//go:build integration

package integration

import (
	"crypto/rand"
	"encoding/json"
	"io"
	"net/http"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"gitlab.com/Timfa/bluegit/internal/backupserver/config"
	"gitlab.com/Timfa/bluegit/internal/backupserver/server"
)

// Feature: Backupserver-Key in BlueGit genereren en de backup server koppelen.
func TestKeyGenerationAndConnect(t *testing.T) {
	g := startBlueGit(t)
	b := startBackup(t, nil)

	// Zonder key niets; een verkeerde key wordt geweigerd.
	if st := g.BackupStatus(); st.HasKey || st.Connected {
		t.Fatalf("vers BlueGit heeft al een key: %+v", st)
	}
	code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: "bgbk_verkeerd"})
	if code != 401 {
		t.Fatalf("verkeerde key: %d %s", code, raw)
	}
	key := g.NewKey()
	b.Connect(g, key)

	st := g.BackupStatus()
	if !st.HasKey || !st.Connected || st.ServerURL != b.URL || st.RemoteError != "" {
		t.Fatalf("BlueGit ziet de koppeling niet: %+v", st)
	}
	bs := b.Status()
	if !bs.Connected || bs.InstanceID != st.InstanceID || bs.BlueGitURL != g.URL {
		t.Fatalf("backup status: %+v", bs)
	}
	// De key staat niet leesbaar in BlueGit.
	raw2, _ := os.ReadFile(filepath.Join(g.State, "backup.json"))
	if strings.Contains(string(raw2), key) {
		t.Fatal("BlueGit bewaart de key leesbaar")
	}
	// Een nieuwe key maakt de oude ongeldig: de backup server kan niet meer syncen.
	g.RotateKey()
	code, raw = b.Admin("POST", "/sync", nil)
	if code == 200 {
		t.Fatalf("sync met ingetrokken key gelukt: %s", raw)
	}
}

// Feature: alle gegevens en configuratie ophalen.
func TestFullSyncCopiesAllData(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "hallo alpha")
	g.Issue("alpha", "eerste issue")
	b := startBackup(t, nil)
	b.Connect(g, g.NewKey())
	b.Sync()

	for _, p := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/alpha.git/HEAD"} {
		if _, err := os.Stat(b.Mirror(p)); err != nil {
			t.Fatalf("kopie mist %s: %v", p, err)
		}
	}
	if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); !strings.Contains(log, "zet README.md") {
		t.Fatalf("kopie van de repo is niet bruikbaar: %s", log)
	}
	db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))
	if !strings.HasPrefix(string(db), "SQLite format 3") || !strings.Contains(string(db), "eerste issue") {
		t.Fatal("databasekopie mist het issue")
	}
	key1, _ := os.ReadFile(filepath.Join(g.State, "secret.key"))
	key2, _ := os.ReadFile(b.Mirror("state/secret.key"))
	if string(key1) != string(key2) {
		t.Fatal("secret.key wijkt af")
	}
	// Installatiegebonden bestanden gaan niet mee.
	for _, p := range []string{"state/backup.json", "state/instance_id", "state/storage_path"} {
		if _, err := os.Stat(b.Mirror(p)); err == nil {
			t.Fatalf("%s hoort niet in de kopie", p)
		}
	}
	// Een tweede sync zonder wijzigingen haalt (bijna) niets op.
	code, raw := b.Admin("POST", "/sync", nil)
	var st struct{ Downloaded int }
	_ = json.Unmarshal(raw, &st)
	if code != 200 || st.Downloaded > 1 {
		t.Fatalf("tweede sync haalde %d bestanden op: %s", st.Downloaded, raw)
	}
}

// Feature: BlueGit meldt elke wijziging; de backup server haalt hem op.
func TestNotificationTriggersSync(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "v1")
	b := startBackup(t, nil) // full sync pas na een uur: alleen meldingen tellen
	b.Connect(g, g.NewKey())
	Eventually(t, 15*time.Second, "eerste sync na koppelen", func() bool {
		return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet README.md")
	})
	before := b.Status().Notifies

	// Wijziging via de API.
	g.Commit("alpha", "CHANGELOG.md", "nieuw", "create")
	Eventually(t, 15*time.Second, "commit via API in de kopie", func() bool {
		return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet CHANGELOG.md")
	})
	// Wijziging via git push over HTTP.
	work := t.TempDir()
	g.Git(work, "clone", "-q", g.RemoteURL("alpha"), "w")
	repo := filepath.Join(work, "w")
	_ = os.WriteFile(filepath.Join(repo, "pushed.txt"), []byte("via git"), 0o644)
	g.Git(repo, "add", ".")
	g.Git(repo, "commit", "-qm", "gepusht met git")
	g.Git(repo, "push", "-q", "origin", "master")
	Eventually(t, 15*time.Second, "git push in de kopie", func() bool {
		return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "gepusht met git")
	})
	// Een issue staat alleen in de database.
	g.Issue("alpha", "issue-na-melding")
	Eventually(t, 15*time.Second, "issue in de databasekopie", func() bool {
		db, _ := os.ReadFile(b.Mirror("state/bluegit.db"))
		return strings.Contains(string(db), "issue-na-melding")
	})
	if b.Status().Notifies <= before {
		t.Fatal("geen meldingen geteld")
	}
}

// Feature: downloaden op lage snelheid.
func TestDownloadIsThrottled(t *testing.T) {
	g := startBlueGit(t)
	g.MustAPI("POST", "/projects", map[string]any{"name": "Big", "visibility": "private"})
	work := t.TempDir()
	g.Git(work, "init", "-q", "-b", "master", "w")
	repo := filepath.Join(work, "w")
	blob := make([]byte, 1536<<10) // 1,5 MiB, niet te comprimeren
	_, _ = rand.Read(blob)
	_ = os.WriteFile(filepath.Join(repo, "random.bin"), blob, 0o644)
	g.Git(repo, "add", ".")
	g.Git(repo, "commit", "-qm", "groot bestand")
	g.Git(repo, "push", "-q", g.RemoteURL("big"), "master")

	b := startBackup(t, func(c *config.Config) { c.RateLimitKiB = 512 })
	start := time.Now()
	b.Connect(g, g.NewKey())
	b.Sync()
	took := time.Since(start)
	// 1,5 MiB tegen 512 KiB/s is minstens ~2,7 s (min de eerste burst).
	if took < 2500*time.Millisecond {
		t.Fatalf("sync duurde %v; de limiet van 512 KiB/s werkt niet", took)
	}
	if b.Status().RateLimitKiB != 512 {
		t.Fatal("limiet niet in de status")
	}
	if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/big.git")), "groot bestand") {
		t.Fatal("groot bestand niet gekopieerd")
	}
}

// Feature: op een interval archiveren; archieflijst in BlueGit.
func TestArchiveIntervalAndListInBlueGit(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "v1")
	b := startBackup(t, func(c *config.Config) { c.ArchiveInterval.Duration = 2 * time.Second })
	if b.Status().Interval != "2s" {
		t.Fatalf("interval: %s", b.Status().Interval)
	}
	b.Connect(g, g.NewKey())
	Eventually(t, 20*time.Second, "twee archieven door het interval", func() bool { return len(b.Archives()) >= 2 })

	names := b.Archives()
	st := g.BackupStatus()
	if len(st.Archives) < 2 || st.Archives[0].Name != names[0] || st.Archives[0].Size == 0 {
		t.Fatalf("BlueGit toont de archieven niet: %+v vs %v", st.Archives, names)
	}
	// De beheerpagina toont de lijst met de grote waarschuwing.
	res, err := g.Session().Get(g.URL + "/admin/backup/s/" + g.Server)
	if err != nil {
		t.Fatal(err)
	}
	page, _ := io.ReadAll(res.Body)
	res.Body.Close()
	for _, want := range []string{names[0], `class="backup-danger"`, `name="understood"`, `name="confirm"`} {
		if !strings.Contains(string(page), want) {
			t.Fatalf("beheerpagina mist %q", want)
		}
	}
	// Het archief is een geldige tar.gz met de logische paden.
	out, err := exec.Command("tar", "-tzf", filepath.Join(b.Dir, "archives", names[0])).CombinedOutput()
	if err != nil || !strings.Contains(string(out), "state/bluegit.db") || !strings.Contains(string(out), "data/repos/tim/alpha.git/HEAD") {
		t.Fatalf("archief: %v %s", err, out)
	}
}

// Feature: archieven ouder dan x dagen, of de oudste bij een volle schijf, verdwijnen.
func TestRetentionAndDiskFull(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "v1")
	b := startBackup(t, func(c *config.Config) { c.RetentionDays = 7 })
	b.Connect(g, g.NewKey())
	b.Sync()
	var names []string
	for i := 0; i < 4; i++ {
		names = append(names, b.Archive())
		time.Sleep(1100 * time.Millisecond) // namen hebben secondes
	}
	// De twee oudste zijn 10 en 8 dagen oud, de derde 6.
	ages := []int{10, 8, 6}
	for i, d := range ages {
		old := time.Now().Add(-time.Duration(d) * 24 * time.Hour)
		_ = os.Chtimes(filepath.Join(b.Dir, "archives", names[i]), old, old)
	}
	code, raw := b.Admin("POST", "/prune", nil)
	if code != 200 || !strings.Contains(string(raw), names[0]) || !strings.Contains(string(raw), names[1]) || strings.Contains(string(raw), names[2]) {
		t.Fatalf("prune op leeftijd: %d %s", code, raw)
	}
	if got := b.Archives(); len(got) != 2 {
		t.Fatalf("na leeftijd: %v", got)
	}
	// Schijf vol: de oudste gaat weg, het nieuwste blijft altijd.
	b.Srv.SetFree(func(string) (uint64, error) { return 0, nil })
	code, raw = b.Admin("POST", "/prune", nil)
	if code != 200 || !strings.Contains(string(raw), names[2]) {
		t.Fatalf("prune schijf vol: %d %s", code, raw)
	}
	if got := b.Archives(); len(got) != 1 || got[0] != names[3] {
		t.Fatalf("na schijf vol: %v, wil alleen %s", got, names[3])
	}
	// Ook een nieuw archief maakt eerst ruimte: het oude gaat weg, het nieuwe komt.
	b.Srv.SetFree(func(string) (uint64, error) {
		if len(b.Archives()) > 0 {
			return 0, nil
		}
		return 10 << 30, nil
	})
	time.Sleep(1100 * time.Millisecond)
	newest := b.Archive()
	if got := b.Archives(); len(got) != 1 || got[0] != newest {
		t.Fatalf("na archief bij volle schijf: %v", got)
	}
}

// Feature: rollback vanuit BlueGit, met bevestiging; kopie en BlueGit gaan terug.
func TestRollbackFromBlueGit(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "versie 1")
	g.Issue("alpha", "voor het archief")
	b := startBackup(t, nil)
	b.Connect(g, g.NewKey())
	b.Sync()
	archiveName := b.Archive()

	// Na het archief: alles verandert.
	g.Commit("alpha", "README.md", "versie 2", "update")
	g.Issue("alpha", "na het archief")
	g.Project("Beta", "b.txt", "nieuw project")
	b.Sync()
	if _, s := g.File("alpha", "README.md"); s != "versie 2" {
		t.Fatalf("voorbereiding: %q", s)
	}

	// Zonder juiste bevestiging gebeurt er niets.
	code, raw := g.Action(g.Server, "rollback", map[string]any{"archive": archiveName, "confirm": "ja"})
	if code != 400 {
		t.Fatalf("rollback zonder bevestiging: %d %s", code, raw)
	}
	// Via het formulier zonder vinkje ook niet.
	if code := postRollbackForm(t, g, archiveName, false); code/100 != 3 {
		t.Fatalf("formulier zonder vinkje: %d", code)
	}
	time.Sleep(300 * time.Millisecond)
	if b.Status().Rollback.State != "idle" {
		t.Fatalf("rollback gestart zonder bevestiging: %+v", b.Status().Rollback)
	}

	// Echte rollback via de UI.
	if code := postRollbackForm(t, g, archiveName, true); code/100 != 3 {
		t.Fatalf("formulier: %d", code)
	}
	Eventually(t, 60*time.Second, "rollback klaar", func() bool {
		st := b.Status().Rollback
		if st.State == "failed" {
			t.Fatalf("rollback mislukt: %s", st.Error)
		}
		return st.State == "done"
	})
	g.WaitUp(30 * time.Second)

	if code, s := g.File("alpha", "README.md"); code != 200 || s != "versie 1" {
		t.Fatalf("README na rollback: %d %q", code, s)
	}
	if code := g.ProjectCode("beta"); code != 404 {
		t.Fatalf("project beta bestaat na rollback nog: %d", code)
	}
	titles := strings.Join(g.IssueTitles("alpha"), "|")
	if !strings.Contains(titles, "voor het archief") || strings.Contains(titles, "na het archief") {
		t.Fatalf("issues na rollback: %s", titles)
	}
	// De koppeling overleeft de rollback: BlueGit ziet de server nog, en
	// de kopie loopt weer gelijk met BlueGit.
	if st := g.BackupStatus(); !st.Connected || st.RemoteError != "" {
		t.Fatalf("koppeling na rollback: %+v", st)
	}
	b.Sync()
	if log := gitLog(t, b.Mirror("data/repos/tim/alpha.git")); strings.Count(log, "zet README.md") != 1 {
		t.Fatalf("kopie na rollback: %s", log)
	}
	if _, err := os.Stat(b.Mirror("data/repos/tim/beta.git/HEAD")); err == nil {
		t.Fatal("beta staat nog in de kopie")
	}
	// Na de rollback werkt BlueGit gewoon verder en blijft melden.
	g.Commit("alpha", "after.txt", "na rollback", "create")
	Eventually(t, 15*time.Second, "melding na rollback", func() bool {
		return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet after.txt")
	})
}

func postRollbackForm(t *testing.T, g *BlueGit, archiveName string, understood bool) int {
	t.Helper()
	hc := g.Session()
	hc.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }
	res, err := hc.Get(g.URL + "/admin/backup/s/" + g.Server)
	if err != nil {
		t.Fatal(err)
	}
	page, _ := io.ReadAll(res.Body)
	res.Body.Close()
	csrf := between(string(page), `name="csrf" value="`, `"`)
	if csrf == "" {
		t.Fatal("geen csrf op de beheerpagina")
	}
	form := url.Values{"csrf": {csrf}, "archive": {archiveName}, "confirm": {archiveName}}
	if understood {
		form.Set("understood", "1")
	}
	res, err = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/rollback", form)
	if err != nil {
		t.Fatal(err)
	}
	res.Body.Close()
	return res.StatusCode
}

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

// Feature: één BlueGit per backup server; keuze "oude backups verwijderen".
func TestNewInstanceWipe(t *testing.T) {
	a := startBlueGit(t)
	a.Project("Alpha", "a.txt", "van A")
	b := startBackup(t, nil)
	b.Connect(a, a.NewKey())
	b.Sync()
	b.Archive()

	other := startBlueGit(t)
	other.Project("Gamma", "g.txt", "van B")
	keyB := other.NewKey()
	code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB})
	if code != 409 {
		t.Fatalf("tweede BlueGit zonder keuze: %d %s", code, raw)
	}
	var cf server.ConflictError
	_ = json.Unmarshal(raw, &cf)
	if !cf.Conflict || cf.PreviousURL != a.URL || cf.Archives != 1 || strings.Join(cf.Choices, ",") != "wipe,restore" {
		t.Fatalf("conflict: %+v", cf)
	}
	// Er is nog niets veranderd.
	if b.Status().BlueGitURL != a.URL || len(b.Archives()) != 1 {
		t.Fatal("conflict veranderde de koppeling")
	}
	code, raw = b.Admin("POST", "/connect", server.ConnectRequest{URL: other.URL, Key: keyB, OnConflict: "wipe"})
	if code != 200 {
		t.Fatalf("wipe: %d %s", code, raw)
	}
	if len(b.Archives()) != 0 {
		t.Fatal("oude archieven staan er nog")
	}
	b.Sync()
	if _, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD")); err == nil {
		t.Fatal("A staat nog in de kopie")
	}
	if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/gamma.git")), "zet g.txt") {
		t.Fatal("B staat niet in de kopie")
	}
	if st := other.BackupStatus(); !st.Connected || st.ServerURL != b.URL {
		t.Fatalf("B ziet de koppeling niet: %+v", st)
	}
	// A is los: zijn meldingen worden geweigerd (andere instantie).
	if b.Status().InstanceID == a.BackupStatus().InstanceID {
		t.Fatal("backup server hoort nog bij A")
	}
}

// Feature: keuze "nieuwe instantie terugzetten naar de gegevens in de backup server".
func TestNewInstanceRestore(t *testing.T) {
	a := startBlueGit(t)
	a.Project("Alpha", "a.txt", "van A")
	a.Issue("alpha", "issue van A")
	b := startBackup(t, nil)
	b.Connect(a, a.NewKey())
	b.Sync()

	fresh := startBlueGit(t)
	fresh.Project("Gamma", "g.txt", "van B")
	keyB := fresh.NewKey()
	freshID := fresh.BackupStatus().InstanceID
	code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: fresh.URL, Key: keyB, OnConflict: "restore"})
	if code != 200 || !strings.Contains(string(raw), `"restored":true`) {
		t.Fatalf("restore: %d %s", code, raw)
	}
	fresh.WaitUp(30 * time.Second)
	// De nieuwe BlueGit heeft nu de database van A, dus ook A's token.
	fresh.Token = a.Token
	if code, s := fresh.File("alpha", "a.txt"); code != 200 || s != "van A" {
		t.Fatalf("A's project op de nieuwe BlueGit: %d %q", code, s)
	}
	if code := fresh.ProjectCode("gamma"); code != 404 {
		t.Fatalf("B's eigen project bestaat nog: %d", code)
	}
	if titles := strings.Join(fresh.IssueTitles("alpha"), "|"); !strings.Contains(titles, "issue van A") {
		t.Fatalf("issues: %s", titles)
	}
	// De koppeling hoort bij de installatie, niet bij de gegevens.
	st := fresh.BackupStatus()
	if !st.Connected || st.InstanceID != freshID || st.ServerURL != b.URL {
		t.Fatalf("koppeling na restore: %+v", st)
	}
	if b.Status().InstanceID != freshID {
		t.Fatal("backup server hoort niet bij de nieuwe instantie")
	}
	b.Sync()
	if !strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet a.txt") {
		t.Fatal("kopie na restore")
	}
}

// Feature: de CLI vraagt de keuze bij een nieuwe verbinding.
func TestCLIConnectAsksOnConflict(t *testing.T) {
	cli := filepath.Join(t.TempDir(), "bluegit-backup")
	if out, err := exec.Command("go", "build", "-o", cli, "../../../cmd/bluegit-backup").CombinedOutput(); err != nil {
		t.Fatalf("build: %v %s", err, out)
	}
	a := startBlueGit(t)
	a.Project("Alpha", "a.txt", "A")
	b := startBackup(t, nil)
	cfgPath := filepath.Join(t.TempDir(), "config.yml")
	_ = os.WriteFile(cfgPath, []byte("listen: "+b.Cfg.Listen+"\npublic_url: "+b.URL+"\ndata_dir: "+b.Dir+"\n"), 0o600)
	run := func(stdin string, args ...string) (string, error) {
		cmd := exec.Command(cli, append([]string{"connect", "--config", cfgPath}, args...)...)
		cmd.Stdin = strings.NewReader(stdin)
		out, err := cmd.CombinedOutput()
		return string(out), err
	}
	keyA := a.NewKey()
	cmd := exec.Command(cli, "connect", "--config", cfgPath, "--url", a.URL)
	cmd.Env = append(os.Environ(), "BLUEGIT_BACKUP_KEY="+keyA)
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("eerste connect: %v %s", err, out)
	}
	b.Sync()

	other := startBlueGit(t)
	keyB := other.NewKey()
	out, err := run("\n", "--url", other.URL, "--key", keyB)
	if err == nil || !strings.Contains(out, "Oude backups verwijderen") || !strings.Contains(out, "terugzetten") || !strings.Contains(out, "afgebroken") {
		t.Fatalf("afbreken: %v %s", err, out)
	}
	if b.Status().BlueGitURL != a.URL {
		t.Fatal("afbreken veranderde de koppeling")
	}
	out, err = run("1\n", "--url", other.URL, "--key", keyB)
	if err != nil || b.Status().BlueGitURL != other.URL {
		t.Fatalf("keuze 1: %v %s", err, out)
	}
	if out, err := exec.Command(cli, "status", "--config", cfgPath).CombinedOutput(); err != nil || !strings.Contains(string(out), other.URL) {
		t.Fatalf("status: %v %s", err, out)
	}
}
