package server

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

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

type backupEnv struct {
	srv  *Server
	st   *store.Store
	base string
	tim  store.User
	tok  string
}

func newBackupEnv(t *testing.T) *backupEnv {
	t.Helper()
	stateDir, storage := t.TempDir(), t.TempDir()
	st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	_ = os.WriteFile(filepath.Join(stateDir, "secret.key"), bytes32(), 0o600)
	cfg := config.Config{
		Listen: "127.0.0.1:0", StoragePath: storage, StatePath: stateDir,
		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", StateDir: stateDir}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	srv.Cfg.BaseURL = ts.URL
	tim, err := st.UpsertUser(context.Background(), 1, "tim", "", false)
	if err != nil {
		t.Fatal(err)
	}
	if !tim.InstanceAdmin {
		t.Skip("eerste gebruiker is geen beheerder")
	}
	_ = os.MkdirAll(filepath.Join(storage, "repos", "tim", "app.git"), 0o755)
	_ = os.WriteFile(filepath.Join(storage, "repos", "tim", "app.git", "HEAD"), []byte("ref: refs/heads/master\n"), 0o644)
	srv.backupInit()
	srv.backupNote.Delay = 20 * time.Millisecond
	return &backupEnv{srv: srv, st: st, base: ts.URL, tim: tim, tok: issue(t, st, tim.ID, "api")}
}

func keyed(t *testing.T, method, u, key string, body io.Reader) (int, []byte) {
	t.Helper()
	req, _ := http.NewRequest(method, u, body)
	if key != "" {
		req.Header.Set("Authorization", "Bearer "+key)
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	return res.StatusCode, b
}

// fakeBackup speelt de backup server: hij controleert elke handtekening.
type fakeBackup struct {
	mu       sync.Mutex
	secret   string
	notifies int
	rollback []string
	badSig   int
	ts       *httptest.Server
}

func newFakeBackup(t *testing.T) *fakeBackup {
	f := &fakeBackup{}
	f.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		body, _ := io.ReadAll(r.Body)
		f.mu.Lock()
		defer f.mu.Unlock()
		if err := backup.Verify(r, f.secret, body, time.Now()); err != nil {
			f.badSig++
			http.Error(w, `{"error":"sig"}`, 401)
			return
		}
		switch r.URL.Path {
		case "/api/v1/notify":
			f.notifies++
			w.WriteHeader(204)
		case "/api/v1/archives":
			_ = json.NewEncoder(w).Encode(map[string]any{"archives": []backup.Archive{{Name: "bluegit-20261115-120000.tar.gz", CreatedAt: time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC), Size: 3 << 20}}})
		case "/api/v1/status":
			_, _ = w.Write([]byte(`{"version":"test","archive_interval":"24h0m0s","retention_days":30,"rollback":{"state":"idle"}}`))
		case "/api/v1/rollback":
			var in struct{ Archive string }
			_ = json.Unmarshal(body, &in)
			f.rollback = append(f.rollback, in.Archive)
			w.WriteHeader(202)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(f.ts.Close)
	return f
}

func TestBackupKeyAndKeyedAPI(t *testing.T) {
	e := newBackupEnv(t)
	// Zonder key: 401. Met een gewoon toegangstoken: ook 401.
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", "", nil); code != 401 {
		t.Fatalf("zonder key: %d", code)
	}
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/manifest", e.tok, nil); code != 401 {
		t.Fatalf("bg_-token: %d", code)
	}
	// Alleen een beheerder maakt een key.
	bob, _ := e.st.UpsertUser(context.Background(), 2, "bob", "", false)
	if code, _ := rapi(t, e.base, issue(t, e.st, bob.ID, "api"), "POST", "/admin/backup/key", nil); code != 403 {
		t.Fatalf("bob maakt key: %d", code)
	}
	code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
	if code != 201 {
		t.Fatalf("key: %d %s", code, b)
	}
	var k struct{ Key string }
	_ = json.Unmarshal(b, &k)
	if !strings.HasPrefix(k.Key, "bgbk_") {
		t.Fatalf("key %q", k.Key)
	}
	code, b = keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil)
	var info struct {
		InstanceID string `json:"instance_id"`
	}
	_ = json.Unmarshal(b, &info)
	if code != 200 || info.InstanceID == "" {
		t.Fatalf("info: %d %s", code, b)
	}
	code, b = keyed(t, "GET", e.base+"/api/v1/backup/manifest", k.Key, nil)
	var m backup.Manifest
	_ = json.Unmarshal(b, &m)
	if code != 200 || m.Instance != info.InstanceID {
		t.Fatalf("manifest: %d %.300s", code, b)
	}
	have := map[string]bool{}
	for _, f := range m.Files {
		have[f.Path] = true
	}
	for _, want := range []string{"state/bluegit.db", "state/secret.key", "data/repos/tim/app.git/HEAD"} {
		if !have[want] {
			t.Fatalf("manifest mist %s: %v", want, have)
		}
	}
	code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape("data/repos/tim/app.git/HEAD"), k.Key, nil)
	if code != 200 || string(b) != "ref: refs/heads/master\n" {
		t.Fatalf("file: %d %q", code, b)
	}
	code, b = keyed(t, "GET", e.base+"/api/v1/backup/file?path=state/bluegit.db", k.Key, nil)
	if code != 200 || !strings.HasPrefix(string(b), "SQLite format 3") {
		t.Fatalf("db-kopie: %d %.20q", code, b)
	}
	for _, bad := range []string{"state/backup.json", "state/storage_path", "../../etc/passwd", "data/repos/../../x"} {
		if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(bad), k.Key, nil); code != 404 {
			t.Fatalf("%s: %d", bad, code)
		}
	}
	// Intrekken: de key werkt niet meer.
	if code, _ := rapi(t, e.base, e.tok, "DELETE", "/admin/backup/key", nil); code != 204 {
		t.Fatalf("revoke: %d", code)
	}
	if code, _ := keyed(t, "GET", e.base+"/api/v1/backup/info", k.Key, nil); code != 401 {
		t.Fatalf("na intrekken: %d", code)
	}
}

func TestBackupConnectNotifyArchivesRollback(t *testing.T) {
	e := newBackupEnv(t)
	fb := newFakeBackup(t)
	_, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
	var k struct{ Key string }
	_ = json.Unmarshal(b, &k)
	fb.secret = backup.SigningSecret(k.Key)
	code, b := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"`+fb.ts.URL+`","server_id":"s1"}`))
	if code != 200 {
		t.Fatalf("connect: %d %s", code, b)
	}
	if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/connect", k.Key, strings.NewReader(`{"server_url":"ftp://x"}`)); code != 400 {
		t.Fatalf("ftp-adres: %d", code)
	}

	// Een schrijvende actie geeft een ondertekende melding.
	if code, b := rapi(t, e.base, e.tok, "POST", "/projects", map[string]any{"name": "Notify"}); code/100 != 2 {
		t.Fatalf("project: %d %s", code, b)
	}
	deadline := time.Now().Add(5 * time.Second)
	for {
		fb.mu.Lock()
		n := fb.notifies
		fb.mu.Unlock()
		if n > 0 {
			break
		}
		if time.Now().After(deadline) {
			t.Fatal("geen melding ontvangen")
		}
		time.Sleep(20 * time.Millisecond)
	}

	// Archieven via de API en op de beheerpagina, met de waarschuwing.
	code, b = rapi(t, e.base, e.tok, "GET", "/admin/backup", nil)
	if code != 200 || !strings.Contains(string(b), "bluegit-20261115-120000.tar.gz") || !strings.Contains(string(b), `"connected":true`) {
		t.Fatalf("admin backup: %d %s", code, b)
	}
	tc, csrf := sessionClient(t, e.st, e.base, e.tim.ID)
	res, _ := tc.Get(e.base + "/admin/backup")
	page := body(t, res)
	for _, want := range []string{"bluegit-20261115-120000.tar.gz", `class="backup-danger"`, `name="understood"`, `name="confirm"`, `href="/admin/backup"`} {
		if !strings.Contains(page, want) {
			t.Fatalf("pagina mist %s: %.600s", want, page)
		}
	}

	// Rollback: verkeerde bevestiging, dan goed.
	if code, _ := rapi(t, e.base, e.tok, "POST", "/admin/backup/rollback", map[string]any{"archive": "bluegit-20261115-120000.tar.gz", "confirm": "ja"}); code != 400 {
		t.Fatalf("verkeerde bevestiging: %d", code)
	}
	res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}})
	res.Body.Close()
	fb.mu.Lock()
	if len(fb.rollback) != 0 {
		t.Fatal("rollback zonder vinkje")
	}
	fb.mu.Unlock()
	res, _ = tc.PostForm(e.base+"/admin/backup/rollback", url.Values{"csrf": {csrf}, "archive": {"bluegit-20261115-120000.tar.gz"}, "confirm": {"bluegit-20261115-120000.tar.gz"}, "understood": {"1"}})
	res.Body.Close()
	if code, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/rollback", map[string]any{"archive": "bluegit-20261115-120000.tar.gz", "confirm": "bluegit-20261115-120000.tar.gz"}); code != 202 {
		t.Fatalf("rollback api: %d %s", code, b)
	}
	fb.mu.Lock()
	defer fb.mu.Unlock()
	if len(fb.rollback) != 2 || fb.badSig != 0 {
		t.Fatalf("rollbacks %v, foute handtekeningen %d", fb.rollback, fb.badSig)
	}
}

func TestBackupRestoreStagesAndRestarts(t *testing.T) {
	e := newBackupEnv(t)
	restarted := make(chan struct{}, 1)
	e.srv.RequestRestart = func() { restarted <- struct{}{} }
	_, b := rapi(t, e.base, e.tok, "POST", "/admin/backup/key", nil)
	var k struct{ Key string }
	_ = json.Unmarshal(b, &k)
	// Ongeldig archief: 400, niets klaargezet.
	if code, _ := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader("x")); code != 400 {
		t.Fatalf("ongeldig: %d", code)
	}
	if backup.HasPending(e.srv.StateDir) {
		t.Fatal("READY na fout")
	}
	// Een archief uit het eigen manifest terugsturen.
	tarball := buildTarFromInstance(t, e, k.Key)
	code, b := keyed(t, "POST", e.base+"/api/v1/backup/restore", k.Key, strings.NewReader(tarball))
	if code != 202 {
		t.Fatalf("restore: %d %s", code, b)
	}
	select {
	case <-restarted:
	case <-time.After(3 * time.Second):
		t.Fatal("geen herstart")
	}
	if !backup.HasPending(e.srv.StateDir) {
		t.Fatal("geen READY")
	}
	restoreBusy.Store(false)
}

func buildTarFromInstance(t *testing.T, e *backupEnv, key string) string {
	t.Helper()
	_, b := keyed(t, "GET", e.base+"/api/v1/backup/manifest", key, nil)
	var m backup.Manifest
	_ = json.Unmarshal(b, &m)
	var sb strings.Builder
	files := map[string]string{}
	for _, f := range m.Files {
		_, data := keyed(t, "GET", e.base+"/api/v1/backup/file?path="+url.QueryEscape(f.Path), key, nil)
		files[f.Path] = string(data)
	}
	writeTarGz(t, &sb, files)
	return sb.String()
}
