package gitrepo

import ( "os" "path/filepath" "sync" "testing" "time"

"gitweb/internal/store"

)

// dirCount returns the number of children under the cache root. func dirCount(t *testing.T, root string) int { t.Helper() children, err := os.ReadDir(root) if err != nil { t.Fatal(err) } return len(children) }

// twoRepos builds two distinct bare repos in one LocalStore and returns the // store and their repo paths. func twoRepos(t *testing.T) (st store.Store, pathA, pathB string) { t.Helper() root := t.TempDir() pathA = makeBareRepo(t, root, "u@d.com", "a.git") pathB = makeBareRepo(t, root, "u@d.com", "b.git") return store.NewLocalStore(root), pathA, pathB }

// repoBytes returns the materialized size of repoPath (sum of manifest sizes). func repoBytes(t *testing.T, st store.Store, repoPath string) int64 { t.Helper() c := newTestCache(t, st, CacheOptions{}) _, release, err := c.Get(repoPath) if err != nil { t.Fatal(err) } defer release() c.mu.Lock() defer c.mu.Unlock() return c.total }

func TestCacheByteEviction(t *testing.T) { st, pathA, pathB := twoRepos(t) sizeA := repoBytes(t, st, pathA)

// Budget fits one repo but not two: getting B must evict A.
dir := t.TempDir()
c := newTestCache(t, st, CacheOptions{Dir: dir, BudgetBytes: sizeA + sizeA/2})

rA, releaseA, err := c.Get(pathA)
if err != nil {
	t.Fatal(err)
}
releaseA()
if got := dirCount(t, dir); got != 1 {
	t.Fatalf("after Get A: %d dirs, want 1", got)
}

_, releaseB, err := c.Get(pathB)
if err != nil {
	t.Fatal(err)
}
releaseB()
if got := dirCount(t, dir); got != 1 {
	t.Fatalf("after Get B evicted A: %d dirs, want 1", got)
}

// A re-materializes on demand as a fresh entry.
rA2, releaseA2, err := c.Get(pathA)
if err != nil {
	t.Fatal(err)
}
defer releaseA2()
if rA2 == rA {
	t.Fatal("expected evicted repo to re-materialize (different pointer)")
}

}

func TestCacheHoldAcrossEviction(t *testing.T) { st, pathA, pathB := twoRepos(t) sizeA := repoBytes(t, st, pathA)

dir := t.TempDir()
c := newTestCache(t, st, CacheOptions{Dir: dir, BudgetBytes: sizeA + sizeA/2})

rA, releaseA, err := c.Get(pathA)
if err != nil {
	t.Fatal(err)
}
// A is still held when B evicts it: its dir must survive.
_, releaseB, err := c.Get(pathB)
if err != nil {
	t.Fatal(err)
}
defer releaseB()
if got := dirCount(t, dir); got != 2 {
	t.Fatalf("evicted-but-held entry deleted early: %d dirs, want 2", got)
}
// The held repo still reads from its (retired) backing dir.
if _, err := rA.Head(); err != nil {
	t.Fatalf("held repo unreadable after eviction: %v", err)
}
releaseA()
if got := dirCount(t, dir); got != 1 {
	t.Fatalf("after release: %d dirs, want 1", got)
}

}

func TestCacheInvalidateDuringHold(t *testing.T) { root := t.TempDir() repoPath := makeBareRepo(t, root, "u@d.com", "demo.git") st := store.NewLocalStore(root)

dir := t.TempDir()
c := newTestCache(t, st, CacheOptions{Dir: dir})

r1, release1, err := c.Get(repoPath)
if err != nil {
	t.Fatal(err)
}
c.Invalidate(repoPath)
if got := dirCount(t, dir); got != 1 {
	t.Fatalf("invalidated-but-held entry deleted early: %d dirs, want 1", got)
}
if _, err := r1.Head(); err != nil {
	t.Fatalf("held repo unreadable after Invalidate: %v", err)
}

// A new Get re-materializes into a fresh dir.
r2, release2, err := c.Get(repoPath)
if err != nil {
	t.Fatal(err)
}
defer release2()
if r2 == r1 {
	t.Fatal("expected fresh repo after Invalidate")
}
if got := dirCount(t, dir); got != 2 {
	t.Fatalf("old + new dirs: %d, want 2", got)
}

release1()
if got := dirCount(t, dir); got != 1 {
	t.Fatalf("old dir survives its last release: %d dirs, want 1", got)
}

}

func TestCacheConcurrentGet(t *testing.T) { root := t.TempDir() repoPath := makeBareRepo(t, root, "u@d.com", "demo.git") st := store.NewLocalStore(root)

dir := t.TempDir()
c := newTestCache(t, st, CacheOptions{Dir: dir})

const n = 8
var wg sync.WaitGroup
errs := make(chan error, n)
for range n {
	wg.Add(1)
	go func() {
		defer wg.Done()
		repo, release, err := c.Get(repoPath)
		if err != nil {
			errs <- err
			return
		}
		defer release()
		if _, err := repo.Head(); err != nil {
			errs <- err
		}
	}()
}
wg.Wait()
close(errs)
for err := range errs {
	t.Fatal(err)
}

// Race losers cleaned up after themselves: one dir remains.
if got := dirCount(t, dir); got != 1 {
	t.Fatalf("%d dirs after concurrent Gets, want 1", got)
}
// And it is a usable cache hit.
_, release, err := c.Get(repoPath)
if err != nil {
	t.Fatal(err)
}
release()

}

func TestCacheStaleReleaseDeletesOldDir(t *testing.T) { root := t.TempDir() repoPath := makeBareRepo(t, root, "u@d.com", "demo.git") st := store.NewLocalStore(root)

dir := t.TempDir()
c := newTestCache(t, st, CacheOptions{Dir: dir})

_, release1, err := c.Get(repoPath)
if err != nil {
	t.Fatal(err)
}
release1()

// Bump the repo's mtime so LocalStore.Seq changes; the stale entry (now
// unreferenced) is retired and deleted during the next Get.
later := time.Now().Add(2 * time.Second)
if err := os.Chtimes(filepath.Join(root, repoPath, "HEAD"), later, later); err != nil {
	t.Fatal(err)
}
_, release2, err := c.Get(repoPath)
if err != nil {
	t.Fatal(err)
}
defer release2()
if got := dirCount(t, dir); got != 1 {
	t.Fatalf("stale dir not deleted: %d dirs, want 1", got)
}

}

func TestCacheSingleRepoOverBudget(t *testing.T) { root := t.TempDir() repoPath := makeBareRepo(t, root, "u@d.com", "demo.git") st := store.NewLocalStore(root)

// Budget of 1 byte: the sole entry must still be kept and servable.
dir := t.TempDir()
c := newTestCache(t, st, CacheOptions{Dir: dir, BudgetBytes: 1})

r1, release1, err := c.Get(repoPath)
if err != nil {
	t.Fatal(err)
}
release1()
if got := dirCount(t, dir); got != 1 {
	t.Fatalf("sole over-budget entry evicted: %d dirs, want 1", got)
}
r2, release2, err := c.Get(repoPath)
if err != nil {
	t.Fatal(err)
}
defer release2()
if r1 != r2 {
	t.Fatal("expected the over-budget entry to be reused")
}

}