package server

import (
	"context"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"gitlab.com/Timfa/bluegit/internal/readcache"
	"gitlab.com/Timfa/bluegit/internal/store"
)

func cacheServer(t *testing.T) (*Server, string, func(path string) (int, string), *http.Client, string, string) {
	t.Helper()
	srv, ts, st := mergeFixServer(t)
	srv.StateDir = t.TempDir()
	root := t.TempDir()
	if err := srv.opSetCache(root, 64); err != nil {
		t.Fatal(err)
	}
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)
	work := pushPair(t, ts, token, "cached", "hallo\n", "verder\n")
	git(t, work, "checkout", "master")
	writeFile(t, filepath.Join(work, "README.md"), "# Eerste versie\n")
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "readme")
	git(t, work, "push", "origin", "master")
	_ = st
	get := func(path string) (int, string) {
		res, err := tim.Get(ts.URL + path)
		if err != nil {
			t.Fatal(err)
		}
		return res.StatusCode, read(t, res)
	}
	return srv, root, get, tim, ts.URL, work
}

func repoOf(t *testing.T, srv *Server, name string) store.Repo {
	t.Helper()
	repos, err := srv.Store.AllRepos(context.Background())
	if err != nil {
		t.Fatal(err)
	}
	for _, r := range repos {
		if r.Name == name {
			return r
		}
	}
	t.Fatalf("repo %s ontbreekt", name)
	return store.Repo{}
}

// waitWarm wacht tot de achtergrond-vulling na een push klaar is.
func waitWarm(srv *Server) {
	time.Sleep(300 * time.Millisecond)
}

func TestReadCacheServesOverviewWithoutRepoDisk(t *testing.T) {
	srv, root, get, _, _, work := cacheServer(t)
	waitWarm(srv)
	pages := []string{"/tim/cached", "/tim/cached/-/branches", "/tim/cached/-/tags"}
	for _, p := range pages {
		if code, _ := get(p); code != 200 {
			t.Fatalf("%s: %d", p, code)
		}
	}
	if srv.ReadCache().Usage().Entries == 0 {
		t.Fatal("niets gecachet")
	}
	// HDD 'weg': de repository-map tijdelijk verplaatsen.
	repo := repoOf(t, srv, "cached")
	dir := srv.gdir(repo)
	if err := os.Rename(dir, dir+".weg"); err != nil {
		t.Fatal(err)
	}
	_, body := get("/tim/cached")
	if !strings.Contains(body, "Eerste versie") {
		t.Fatal("README niet uit de cache")
	}
	if _, body := get("/tim/cached/-/branches"); !strings.Contains(body, "topic") {
		t.Fatal("branches niet uit de cache")
	}
	if err := os.Rename(dir+".weg", dir); err != nil {
		t.Fatal(err)
	}

	// write-through: na een push nooit de oude README
	writeFile(t, filepath.Join(work, "README.md"), "# Tweede versie\n")
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "readme 2")
	git(t, work, "push", "origin", "master")
	git(t, work, "push", "origin", "master:nieuwe-branch")
	_, body = get("/tim/cached")
	if !strings.Contains(body, "Tweede versie") || strings.Contains(body, "Eerste versie") {
		t.Fatal("verouderde README na push")
	}
	if _, body := get("/tim/cached/-/branches"); !strings.Contains(body, "nieuwe-branch") {
		t.Fatal("nieuwe branch ontbreekt")
	}

	// corrupte entries zijn een miss, geen fout
	_ = filepath.Walk(filepath.Join(root, "cache"), func(p string, info os.FileInfo, err error) error {
		if err == nil && !info.IsDir() {
			_ = os.WriteFile(p, []byte("kapot"), 0o600)
		}
		return nil
	})
	if code, body := get("/tim/cached"); code != 200 || !strings.Contains(body, "Tweede versie") {
		t.Fatalf("corrupte cache brak de pagina: %d", code)
	}
}

func TestReadCacheRespectsVisibility(t *testing.T) {
	srv, _, get, _, base, _ := cacheServer(t)
	waitWarm(srv)
	get("/tim/cached")
	repo := repoOf(t, srv, "cached")
	anon := &http.Client{}
	res, _ := anon.Get(base + "/tim/cached")
	res.Body.Close()
	if res.StatusCode != 200 {
		t.Fatalf("publiek anoniem: %d", res.StatusCode)
	}
	before := srv.ReadCache().Usage().Entries
	tim, _ := srv.Store.UserByUsername(context.Background(), "tim")
	if err := srv.opUpdateRepo(context.Background(), tim, repo, repo.Description, "private"); err != nil {
		t.Fatal(err)
	}
	if after := srv.ReadCache().Usage().Entries; after >= before {
		t.Fatalf("cache niet gewist bij zichtbaarheid: %d -> %d", before, after)
	}
	get("/tim/cached") // eigenaar warmt opnieuw
	for _, p := range []string{"/tim/cached", "/tim/cached/-/branches", "/tim/cached/-/tags"} {
		res, _ := anon.Get(base + p)
		body := read(t, res)
		if res.StatusCode == 200 || strings.Contains(body, "Eerste versie") {
			t.Fatalf("%s lekt naar anoniem: %d", p, res.StatusCode)
		}
	}
}

func TestReadCacheClearKeepsData(t *testing.T) {
	srv, root, get, _, _, _ := cacheServer(t)
	get("/tim/cached")
	keep := filepath.Join(root, "data", "bewaar.txt")
	_ = os.MkdirAll(filepath.Dir(keep), 0o750)
	_ = os.WriteFile(keep, []byte("x"), 0o600)
	srv.ReadCache().Clear()
	if srv.ReadCache().Usage().Entries != 0 {
		t.Fatal("niet leeg")
	}
	if _, err := os.Stat(keep); err != nil {
		t.Fatal("data/ geraakt")
	}
	repo := repoOf(t, srv, "cached")
	srv.ReadCache().PutJSON(repo.ID, false, "x", 1)
	tim, _ := srv.Store.UserByUsername(context.Background(), "tim")
	if err := srv.opDeleteRepo(context.Background(), tim, repo, "cached", false); err != nil {
		t.Fatal(err)
	}
	if srv.ReadCache().Usage().Entries != 0 {
		t.Fatal("cache van verwijderde repo bleef staan")
	}
}

func TestSetCacheValidates(t *testing.T) {
	srv, _, _ := mergeFixServer(t)
	srv.StateDir = t.TempDir()
	if srv.opSetCache("relatief", 0) == nil {
		t.Fatal("relatief pad geaccepteerd")
	}
	if srv.opSetCache(filepath.Join(srv.StoragePath(), "cache"), 0) == nil {
		t.Fatal("pad in opslag geaccepteerd")
	}
	root := t.TempDir()
	if err := srv.opSetCache(root, 0); err != nil || srv.ReadCache() == nil {
		t.Fatal(err)
	}
	// blijft bewaard over een herstart
	srv2 := &Server{StateDir: srv.StateDir}
	srv2.InitReadCache()
	if srv2.ReadCache() == nil || srv2.CacheConfig().Path != root {
		t.Fatal("instelling niet bewaard")
	}
	if err := srv.opSetCache("", 0); err != nil || srv.ReadCache() != nil {
		t.Fatal("uitzetten mislukt")
	}
}

// TestReadCacheColdWarm meet een overzichtspagina koud en warm.
func TestReadCacheColdWarm(t *testing.T) {
	srv, _, get, _, _, _ := cacheServer(t)
	waitWarm(srv)
	const n = 20
	measure := func() time.Duration {
		start := time.Now()
		for i := 0; i < n; i++ {
			get("/tim/cached")
		}
		return time.Since(start) / n
	}
	keep := srv.ReadCache()
	srv.SetReadCache(nil)
	cold := measure()
	srv.SetReadCache(keep)
	get("/tim/cached")
	warm := measure()
	t.Logf("overzicht: zonder cache %v, warm %v per pagina", cold, warm)
	if warm > cold*2 {
		t.Fatalf("warm (%v) veel trager dan koud (%v)", warm, cold)
	}
	_ = readcache.DefaultMax
}
