package server

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

	"gitlab.com/Timfa/bluegit/internal/auth"
	"gitlab.com/Timfa/bluegit/internal/config"
	"gitlab.com/Timfa/bluegit/internal/gitgraph"
	"gitlab.com/Timfa/bluegit/internal/store"
)

func TestOverviewRendersCommitGraph(t *testing.T) {
	ts, client, repo := graphTestRepo(t)
	page := read(t, mustGet(t, client, ts.URL+"/tim/grafiek"))
	if !strings.Contains(page, `class="commitgraph"`) {
		t.Fatalf("geen grafiek op het overzicht:\n%s", page)
	}
	if !strings.Contains(page, `aria-label="Commit graph"`) && !strings.Contains(page, `aria-label="Commitgrafiek"`) {
		t.Fatalf("geen toegankelijk label:\n%s", page)
	}
	if !strings.Contains(page, "is-default") || !strings.Contains(page, ">master<") {
		t.Fatalf("hoofdbranch-label ontbreekt:\n%s", page)
	}
	if !strings.Contains(page, ">feature<") || !strings.Contains(page, "is-tag") || !strings.Contains(page, ">v1<") {
		t.Fatalf("feature of tag ontbreekt:\n%s", page)
	}
	if !strings.Contains(page, `stroke="var(--blue)"`) {
		t.Fatalf("hoofdbranch is niet blauw:\n%s", page)
	}
	if !strings.Contains(page, " Q ") || !strings.Contains(page, " H ") {
		t.Fatalf("verwacht afgeronde 90-graden bochten in de svg:\n%s", page)
	}
	if i := strings.Index(page, `class="commitgraph-svg"`); i >= 0 {
		end := strings.Index(page[i:], "</svg>")
		if end >= 0 && strings.Contains(page[i:i+end], "<circle") {
			t.Fatalf("svg mag geen cirkels meer tekenen, de avatar is de knoop")
		}
	}
	if !strings.Contains(page, `data-branch="master"`) {
		t.Fatalf("gloed-attribuut ontbreekt:\n%s", page)
	}
	if !strings.Contains(page, `class="commitgraph-slot"`) || !strings.Contains(page, "--graph-w:") || !strings.Contains(page, "--graph-lanes-w:") || !strings.Contains(page, "--graph-svg-w:") {
		t.Fatalf("inline paneelmaten ontbreken op de slot:\n%s", page)
	}
	if !strings.Contains(page, "grid-template-columns:") {
		t.Fatalf("rijen missen een pixel-grid voor de tekstkolom:\n%s", page)
	}
	if !strings.Contains(page, `style="left:`) {
		t.Fatalf("avatars missen een inline left (moeten op hun lane staan):\n%s", page)
	}
	if i := strings.Index(page, `class="commitgraph-svg"`); i >= 0 {
		end := strings.Index(page[i:], "</svg>")
		chunk := page[i:]
		if end >= 0 {
			chunk = page[i : i+end]
		}
		if strings.Contains(chunk, "viewBox") {
			t.Fatalf("commitgraph-svg mag geen viewBox hebben (schaalt de lanes):\n%s", chunk)
		}
		if !strings.Contains(chunk, "style=\"width:") || !strings.Contains(chunk, "left:") {
			t.Fatalf("commitgraph-svg mist 1:1 inline-maten:\n%s", chunk)
		}
	}
	if strings.Contains(page, "ZgotmplZ") {
		t.Fatalf("css-kleur werd weggestreept:\n%s", page)
	}
	if !strings.Contains(page, "/tim/grafiek/-/commit/") {
		t.Fatalf("geen commitlinks")
	}
	if !strings.Contains(page, "merge feature") && !strings.Contains(page, "feature-work") {
		t.Fatalf("commitberichten ontbreken")
	}
	// Tweede request: nog steeds dezelfde grafiek (cache).
	page2 := read(t, mustGet(t, client, ts.URL+"/tim/grafiek"))
	if !strings.Contains(page2, `class="commitgraph"`) {
		t.Fatal("grafiek verdween bij herladen")
	}
	_ = repo
}

func TestGraphCacheHitSkipsGit(t *testing.T) {
	ts, client, repo := graphTestRepo(t)
	// Eerste opbouw via de pagina, daarna git-binary onbruikbaar maken.
	_ = read(t, mustGet(t, client, ts.URL+"/tim/grafiek"))
	srv := repo
	srv.Git = filepath.Join(t.TempDir(), "niet-bestaande-git")
	g, err := srv.repoGraph(context.Background(), mustStoreRepo(t, srv))
	if err != nil || g == nil || len(g.Rows) == 0 {
		t.Fatalf("cache-hit had geen git nodig, kreeg err=%v g=%v", err, g)
	}
	hits, misses, _, _ := srv.graphs().Stats()
	if hits < 1 || misses < 1 {
		t.Fatalf("verwacht miss+hit, hits=%d misses=%d", hits, misses)
	}
}

func TestGraphColdWarmTimes(t *testing.T) {
	storage := t.TempDir()
	st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	cfg := config.Config{
		BaseURL: "http://git.example", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	page := read(t, mustGet(t, client, ts.URL+"/login"))
	page = read(t, mustPost(t, client, ts.URL+"/new/repo", url.Values{"csrf": {csrfOf(t, page)}, "name": {"tijden"}, "visibility": {"public"}}))
	page = read(t, mustPost(t, client, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"tim"}}))
	token := between(page, `<p class="code">`, "</p>")

	work := t.TempDir()
	git(t, work, "init", "-b", "master")
	git(t, work, "config", "user.email", "tim@example")
	git(t, work, "config", "user.name", "tim")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/tijden.git"
	git(t, work, "remote", "add", "origin", remote)
	for i := 0; i < 24; i++ {
		writeFile(t, filepath.Join(work, "f"), string(rune('a'+i%26))+"\n")
		git(t, work, "add", "f")
		git(t, work, "commit", "-m", "c"+string(rune('a'+i%26)))
	}
	git(t, work, "checkout", "-b", "feature")
	for i := 0; i < 8; i++ {
		writeFile(t, filepath.Join(work, "g"), "g"+string(rune('a'+i))+"\n")
		git(t, work, "add", "g")
		git(t, work, "commit", "-m", "f"+string(rune('a'+i)))
	}
	git(t, work, "checkout", "master")
	git(t, work, "merge", "--no-ff", "-m", "merge feature", "feature")
	git(t, work, "push", "-u", "origin", "master")
	git(t, work, "push", "origin", "feature")

	row, err := st.RepoByPath(context.Background(), "tim", "tijden")
	if err != nil {
		t.Fatal(err)
	}
	ctx := context.Background()
	// De push heeft de cache al via refsChanged gevuld; eerst legen voor een echte koude meting.
	time.Sleep(50 * time.Millisecond)
	srv.dropGraph(row)
	start := time.Now()
	g, err := srv.repoGraph(ctx, row)
	cold := time.Since(start)
	if err != nil || g == nil || len(g.Rows) == 0 {
		t.Fatalf("koud: %v", err)
	}
	start = time.Now()
	g2, err := srv.repoGraph(ctx, row)
	warm := time.Since(start)
	if err != nil || g2 == nil {
		t.Fatalf("warm: %v", err)
	}
	t.Logf("commitgrafiek koud=%s warm=%s rijen=%d lanes=%d", cold, warm, len(g.Rows), g.Lanes)
	if warm > cold && warm > 20*time.Millisecond {
		t.Fatalf("warm (%s) zou ruim onder koud (%s) moeten liggen", warm, cold)
	}
	// Alleen rapporteren; een minieme warm-meting kan door ruis iets hoger zijn
	// als beide sub-milliseconde zijn. Dan is het alsnog een cache-hit.
	hits, _, _, _ := srv.graphs().Stats()
	if hits < 1 {
		t.Fatal("geen cache-hit bij de warme meting")
	}
}

func graphTestRepo(t *testing.T) (*httptest.Server, *http.Client, *Server) {
	t.Helper()
	storage := t.TempDir()
	st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	cfg := config.Config{
		BaseURL: "http://git.example", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	page := read(t, mustGet(t, client, ts.URL+"/login"))
	page = read(t, mustPost(t, client, ts.URL+"/new/repo", url.Values{"csrf": {csrfOf(t, page)}, "name": {"grafiek"}, "visibility": {"public"}}))
	page = read(t, mustPost(t, client, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"tim"}}))
	token := between(page, `<p class="code">`, "</p>")

	work := t.TempDir()
	git(t, work, "init", "-b", "master")
	git(t, work, "config", "user.email", "tim@example")
	git(t, work, "config", "user.name", "tim")
	writeFile(t, filepath.Join(work, "README.md"), "start\n")
	git(t, work, "add", ".")
	git(t, work, "commit", "-m", "start")
	git(t, work, "checkout", "-b", "feature")
	writeFile(t, filepath.Join(work, "extra.txt"), "meer\n")
	git(t, work, "add", "extra.txt")
	git(t, work, "commit", "-m", "feature-work")
	git(t, work, "checkout", "master")
	writeFile(t, filepath.Join(work, "on-master.txt"), "c\n")
	git(t, work, "add", "on-master.txt")
	git(t, work, "commit", "-m", "on-master")
	git(t, work, "tag", "v1")
	git(t, work, "merge", "--no-ff", "-m", "merge feature", "feature")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/grafiek.git"
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master", "--tags")
	git(t, work, "push", "-u", "origin", "feature")
	return ts, client, srv
}

func mustStoreRepo(t *testing.T, s *Server) store.Repo {
	t.Helper()
	row, err := s.Store.RepoByPath(context.Background(), "tim", "grafiek")
	if err != nil {
		t.Fatal(err)
	}
	return row
}

func TestSVGColorsAreSafe(t *testing.T) {
	g := gitgraph.Layout(
		[]gitgraph.Commit{
			{SHA: "m", Subject: `<script>`, Parents: []string{"c", "f"}},
			{SHA: "f", Subject: "x", Parents: []string{"b"}},
			{SHA: "c", Subject: "y", Parents: []string{"b"}},
			{SHA: "b", Subject: "z", Parents: nil},
		},
		[]gitgraph.Ref{{Name: "master", SHA: "m", Kind: "branch"}, {Name: "feature", SHA: "f", Kind: "branch"}},
		"master",
	)
	svg := g.SVG()
	if strings.Contains(svg, "<script") || strings.Contains(svg, `subject`) {
		t.Fatalf("svg lekt tekst: %s", svg)
	}
	if !strings.Contains(svg, "var(--blue)") {
		t.Fatalf("blauw ontbreekt: %s", svg)
	}
	if !strings.Contains(svg, "stroke=\"var(--") {
		t.Fatalf("verwacht stroke in %s", svg)
	}
	if strings.Contains(svg, "<circle") {
		t.Fatalf("geen cirkels in svg: %s", svg)
	}
	if !strings.Contains(svg, " Q ") {
		t.Fatalf("verwacht afgeronde bochten in %s", svg)
	}
}

func TestGraphCSSDoesNotShrinkLanes(t *testing.T) {
	css, err := os.ReadFile("static/style.css")
	if err != nil {
		t.Fatal(err)
	}
	s := string(css)
	for _, want := range []string{
		"min-width: var(--graph-w)",
		"flex: 0 0 var(--graph-w)",
		"minmax(0, 1fr)",
		"text-overflow: ellipsis",
		"--graph-lanes-w",
	} {
		if !strings.Contains(s, want) {
			t.Fatalf("stylesheet mist %q", want)
		}
	}
	for _, want := range []string{
		"grid-column: 1 / -1",
		"@container maincol (min-width: 1142px)",
		"@media (min-width: 1400px)",
		"@media (min-width: 1160px)",
	} {
		if !strings.Contains(s, want) {
			t.Fatalf("stylesheet mist %q", want)
		}
	}
	for _, old := range []string{
		"@media (min-width: 1860px)",
		"@media (min-width: 1140px)",
		"@container maincol (min-width: 900px)",
	} {
		if strings.Contains(s, old) {
			t.Fatalf("oude drempel %q knijpt de hoofdkolom of verbergt de grafiek verkeerd", old)
		}
	}
}

func TestAssetCSSAndJSAreNotCached(t *testing.T) {
	ts, client, _ := graphTestRepo(t)
	css := mustGet(t, client, ts.URL+"/assets/style.css")
	if got := css.Header.Get("Cache-Control"); got != "no-cache" {
		t.Fatalf("style.css Cache-Control=%q, wil no-cache", got)
	}
	_ = css.Body.Close()
	js := mustGet(t, client, ts.URL+"/assets/repo.js")
	if got := js.Header.Get("Cache-Control"); got != "no-cache" {
		t.Fatalf("repo.js Cache-Control=%q, wil no-cache", got)
	}
	_ = js.Body.Close()
}
