package repository

import (
	"crypto/rand"
	"encoding/binary"

	"github.com/restic/restic/internal/restic"

	"github.com/dchest/siphash"
)

// An indexMap is a chained hash table that maps blob IDs to indexEntries.
// It allows storing multiple entries with the same key.
//
// IndexMap uses some optimizations that are not compatible with supporting
// deletions.
//
// The buckets in this hash table contain only pointers, rather than inlined
// key-value pairs like the standard Go map. This way, only a pointer array
// needs to be resized when the table grows, preventing memory usage spikes.
type indexMap struct {
	// The number of buckets is always a power of two and never zero.
	buckets    []*indexEntry
	numentries uint

	key0, key1 uint64 // Key for hash randomization.

	free *indexEntry // Free list.
}

const (
	growthFactor = 2 // Must be a power of 2.
	maxLoad      = 4 // Max. number of entries per bucket.
)

// add inserts an indexEntry for the given arguments into the map,
// using id as the key.
func (m *indexMap) add(id restic.ID, packIdx int, offset, length uint32) {
	switch {
	case m.numentries == 0: // Lazy initialization.
		m.init()
	case m.numentries >= maxLoad*uint(len(m.buckets)):
		m.grow()
	}

	h := m.hash(id)
	e := m.newEntry()
	e.id = id
	e.next = m.buckets[h] // Prepend to existing chain.
	e.packIndex = packIdx
	e.offset = offset
	e.length = length

	m.buckets[h] = e
	m.numentries++
}

// foreach calls fn for all entries in the map, until fn returns false.
func (m *indexMap) foreach(fn func(*indexEntry) bool) {
	for _, e := range m.buckets {
		for e != nil {
			if !fn(e) {
				return
			}
			e = e.next
		}
	}
}

// foreachWithID calls fn for all entries with the given id.
func (m *indexMap) foreachWithID(id restic.ID, fn func(*indexEntry)) {
	if len(m.buckets) == 0 {
		return
	}

	h := m.hash(id)
	for e := m.buckets[h]; e != nil; e = e.next {
		if e.id != id {
			continue
		}
		fn(e)
	}
}

// get returns the first entry for the given id.
func (m *indexMap) get(id restic.ID) *indexEntry {
	if len(m.buckets) == 0 {
		return nil
	}

	h := m.hash(id)
	for e := m.buckets[h]; e != nil; e = e.next {
		if e.id == id {
			return e
		}
	}
	return nil
}

func (m *indexMap) grow() {
	old := m.buckets
	m.buckets = make([]*indexEntry, growthFactor*len(m.buckets))

	for _, e := range old {
		for e != nil {
			h := m.hash(e.id)
			next := e.next
			e.next = m.buckets[h]
			m.buckets[h] = e
			e = next
		}
	}
}

func (m *indexMap) hash(id restic.ID) uint {
	// We use siphash with a randomly generated 128-bit key, to prevent
	// backups of specially crafted inputs from degrading performance.
	// While SHA-256 should be collision-resistant, for hash table indices
	// we use only a few bits of it and finding collisions for those is
	// much easier than breaking the whole algorithm.
	h := uint(siphash.Hash(m.key0, m.key1, id[:]))
	return h & uint(len(m.buckets)-1)
}

func (m *indexMap) init() {
	const initialBuckets = 64
	m.buckets = make([]*indexEntry, initialBuckets)

	var buf [16]byte
	if _, err := rand.Read(buf[:]); err != nil {
		panic(err) // Very little we can do here.
	}
	m.key0 = binary.LittleEndian.Uint64(buf[:8])
	m.key1 = binary.LittleEndian.Uint64(buf[8:])
}

func (m *indexMap) len() uint { return m.numentries }

func (m *indexMap) newEntry() *indexEntry {
	// Allocating in batches means that we get closer to optimal space usage,
	// as Go's malloc will overallocate for structures of size 56 (indexEntry
	// on amd64).
	//
	// 256*56 and 256*48 both have minimal malloc overhead among reasonable sizes.
	// See src/runtime/sizeclasses.go in the standard library.
	const entryAllocBatch = 256

	if m.free == nil {
		free := new([entryAllocBatch]indexEntry)
		for i := range free[:len(free)-1] {
			free[i].next = &free[i+1]
		}
		m.free = &free[0]
	}

	e := m.free
	m.free = m.free.next

	return e
}

type indexEntry struct {
	id        restic.ID
	next      *indexEntry
	packIndex int // Position in containing Index's packs field.
	offset    uint32
	length    uint32
}