//go:build integration

package integration

import (
	"encoding/json"
	"io"
	"net/http"
	"net/http/cookiejar"
	"net/url"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"testing"
	"time"
)

// webUI is een browser op de webinterface van de backup server.
type webUI struct {
	t    *testing.T
	b    *Backup
	hc   *http.Client
	csrf string
}

func openUI(t *testing.T, b *Backup) *webUI {
	t.Helper()
	jar, _ := cookiejar.New(nil)
	u := &webUI{t: t, b: b, hc: &http.Client{Jar: jar, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}}
	res, err := u.hc.Get(b.URL + "/")
	if err != nil {
		t.Fatal(err)
	}
	res.Body.Close()
	if res.StatusCode != 303 || res.Header.Get("Location") != "/login" {
		t.Fatalf("zonder login: %d %s", res.StatusCode, res.Header.Get("Location"))
	}
	res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {"bba_fout"}})
	res.Body.Close()
	if res.Header.Get("Location") != "/login?fout=1" {
		t.Fatal("fout token geaccepteerd")
	}
	res, _ = u.hc.PostForm(b.URL+"/login", url.Values{"token": {b.Srv.AdminToken()}})
	res.Body.Close()
	if res.StatusCode != 303 || res.Header.Get("Location") != "/" {
		t.Fatalf("login: %d", res.StatusCode)
	}
	u.Page()
	return u
}

// Page haalt de hoofdpagina op en onthoudt het CSRF-token.
func (u *webUI) Page() string {
	u.t.Helper()
	res, err := u.hc.Get(u.b.URL + "/")
	if err != nil {
		u.t.Fatal(err)
	}
	b, _ := io.ReadAll(res.Body)
	res.Body.Close()
	if res.StatusCode != 200 {
		u.t.Fatalf("pagina: %d", res.StatusCode)
	}
	u.csrf = between(string(b), `name="csrf" value="`, `"`)
	return string(b)
}

// Act verstuurt het formulier van een actie en geeft de melding erna.
func (u *webUI) Act(name string, form url.Values) string {
	u.t.Helper()
	if form == nil {
		form = url.Values{}
	}
	form.Set("csrf", u.csrf)
	res, err := u.hc.PostForm(u.b.URL+"/ui/act/"+name, form)
	if err != nil {
		u.t.Fatal(err)
	}
	res.Body.Close()
	if res.StatusCode != 303 {
		u.t.Fatalf("%s: %d", name, res.StatusCode)
	}
	return between(u.Page(), `role="status">`, `</div>`)
}

func actionNames(t *testing.T, b *Backup, withGet bool) []string {
	t.Helper()
	code, raw := b.Admin("GET", "/actions", nil)
	if code != 200 {
		t.Fatalf("actions: %d", code)
	}
	var out struct {
		Actions []struct{ Name, Method string }
	}
	_ = json.Unmarshal(raw, &out)
	var names []string
	for _, a := range out.Actions {
		if withGet || a.Method != "GET" {
			names = append(names, a.Name)
		}
	}
	sort.Strings(names)
	return names
}

func requireAll(t *testing.T, what string, want []string, done map[string]bool) {
	t.Helper()
	for _, n := range want {
		if !done[n] {
			t.Errorf("%s: actie %s niet getest", what, n)
		}
	}
}

// Feature: alles is in te stellen en te bedienen via de webinterface (poort 8080 standaard).
func TestWebUIConfiguresAndOperatesEverything(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "v1")
	b := startBackup(t, nil)
	u := openUI(t, b)
	done := map[string]bool{}

	// Instellingen.
	msg := u.Act("config.update", url.Values{"archive_interval": {"3h"}, "retention_days": {"5"}, "rate_limit_kib": {"2048"}, "min_free_mb": {"2"}, "full_sync_interval": {"2h"}, "min_sync_interval": {"1s"}, "public_url": {b.URL}, "listen": {b.Cfg.Listen}})
	if !strings.Contains(msg, "opgeslagen") {
		t.Fatalf("instellingen: %q", msg)
	}
	done["config.update"] = true
	st := b.Status()
	if st.Interval != "3h0m0s" || st.RetentionDays != 5 || st.RateLimitKiB != 2048 {
		t.Fatalf("niet toegepast: %+v", st)
	}
	if msg := u.Act("config.update", url.Values{"archive_interval": {"nooit"}}); !strings.Contains(msg, "mislukt") {
		t.Fatalf("ongeldige waarde: %q", msg)
	}
	u.Act("config.update", url.Values{"rate_limit_kib": {"0"}})

	// Koppelen met een key uit BlueGit.
	if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {"bgbk_fout"}, "on_conflict": {""}}); !strings.Contains(msg, "mislukt") {
		t.Fatalf("verkeerde key: %q", msg)
	}
	if msg := u.Act("connect", url.Values{"url": {g.URL}, "key": {g.NewKey()}, "on_conflict": {""}}); !strings.Contains(msg, "gelukt") {
		t.Fatalf("koppelen: %q", msg)
	}
	done["connect"] = true
	if st := g.BackupStatus(); !st.Connected || st.ServerURL != b.URL {
		t.Fatalf("BlueGit ziet de koppeling niet: %+v", st)
	}

	// Sync, archief, opruimen.
	if msg := u.Act("sync", nil); !strings.Contains(msg, "gestart") {
		t.Fatalf("sync: %q", msg)
	}
	done["sync"] = true
	Eventually(t, 15*time.Second, "kopie na sync uit de webinterface", func() bool {
		_, err := os.Stat(b.Mirror("data/repos/tim/alpha.git/HEAD"))
		return err == nil
	})
	b.Sync()
	if msg := u.Act("archive", nil); !strings.Contains(msg, "Archief gemaakt") {
		t.Fatalf("archief: %q", msg)
	}
	done["archive"] = true
	name := b.Archives()[0]
	page := u.Page()
	if !strings.Contains(page, name) || !strings.Contains(page, "gekoppeld") {
		t.Fatal("pagina toont het archief of de koppeling niet")
	}
	// Download vanuit de pagina.
	res, err := u.hc.Get(b.URL + "/api/v1/admin/archives/" + name + "/download")
	if err != nil {
		t.Fatal(err)
	}
	got, _ := io.ReadAll(res.Body)
	res.Body.Close()
	want, _ := os.ReadFile(filepath.Join(b.Dir, "archives", name))
	if res.StatusCode != 200 || len(got) == 0 || string(got) != string(want) {
		t.Fatalf("download: %d %d bytes", res.StatusCode, len(got))
	}
	if msg := u.Act("prune", nil); !strings.Contains(msg, "Opgeruimd") {
		t.Fatalf("opruimen: %q", msg)
	}
	done["prune"] = true

	// Rollback vanuit de webinterface: zonder vinkje niets, daarna echt.
	g.Commit("alpha", "README.md", "v2", "update")
	b.Sync()
	if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}}); !strings.Contains(msg, "Vink aan") {
		t.Fatalf("zonder vinkje: %q", msg)
	}
	if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {"verkeerd"}, "understood": {"1"}}); !strings.Contains(msg, "mislukt") {
		t.Fatalf("verkeerde bevestiging: %q", msg)
	}
	if msg := u.Act("rollback", url.Values{"archive": {name}, "confirm": {name}, "understood": {"1"}}); !strings.Contains(msg, "Rollback gestart") {
		t.Fatalf("rollback: %q", msg)
	}
	done["rollback"] = true
	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 _, s := g.File("alpha", "README.md"); s != "v1" {
		t.Fatalf("README na rollback: %q", s)
	}

	// Archief verwijderen en ontkoppelen.
	if msg := u.Act("archive.delete", url.Values{"name": {name}}); !strings.Contains(msg, "gelukt") {
		t.Fatalf("verwijderen: %q", msg)
	}
	done["archive.delete"] = true
	if len(b.Archives()) != 0 {
		t.Fatal("archief staat er nog")
	}
	if msg := u.Act("disconnect", nil); !strings.Contains(msg, "gelukt") {
		t.Fatalf("ontkoppelen: %q", msg)
	}
	done["disconnect"] = true
	if b.Status().Connected {
		t.Fatal("nog gekoppeld")
	}
	requireAll(t, "webinterface", actionNames(t, b, false), done)
}

// Feature: de API kan alles wat de webinterface kan, en andersom.
func TestAPIDoesEverythingTheUICan(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "v1")
	b := startBackup(t, nil)
	done := map[string]bool{}
	call := func(name, method, path string, in any, want int) []byte {
		t.Helper()
		code, raw := b.Admin(method, path, in)
		if code != want {
			t.Fatalf("%s %s: %d %s", method, path, code, raw)
		}
		done[name] = true
		return raw
	}
	call("status", "GET", "/status", nil, 200)
	call("actions", "GET", "/actions", nil, 200)
	raw := call("config", "GET", "/config", nil, 200)
	if !strings.Contains(string(raw), `"key":"listen"`) {
		t.Fatalf("config: %s", raw)
	}
	call("config.update", "PUT", "/config", map[string]any{"retention_days": 7, "archive_interval": "6h"}, 200)
	if b.Status().RetentionDays != 7 {
		t.Fatal("config niet toegepast")
	}
	call("connect", "POST", "/connect", map[string]any{"url": g.URL, "key": g.NewKey()}, 200)
	call("sync", "POST", "/sync", nil, 200)
	raw = call("archive", "POST", "/archive", nil, 201)
	var a struct{ Name string }
	_ = json.Unmarshal(raw, &a)
	raw = call("archives", "GET", "/archives", nil, 200)
	if !strings.Contains(string(raw), a.Name) {
		t.Fatalf("archives: %s", raw)
	}
	raw = call("archive.download", "GET", "/archives/"+a.Name+"/download", nil, 200)
	if len(raw) < 100 || raw[0] != 0x1f || raw[1] != 0x8b {
		t.Fatal("download is geen gzip")
	}
	call("prune", "POST", "/prune", nil, 200)
	call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name}, 400) // bevestiging ontbreekt
	call("rollback", "POST", "/rollback", map[string]any{"archive": a.Name, "confirm": a.Name}, 202)
	Eventually(t, 60*time.Second, "rollback klaar", func() bool { return b.Status().Rollback.State == "done" })
	g.WaitUp(30 * time.Second)
	call("archive.delete", "DELETE", "/archives/"+a.Name, nil, 200)
	call("disconnect", "POST", "/disconnect", nil, 200)
	requireAll(t, "API", actionNames(t, b, true), done)
}

// Feature: vanuit BlueGit is de backup server te bedienen zoals in zijn eigen webinterface.
func TestBlueGitControlsBackupServer(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "v1")
	b := startBackup(t, nil)
	b.Connect(g, g.NewKey())
	b.Sync()

	// Instellingen lezen en wijzigen via de BlueGit-API.
	st := g.BackupStatus()
	if len(st.Config.Fields) == 0 {
		t.Fatalf("BlueGit ziet geen instellingen: %+v", st)
	}
	if code, raw := g.Action(g.Server, "config.update", map[string]any{"retention_days": "11", "archive_interval": "5h"}); code != 200 {
		t.Fatalf("config via BlueGit: %d %s", code, raw)
	}
	if s := b.Status(); s.RetentionDays != 11 || s.Interval != "5h0m0s" {
		t.Fatalf("niet toegepast: %+v", s)
	}
	// Archief maken, synchroniseren en verwijderen via BlueGit.
	if code, raw := g.Action(g.Server, "archive", nil); code != 201 {
		t.Fatalf("archief via BlueGit: %d %s", code, raw)
	}
	name := b.Archives()[0]
	g.Commit("alpha", "x.txt", "x", "create")
	before := b.Status().Syncs
	if code, raw := g.Action(g.Server, "sync", nil); code != 202 {
		t.Fatalf("sync via BlueGit: %d %s", code, raw)
	}
	Eventually(t, 15*time.Second, "sync gestart door BlueGit", func() bool { return b.Status().Syncs > before })
	if code, raw := g.Action(g.Server, "archive.delete", map[string]any{"name": name}); code != 200 {
		t.Fatalf("verwijderen via BlueGit: %d %s", code, raw)
	}
	if len(b.Archives()) != 0 {
		t.Fatal("archief niet verwijderd")
	}
	// Koppelen kan BlueGit niet namens de backup server (alleen lokaal).
	if code, _ := g.Action(g.Server, "connect", map[string]any{"url": g.URL, "key": "bgbk_x"}); code != 404 {
		t.Fatalf("connect via BlueGit: %d", code)
	}

	// Dezelfde bediening in de BlueGit-webinterface.
	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()
	for _, want := range []string{`name="retention_days" value="11"`, "/act/sync", "/act/archive", "/act/prune", "/act/config.update"} {
		if !strings.Contains(string(page), want) {
			t.Fatalf("BlueGit-pagina mist %q", want)
		}
	}
	csrf := between(string(page), `name="csrf" value="`, `"`)
	res, err = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"12"}})
	if err != nil {
		t.Fatal(err)
	}
	res.Body.Close()
	if b.Status().RetentionDays != 12 {
		t.Fatalf("formulier in BlueGit: %d", b.Status().RetentionDays)
	}
	res, _ = hc.PostForm(g.URL+"/admin/backup/s/"+g.Server+"/act/archive", url.Values{"csrf": {csrf}})
	res.Body.Close()
	if len(b.Archives()) != 1 {
		t.Fatal("archief via het BlueGit-formulier ontbreekt")
	}
}

// Feature: één BlueGit kan meerdere backup servers hebben; elke backup server hoort bij één BlueGit.
func TestMultipleBackupServers(t *testing.T) {
	g := startBlueGit(t)
	g.Project("Alpha", "README.md", "v1")
	b1, b2 := startBackup(t, nil), startBackup(t, nil)
	id1, key1 := g.AddServer("nas")
	id2, key2 := g.AddServer("offsite")
	b1.Connect(g, key1)
	b2.Connect(g, key2)
	for _, id := range []string{id1, id2} {
		if st := g.ServerStatus(id); !st.Connected || st.RemoteError != "" {
			t.Fatalf("%s: %+v", id, st)
		}
	}
	if g.ServerStatus(id1).ServerURL != b1.URL || g.ServerStatus(id2).ServerURL != b2.URL {
		t.Fatal("adressen verwisseld")
	}
	// Elke wijziging komt bij beide aan.
	g.Commit("alpha", "beide.txt", "x", "create")
	for _, b := range []*Backup{b1, b2} {
		Eventually(t, 15*time.Second, "melding bij "+b.URL, func() bool {
			return strings.Contains(gitLog(t, b.Mirror("data/repos/tim/alpha.git")), "zet beide.txt")
		})
	}
	// Een key hoort bij één server: key1 werkt niet voor de tweede server.
	b3 := startBackup(t, nil)
	b3.Connect(g, key1) // dezelfde key: BlueGit verplaatst de koppeling van nas naar b3
	if st := g.ServerStatus(id1); st.ServerURL != b3.URL {
		t.Fatalf("koppeling niet verplaatst: %+v", st)
	}
	// Verwijderen in BlueGit ontkoppelt alleen die server.
	if code, raw := g.API("DELETE", "/admin/backup/servers/"+id2, nil); code != 204 {
		t.Fatalf("verwijderen: %d %s", code, raw)
	}
	if b2.Status().Connected {
		t.Fatal("verwijderde backup server is nog gekoppeld")
	}
	g.Commit("alpha", "daarna.txt", "x", "create")
	Eventually(t, 15*time.Second, "overgebleven server krijgt meldingen", func() bool {
		return strings.Contains(gitLog(t, b3.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt")
	})
	time.Sleep(time.Second)
	if strings.Contains(gitLog(t, b2.Mirror("data/repos/tim/alpha.git")), "zet daarna.txt") {
		t.Fatal("verwijderde server synchroniseert nog")
	}
	// Een backup server hoort bij één BlueGit: koppelen aan een andere vraagt om een keuze.
	other := startBlueGit(t)
	code, raw := b3.Admin("POST", "/connect", map[string]any{"url": other.URL, "key": other.NewKey()})
	if code != 409 || !strings.Contains(string(raw), `"choices":["wipe","restore"]`) {
		t.Fatalf("tweede BlueGit: %d %s", code, raw)
	}
}
