package server

import (
	"context"
	"encoding/json"
	"io"
	"net/http"
	"net/http/cookiejar"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"
	"testing"
	"time"

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

func TestWebRepoPushAndSecretBoundary(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	storage := t.TempDir()
	key := bytes32()
	st, err := store.Open(filepath.Join(storage, "bluegit.db"), key)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	cfg := config.Config{
		BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
		SSH:  config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
		CI:   config.CI{Enabled: false},
	}
	cfg.Auth.BaseURL = "https://auth.timfalken.com"
	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}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	body := read(t, res)
	if res.StatusCode != 200 || !strings.Contains(body, "Overview") {
		t.Fatalf("login %d %s", res.StatusCode, body)
	}
	logo, err := client.Get(ts.URL + "/assets/logo.svg")
	if err != nil {
		t.Fatal(err)
	}
	wantLogo, err := os.ReadFile("../../assets/logo.svg")
	if err != nil {
		t.Fatal(err)
	}
	if logo.StatusCode != 200 || read(t, logo) != string(wantLogo) {
		t.Fatalf("logo %d wijkt af van assets/logo.svg", logo.StatusCode)
	}
	if ct := logo.Header.Get("Content-Type"); !strings.Contains(ct, "image/svg+xml") {
		t.Fatalf("favicon-type %s", ct)
	}
	csrf := csrfOf(t, body)
	form := url.Values{"csrf": {csrf}, "name": {"demo"}, "description": {"eerste"}, "visibility": {"private"}}
	res, err = client.PostForm(ts.URL+"/new/repo", form)
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, "tim/demo") {
		t.Fatalf("repo pagina:\n%s", body)
	}
	if !strings.Contains(body, "git@git.timfalken.com:tim/demo.git") {
		t.Fatalf("clone-URL hoort de publieke SSH-poort te tonen:\n%s", body)
	}
	if strings.Contains(body, ":2222/") {
		t.Fatalf("clone-URL toont de bindpoort:\n%s", body)
	}
	sshURL := "git@git.timfalken.com:tim/demo.git"
	httpURL := "http://127.0.0.1:9/tim/demo.git"
	assertCloneMenu(t, body, "overzicht", sshURL, httpURL)
	res, err = client.Get(ts.URL + "/tim/demo/-/tree")
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusOK {
		t.Fatalf("bestanden %d", res.StatusCode)
	}
	assertCloneMenu(t, read(t, res), "bestanden", sshURL, httpURL)

	res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, body)}, "name": {"test"}})
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	token := between(body, `<p class="code">`, "</p>")
	if !strings.HasPrefix(token, "bg_") {
		t.Fatalf("token pagina:\n%s", body)
	}

	work := t.TempDir()
	git(t, work, "init", "-b", "master")
	git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
	git(t, work, "config", "user.name", "tim")
	if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("hallo bluegit\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "eerste commit")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/demo.git"
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")

	res, err = client.Get(ts.URL + "/tim/demo")
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, "eerste commit") || !strings.Contains(body, "README.md") {
		t.Fatalf("na push:\n%s", body)
	}
	res, err = client.Get(ts.URL + "/tim/demo/-/blob/README.md")
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, "hallo bluegit") {
		t.Fatalf("blob:\n%s", body)
	}

	ctx := context.Background()
	ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	repo, err := st.RepoByPath(ctx, "tim", "demo")
	if err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
		t.Fatal(err)
	}
	sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
	if err != nil {
		t.Fatal(err)
	}
	adaJar, _ := cookiejar.New(nil)
	adaClient := &http.Client{Jar: adaJar}
	u, _ := url.Parse(ts.URL)
	adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
	res, err = adaClient.Get(ts.URL + "/")
	if err != nil {
		t.Fatal(err)
	}
	adaCSRF := csrfOf(t, read(t, res))
	res, err = adaClient.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
		"csrf": {adaCSRF}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("ontwikkelaar mocht een geheim schrijven: %d", res.StatusCode)
	}
	_ = res.Body.Close()

	res, err = client.Get(ts.URL + "/tim/demo/-/settings?tab=geheimen")
	if err != nil {
		t.Fatal(err)
	}
	ownerPage := read(t, res)
	res, err = client.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
		"csrf": {csrfOf(t, ownerPage)}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
	})
	if err != nil {
		t.Fatal(err)
	}
	saved := read(t, res)
	if strings.Contains(saved, "super-geheim-waarde") {
		t.Fatal("geheimwaarde staat op de pagina")
	}
	if !strings.Contains(saved, "TOKEN") {
		t.Fatalf("naam ontbreekt:\n%s", saved)
	}

	res, err = client.PostForm(ts.URL+"/tim/demo/-/webhooks", url.Values{
		"csrf": {csrfOf(t, saved)}, "name": {"kapot"}, "preset": {"generic"},
		"url": {"https://example.test/hook"}, "branch_filter": {"re:("}, "event_push": {"1"},
	})
	if err != nil {
		t.Fatal(err)
	}
	hookPage := read(t, res)
	if !strings.Contains(hookPage, "branchfilter") && !strings.Contains(hookPage, "error") && !strings.Contains(strings.ToLower(hookPage), "regex") {
		t.Fatalf("kapot filter:\n%s", hookPage)
	}
}

func TestSetupChoosesStorage(t *testing.T) {
	storage := t.TempDir()
	stateDir := t.TempDir()
	key := bytes32()
	st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), key)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	cfg := config.Config{
		BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0",
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
		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", StateDir: stateDir}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)

	res, err := http.Get(ts.URL + "/tim/demo.git/info/refs?service=git-upload-pack")
	if err != nil {
		t.Fatal(err)
	}
	body := read(t, res)
	if res.StatusCode != http.StatusServiceUnavailable || !strings.Contains(body, "not set up yet") {
		t.Fatalf("git zonder opslag: %d %s", res.StatusCode, body)
	}

	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	res, err = client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	page := read(t, res)
	if res.StatusCode != 200 || !strings.Contains(page, "Choose storage") {
		t.Fatalf("setup:\n%s", page)
	}
	res, err = client.PostForm(ts.URL+"/setup", url.Values{"csrf": {csrfOf(t, page)}, "path": {"relatief"}})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if !strings.Contains(page, "absolute") {
		t.Fatalf("relatief pad:\n%s", page)
	}
	res, err = client.PostForm(ts.URL+"/setup", url.Values{"csrf": {csrfOf(t, page)}, "path": {storage}})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if !strings.Contains(page, "Overview") || !strings.Contains(page, "free.") {
		t.Fatalf("na opslaan:\n%s", page)
	}
	if srv.StoragePath() != storage {
		t.Fatalf("pad %s", srv.StoragePath())
	}
	saved, err := os.ReadFile(filepath.Join(stateDir, "storage_path"))
	if err != nil || strings.TrimSpace(string(saved)) != storage {
		t.Fatalf("bestand %q %v", saved, err)
	}
	res, err = client.Get(ts.URL + "/setup")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	info, err := state.Inspect(storage)
	if err != nil {
		t.Fatal(err)
	}
	n, err := state.DirSize(context.Background(), storage)
	if err != nil {
		t.Fatal(err)
	}
	pct := state.Percent(info.Used(), info.Total)
	for _, want := range []string{
		"does not move",
		"BlueGit uses " + state.Format(n),
		"Disk: " + state.Format(info.Total),
		state.Format(info.Used()) + " used",
		state.Format(info.Free) + " free.",
		`<svg class="diskbar-svg"`,
		`class="fill" width="` + strconv.Itoa(pct) + `"`,
	} {
		if !strings.Contains(page, want) {
			t.Fatalf("mist %q\n%s", want, page)
		}
	}
	if strings.Contains(page, "Count stopped early") {
		t.Fatal("kleine map hoort volledig geteld")
	}
	res, err = http.Get(ts.URL + "/tim/demo.git/info/refs?service=git-upload-pack")
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if res.StatusCode == http.StatusServiceUnavailable {
		t.Fatalf("git blijft geblokkeerd: %s", body)
	}

	ada, err := st.UpsertUser(context.Background(), 2, "ada", "", true)
	if err != nil {
		t.Fatal(err)
	}
	if ada.InstanceAdmin {
		t.Fatal("is_admin werd installatiebeheerder")
	}
	sess, err := st.CreateSession(context.Background(), ada.ID, "dev", time.Now().Add(time.Hour))
	if err != nil {
		t.Fatal(err)
	}
	adaJar, _ := cookiejar.New(nil)
	adaClient := &http.Client{Jar: adaJar}
	u, _ := url.Parse(ts.URL)
	adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
	res, err = adaClient.Get(ts.URL + "/setup")
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("ada setup %d %s", res.StatusCode, read(t, res))
	}
	_ = res.Body.Close()
}

func TestNameBecomesSlug(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	storage := t.TempDir()
	st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	cfg := config.Config{
		BaseURL: "http://git.timfalken.com", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
		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}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	_ = read(t, res)
	res, err = client.Get(ts.URL + "/new")
	if err != nil {
		t.Fatal(err)
	}
	page := read(t, res)
	if !strings.Contains(page, `data-kind="repo"`) || !strings.Contains(page, "/assets/slug.js") {
		t.Fatalf("formulier:\n%s", page)
	}
	if strings.Contains(page, `pattern=`) {
		t.Fatalf("het naamveld blokkeert spaties in de browser:\n%s", page)
	}

	prev, err := client.Get(ts.URL + "/new/slug?kind=repo&name=test+repo")
	if err != nil {
		t.Fatal(err)
	}
	var body struct {
		Name string `json:"name"`
		URL  string `json:"url"`
	}
	if err := json.NewDecoder(prev.Body).Decode(&body); err != nil {
		t.Fatal(err)
	}
	prev.Body.Close()
	if body.Name != "test-repo" || body.URL != "git.timfalken.com/tim/test-repo" {
		t.Fatalf("preview %+v", body)
	}
	prev, err = client.Get(ts.URL + "/new/slug?kind=group&name=Test+Groep")
	if err != nil {
		t.Fatal(err)
	}
	if err := json.NewDecoder(prev.Body).Decode(&body); err != nil {
		t.Fatal(err)
	}
	prev.Body.Close()
	if body.Name != "test-groep" || body.URL != "git.timfalken.com/groups/test-groep" {
		t.Fatalf("groep-preview %+v", body)
	}
	prev, err = client.Get(ts.URL + "/new/slug?kind=repo&name=foo.git")
	if err != nil {
		t.Fatal(err)
	}
	if err := json.NewDecoder(prev.Body).Decode(&body); err != nil {
		t.Fatal(err)
	}
	prev.Body.Close()
	if body.Name != "" || body.URL != "" {
		t.Fatalf("ongeldige preview %+v", body)
	}

	csrf := csrfOf(t, page)
	res, err = client.PostForm(ts.URL+"/new/repo", url.Values{"csrf": {csrf}, "name": {"test repo"}, "visibility": {"private"}})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if !strings.Contains(page, "tim/test-repo") || strings.Contains(page, "test repo") {
		t.Fatalf("repository:\n%s", page)
	}
	res, err = client.PostForm(ts.URL+"/new/group", url.Values{"csrf": {csrfOf(t, page)}, "name": {"Test Groep"}})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if !strings.Contains(page, ">Test Groep<") || !strings.Contains(page, "test-groep") {
		t.Fatalf("groep:\n%s", page)
	}
	prev, err = client.Get(ts.URL + "/new/slug?kind=repo&name=test+repo&owner=test-groep")
	if err != nil {
		t.Fatal(err)
	}
	if err := json.NewDecoder(prev.Body).Decode(&body); err != nil {
		t.Fatal(err)
	}
	prev.Body.Close()
	if body.URL != "git.timfalken.com/test-groep/test-repo" {
		t.Fatalf("preview met groep %+v", body)
	}
	res, err = client.PostForm(ts.URL+"/new/repo", url.Values{"csrf": {csrfOf(t, page)}, "name": {"foo.git"}})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if !strings.Contains(page, "This name cannot be used.") {
		t.Fatalf("weigering:\n%s", page)
	}
}

func TestProjectOverviewAndFiles(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	hook := filepath.Join(t.TempDir(), "bluegit")
	build := exec.Command("go", "build", "-buildvcs=false", "-o", hook, "gitlab.com/Timfa/bluegit/cmd/bluegit")
	build.Env = append(os.Environ(), "CGO_ENABLED=0")
	if out, err := build.CombinedOutput(); err != nil {
		t.Fatalf("hook bouwen: %v\n%s", err, out)
	}

	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://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
		SSH:  config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
	}
	cfg.Auth.BaseURL = "https://auth.timfalken.com"
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: hook}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)

	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	csrf := csrfOf(t, read(t, res))
	res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
		"csrf": {csrf}, "name": {"legacy cycles"}, "description": {"Simulatie"}, "visibility": {"public"},
	})
	if err != nil {
		t.Fatal(err)
	}
	created := read(t, res)
	if !strings.Contains(created, "tim/legacy-cycles") || !strings.Contains(created, "No commits yet.") {
		t.Fatalf("lege repo:\n%s", created)
	}
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "legacy-cycles")
	if err != nil {
		t.Fatal(err)
	}
	pats, err := st.ProtectedPatterns(ctx, repo.ID)
	if err != nil || len(pats) != 1 || pats[0] != "master" {
		t.Fatalf("master hoort beschermd te zijn: %v %v", pats, err)
	}

	res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, created)}, "name": {"laptop"}})
	if err != nil {
		t.Fatal(err)
	}
	token := between(read(t, res), `<p class="code">`, "</p>")
	work := t.TempDir()
	git(t, work, "init", "-b", "master")
	git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
	git(t, work, "config", "user.name", "tim")
	readme := "# Legacy Cycles\n\nEen kleine simulatie.\n\n| Sleutel | Waarde |\n| --- | --- |\n| Taal | Rust |\n| Netwerk | UDP |\n\nZie [regels](docs/regels.md).\n"
	writeFile(t, filepath.Join(work, "README.md"), readme)
	writeFile(t, filepath.Join(work, "LICENSE"), "MIT\n")
	writeFile(t, filepath.Join(work, "Cargo.toml"), "[package]\nname = \"legacy-cycles\"\nversion = \"0.1.0\"\n\n# debug\n[profile.dev]\nopt-level = 1\n")
	writeFile(t, filepath.Join(work, "src", "main.go"), "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"hallo\")\n}\n")
	writeFile(t, filepath.Join(work, "crates", "sim", "lib.rs"), "pub fn tick() {}\n")
	git(t, work, "add", ".")
	git(t, work, "commit", "-m", "eerste commit")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/legacy-cycles.git"
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")

	res, err = client.Get(ts.URL + "/tim/legacy-cycles")
	if err != nil {
		t.Fatal(err)
	}
	body := read(t, res)
	for _, want := range []string{
		`class="on">Overview`,
		`/-/tree?rev=master">Files`,
		"Project information",
		"Last commit",
		"Last update",
		"eerste commit",
		"Find file",
		`aria-label="Protected"`,
		"Created on ",
		"1 commit",
		"<table class=\"md\">",
		"<th>Sleutel</th>",
		"<td>Rust</td>",
		"/tim/legacy-cycles/-/blob/docs/regels.md?rev=master",
		"/-/blob/README.md?rev=master\">README",
		"/-/blob/LICENSE?rev=master\">LICENSE",
		"/-/tree/crates?rev=master",
		"/-/tree/src?rev=master",
		"Simulatie",
		"git@git.timfalken.com:tim/legacy-cycles.git",
	} {
		if !strings.Contains(body, want) {
			t.Fatalf("overzicht mist %q\n%s", want, body)
		}
	}
	crates := strings.Index(body, "/-/tree/crates")
	cargo := strings.Index(body, "Cargo.toml")
	if crates < 0 || cargo < 0 || crates > cargo {
		t.Fatal("mappen horen voor bestanden")
	}

	res, err = client.Get(ts.URL + "/tim/legacy-cycles/-/tree")
	if err != nil {
		t.Fatal(err)
	}
	tree := read(t, res)
	for _, want := range []string{
		`class="on">Files`,
		`data-tree-filter`,
		`data-path="src/main.go"`,
		`data-path="crates/sim"`,
		`data-repo="tim/legacy-cycles"`,
		`class="fill"`,
		`class="filepane"`,
		`class="twist"`,
		`aria-expanded="false"`,
		"This directory is empty.",
	} {
		if want == "This directory is empty." {
			if strings.Contains(tree, want) {
				t.Fatalf("root is niet leeg:\n%s", tree)
			}
			continue
		}
		if !strings.Contains(tree, want) {
			t.Fatalf("bestanden mist %q\n%s", want, tree)
		}
	}
	if strings.Contains(tree, `aria-expanded="true"`) || strings.Contains(tree, ` dir open`) {
		t.Fatalf("root hoort dichtgeklapt:\n%s", tree)
	}

	res, err = client.Get(ts.URL + "/tim/legacy-cycles/-/blob/src/main.go")
	if err != nil {
		t.Fatal(err)
	}
	blob := read(t, res)
	for _, want := range []string{
		`class="on">Files`,
		`class="depth-1 active"`,
		`class="depth-0 dir open active"`,
		`data-dir="1"`,
		`aria-expanded="true"`,
		`data-path="src"`,
		`data-repo="tim/legacy-cycles"`,
		`class="fill"`,
		`class="filepane"`,
		`class="chevron"`,
		`<span class="hl-k">func</span>`,
		`<span class="hl-s">&#34;fmt&#34;</span>`,
		`class="ln">1`,
		`<span>src</span>`,
		`<span>main.go</span>`,
		`main.go <span class="muted">`,
		"Copy",
	} {
		if !strings.Contains(blob, want) {
			t.Fatalf("blob mist %q\n%s", want, blob)
		}
	}

	res, err = client.Get(ts.URL + "/tim/legacy-cycles/-/blob/Cargo.toml")
	if err != nil {
		t.Fatal(err)
	}
	toml := read(t, res)
	if !strings.Contains(toml, `class="hl-s">&#34;legacy-cycles&#34;`) || !strings.Contains(toml, `class="hl-c"># debug`) || !strings.Contains(toml, `class="hl-n">1`) {
		t.Fatalf("toml-kleuring:\n%s", toml)
	}

	ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
		t.Fatal(err)
	}
	adaToken, err := st.CreateToken(ctx, ada.ID, "ada")
	if err != nil {
		t.Fatal(err)
	}
	adaWork := t.TempDir()
	adaRemote := strings.Replace(ts.URL, "http://", "http://ada:"+adaToken+"@", 1) + "/tim/legacy-cycles.git"
	git(t, adaWork, "clone", adaRemote, ".")
	git(t, adaWork, "config", "user.email", "ada@users.git.timfalken.com")
	git(t, adaWork, "config", "user.name", "ada")
	writeFile(t, filepath.Join(adaWork, "README.md"), readme+"\nextra\n")
	git(t, adaWork, "add", "README.md")
	git(t, adaWork, "commit", "-m", "ada op master")
	if out, err := gitOut(adaWork, "push", "origin", "master"); err == nil {
		t.Fatalf("ontwikkelaar pushte master:\n%s", out)
	} else if !strings.Contains(out, "protected") {
		t.Fatalf("weigering zonder beschermd: %v\n%s", err, out)
	}
	git(t, adaWork, "checkout", "-b", "feature")
	git(t, adaWork, "push", "-u", "origin", "feature")
}

func writeFile(t *testing.T, path, body string) {
	t.Helper()
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
		t.Fatal(err)
	}
}

func gitOut(dir string, args ...string) (string, error) {
	cmd := exec.Command("git", args...)
	cmd.Dir = dir
	out, err := cmd.CombinedOutput()
	return string(out), err
}

func csrfOf(t *testing.T, body string) string {
	t.Helper()
	const needle = `name="csrf" value="`
	i := strings.Index(body, needle)
	if i < 0 {
		t.Fatalf("geen csrf in\n%s", body)
	}
	rest := body[i+len(needle):]
	j := strings.Index(rest, `"`)
	return rest[:j]
}

// assertCloneMenu faalt als de Code-dropdown de werkbalk verlaat.
// De SSH-URL gebruikt ssh.public_host en ssh.public_port, niet de bindpoort.
func assertCloneMenu(t *testing.T, body, where, sshURL, httpURL string) {
	t.Helper()
	tool := strings.Index(body, `<div class="toolbar">`)
	clone := strings.Index(body, `data-clone`)
	if tool < 0 || clone < tool {
		t.Fatalf("%s: clone-knop hoort in de werkbalk", where)
	}
	end := strings.Index(body[clone:], `</details>`)
	if end < 0 {
		t.Fatalf("%s: clone-menu niet gesloten", where)
	}
	menu := body[clone : clone+end]
	for _, want := range []string{
		`popover="manual"`,
		`class="menu-panel"`,
		`>Code</summary>`,
		`value="` + sshURL + `"`,
		`data-copy="` + sshURL + `"`,
		`value="` + httpURL + `"`,
		`data-copy="` + httpURL + `"`,
	} {
		if !strings.Contains(menu, want) {
			t.Fatalf("%s: clone-menu mist %q:\n%s", where, want, menu)
		}
	}
	if strings.Count(menu, `data-copy="`) != 2 {
		t.Fatalf("%s: clone-menu hoort twee kopieerknoppen te hebben:\n%s", where, menu)
	}
	if strings.Contains(menu, ":2222/") {
		t.Fatalf("%s: clone-menu toont de bindpoort:\n%s", where, menu)
	}
}

func between(s, a, b string) string {
	i := strings.Index(s, a)
	if i < 0 {
		return ""
	}
	rest := s[i+len(a):]
	j := strings.Index(rest, b)
	if j < 0 {
		return ""
	}
	return rest[:j]
}

func read(t *testing.T, res *http.Response) string {
	t.Helper()
	defer res.Body.Close()
	b, err := io.ReadAll(res.Body)
	if err != nil {
		t.Fatal(err)
	}
	return string(b)
}

func git(t *testing.T, dir string, args ...string) {
	t.Helper()
	if len(args) > 0 && (args[0] == "push" || args[0] == "clone" || args[0] == "fetch" || args[0] == "pull") {
		if why := gitHTTPGap(); why != "" {
			t.Skip(why)
		}
	}
	cmd := exec.Command("git", args...)
	cmd.Dir = dir
	out, err := cmd.CombinedOutput()
	if err != nil {
		if strings.Contains(string(out), "git-http-push") || strings.Contains(string(out), "return code 22") {
			t.Skipf("git valt terug op dumb HTTP (smart HTTP ontbreekt): %s", out)
		}
		t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
	}
}

// gitHTTPGap meldt een git zonder smart HTTP. Alpine levert git-http-backend
// via git-daemon en git-remote-http via git. Zonder die helpers faalt
// git push met "git-http-push failed, return code 22".
func gitHTTPGap() string {
	out, err := exec.Command("git", "--exec-path").Output()
	if err != nil {
		return "git --exec-path faalt: " + err.Error()
	}
	dir := strings.TrimSpace(string(out))
	if _, err := os.Stat(filepath.Join(dir, "git-http-backend")); err != nil {
		return "git-http-backend ontbreekt (pakket git-daemon); git push over HTTP valt terug op dumb HTTP"
	}
	if _, err := os.Stat(filepath.Join(dir, "git-remote-http")); err != nil {
		return "git-remote-http ontbreekt; git kan niet via smart HTTP pushen"
	}
	return ""
}

func bytes32() []byte {
	b := make([]byte, 32)
	for i := range b {
		b[i] = byte(i + 3)
	}
	return b
}
