// Package readcache is een optionele, wegwerpbare cache voor afgeleide
// paginadata (README, trees, laatste commits, ref-lijsten, tellingen).
// De bron blijft altijd git: een fout in de cache betekent een miss.
//
// Indeling: <root>/cache/<repoID>/{sha,refs}/<hash>. Alleen cache/ is van
// deze package; Clear en LRU raken niets anders onder root aan.
package readcache

import (
	"container/list"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"io/fs"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
)

// DefaultMax is de standaardgrootte: 512 MiB.
const DefaultMax = 512 << 20

// Cache is veilig voor gelijktijdig gebruik. Een nil *Cache is uit.
type Cache struct {
	dir string
	max int64

	mu    sync.Mutex
	lru   *list.List // voorkant = recent
	items map[string]*list.Element
	size  int64

	hits, misses atomic.Int64
	gens         map[int64]uint64
	allGen       uint64
}

type entry struct {
	rel  string
	size int64
}

// Open maakt <root>/cache aan en leest de bestaande inhoud in.
func Open(root string, max int64) (*Cache, error) {
	root = strings.TrimSpace(root)
	if root == "" {
		return nil, errors.New("readcache: geen pad")
	}
	if max <= 0 {
		max = DefaultMax
	}
	dir := filepath.Join(root, "cache")
	if err := os.MkdirAll(dir, 0o750); err != nil {
		return nil, err
	}
	c := &Cache{dir: dir, max: max, lru: list.New(), items: map[string]*list.Element{}, gens: map[int64]uint64{}}
	type found struct {
		rel  string
		size int64
		mod  int64
	}
	var all []found
	_ = filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
		if err != nil || d.IsDir() {
			return nil
		}
		if strings.HasPrefix(d.Name(), ".tmp-") {
			_ = os.Remove(p)
			return nil
		}
		info, err := d.Info()
		if err != nil {
			return nil
		}
		rel, _ := filepath.Rel(dir, p)
		all = append(all, found{rel, info.Size(), info.ModTime().UnixNano()})
		return nil
	})
	// oudste achteraan
	for i := 1; i < len(all); i++ {
		for j := i; j > 0 && all[j].mod > all[j-1].mod; j-- {
			all[j], all[j-1] = all[j-1], all[j]
		}
	}
	for _, f := range all {
		c.items[f.rel] = c.lru.PushBack(&entry{f.rel, f.size})
		c.size += f.size
	}
	c.mu.Lock()
	c.evictLocked()
	c.mu.Unlock()
	return c, nil
}

// Dir is de cachemap zelf (<root>/cache).
func (c *Cache) Dir() string {
	if c == nil {
		return ""
	}
	return c.dir
}

func repoDir(repoID int64) string { return strconv.FormatInt(repoID, 10) }

// rel geeft het pad voor een sleutel. refs=true hoort bij een ref-naam
// en verdwijnt bij elke ref-wijziging; anders is de sleutel onveranderlijk.
func rel(repoID int64, refs bool, key string) string {
	sum := sha256.Sum256([]byte(key))
	ns := "sha"
	if refs {
		ns = "refs"
	}
	return filepath.Join(repoDir(repoID), ns, hex.EncodeToString(sum[:16]))
}

// GetJSON vult v uit de cache. false bij een miss of corrupte entry.
func (c *Cache) GetJSON(repoID int64, refs bool, key string, v any) bool {
	if c == nil {
		return false
	}
	r := rel(repoID, refs, key)
	b, err := os.ReadFile(filepath.Join(c.dir, r))
	if err != nil {
		c.misses.Add(1)
		return false
	}
	// eerste regel is de volledige sleutel, tegen hash-botsingen
	nl := strings.IndexByte(string(b), '\n')
	if nl < 0 || string(b[:nl]) != key || json.Unmarshal(b[nl+1:], v) != nil {
		c.misses.Add(1)
		c.remove(r)
		return false
	}
	c.hits.Add(1)
	c.mu.Lock()
	if el, ok := c.items[r]; ok {
		c.lru.MoveToFront(el)
	}
	c.mu.Unlock()
	return true
}

// Gen is de generatie van een repo. Lees die vóór git en geef hem aan
// PutJSONAt: een ref-wijziging tussendoor maakt de schrijfactie ongeldig.
func (c *Cache) Gen(repoID int64) uint64 {
	if c == nil {
		return 0
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.gens[repoID] + c.allGen<<32
}

// PutJSON schrijft atomisch. Fouten worden genegeerd.
func (c *Cache) PutJSON(repoID int64, refs bool, key string, v any) {
	c.PutJSONAt(repoID, refs, key, v, c.Gen(repoID))
}

// PutJSONAt schrijft alleen als de generatie nog gen is.
func (c *Cache) PutJSONAt(repoID int64, refs bool, key string, v any, gen uint64) {
	if c == nil || strings.ContainsRune(key, '\n') {
		return
	}
	body, err := json.Marshal(v)
	if err != nil {
		return
	}
	data := append([]byte(key+"\n"), body...)
	if int64(len(data)) > c.max/4 {
		return
	}
	r := rel(repoID, refs, key)
	full := filepath.Join(c.dir, r)
	if err := os.MkdirAll(filepath.Dir(full), 0o750); err != nil {
		return
	}
	tmp, err := os.CreateTemp(filepath.Dir(full), ".tmp-*")
	if err != nil {
		return
	}
	_, werr := tmp.Write(data)
	cerr := tmp.Close()
	if werr != nil || cerr != nil || os.Rename(tmp.Name(), full) != nil {
		_ = os.Remove(tmp.Name())
		return
	}
	c.mu.Lock()
	if c.gens[repoID]+c.allGen<<32 != gen {
		c.mu.Unlock()
		_ = os.Remove(full)
		return
	}
	if el, ok := c.items[r]; ok {
		c.size -= el.Value.(*entry).size
		c.lru.Remove(el)
	}
	c.items[r] = c.lru.PushFront(&entry{r, int64(len(data))})
	c.size += int64(len(data))
	c.evictLocked()
	c.mu.Unlock()
}

func (c *Cache) evictLocked() {
	for c.size > c.max {
		el := c.lru.Back()
		if el == nil {
			return
		}
		e := el.Value.(*entry)
		_ = os.Remove(filepath.Join(c.dir, e.rel))
		c.lru.Remove(el)
		delete(c.items, e.rel)
		c.size -= e.size
	}
}

func (c *Cache) remove(r string) {
	_ = os.Remove(filepath.Join(c.dir, r))
	c.mu.Lock()
	if el, ok := c.items[r]; ok {
		c.size -= el.Value.(*entry).size
		c.lru.Remove(el)
		delete(c.items, r)
	}
	c.mu.Unlock()
}

func (c *Cache) dropPrefix(repoID int64, prefix string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.gens[repoID]++
	_ = os.RemoveAll(filepath.Join(c.dir, prefix))
	for r, el := range c.items {
		if r == prefix || strings.HasPrefix(r, prefix+string(filepath.Separator)) {
			c.size -= el.Value.(*entry).size
			c.lru.Remove(el)
			delete(c.items, r)
		}
	}
}

// DropRefs vergeet alles wat van een ref-naam afhangt.
func (c *Cache) DropRefs(repoID int64) {
	if c != nil {
		c.dropPrefix(repoID, filepath.Join(repoDir(repoID), "refs"))
	}
}

// DropRepo vergeet alles van één repo (verwijderd, hernoemd, zichtbaarheid).
func (c *Cache) DropRepo(repoID int64) {
	if c != nil {
		c.dropPrefix(repoID, repoDir(repoID))
	}
}

// Clear leegt de hele cache/-map, en niets daarbuiten.
func (c *Cache) Clear() {
	if c == nil {
		return
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	ents, _ := os.ReadDir(c.dir)
	for _, e := range ents {
		_ = os.RemoveAll(filepath.Join(c.dir, e.Name()))
	}
	c.allGen++
	c.lru.Init()
	c.items = map[string]*list.Element{}
	c.size = 0
}

// Usage is de stand voor Beheer.
type Usage struct {
	Dir     string
	Bytes   int64
	Max     int64
	Entries int
	Hits    int64
	Misses  int64
}

// Usage geeft de huidige stand.
func (c *Cache) Usage() Usage {
	if c == nil {
		return Usage{}
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	return Usage{Dir: c.dir, Bytes: c.size, Max: c.max, Entries: len(c.items), Hits: c.hits.Load(), Misses: c.misses.Load()}
}
