//go:build integration

// Integratietests: elke test start een echte BlueGit (BLUEGIT_BIN), maakt
// daar een beheerder, token en Backupserver-Key aan, en test de backup
// server ertegen. Zonder BLUEGIT_BIN falen ze; ze slaan niet over, zodat de
// release-jobs nooit op een overgeslagen test kunnen leunen.
package integration

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log/slog"
	"net"
	"net/http"
	"net/http/cookiejar"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"

	"git.timfalken.com/timfa/bluegit-backup/internal/config"
	"git.timfalken.com/timfa/bluegit-backup/internal/server"
)

func bluegitBin(t *testing.T) string {
	t.Helper()
	bin := os.Getenv("BLUEGIT_BIN")
	if bin == "" {
		t.Fatal("BLUEGIT_BIN ontbreekt: bouw BlueGit met scripts/build-bluegit.sh")
	}
	if _, err := os.Stat(bin); err != nil {
		t.Fatalf("BLUEGIT_BIN: %v", err)
	}
	if _, err := exec.LookPath("git"); err != nil {
		t.Fatal("git ontbreekt")
	}
	return bin
}

func freePort(t *testing.T) int {
	t.Helper()
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	defer ln.Close()
	return ln.Addr().(*net.TCPAddr).Port
}

// BlueGit is één lokaal opgespinde BlueGit.
type BlueGit struct {
	t       *testing.T
	Bin     string
	URL     string
	Config  string
	State   string
	Storage string
	Token   string
	cmd     *exec.Cmd
	log     *syncBuf
	// Server is het id van de laatst toegevoegde backup server in BlueGit.
	Server string
}

type syncBuf struct {
	mu sync.Mutex
	b  bytes.Buffer
}

func (s *syncBuf) Write(p []byte) (int, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.b.Write(p)
}

func (s *syncBuf) String() string {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.b.String()
}

func startBlueGit(t *testing.T) *BlueGit {
	t.Helper()
	return startBlueGitBin(t, bluegitBin(t))
}

// bluegitFutureBin is een test-build van dezelfde BlueGit met een hoger
// protocol (scripts/build-bluegit.sh bouwt hem naast BLUEGIT_BIN met
// -ldflags -X): protocol FutureProtocol, en hij ondersteunt alleen backup
// servers vanaf FutureProtocol.
func bluegitFutureBin(t *testing.T) string {
	t.Helper()
	bin := os.Getenv("BLUEGIT_FUTURE_BIN")
	if bin == "" {
		bin = filepath.Join(filepath.Dir(bluegitBin(t)), "bluegit-future")
	}
	if _, err := os.Stat(bin); err != nil {
		t.Fatalf("test-build met hoger protocol ontbreekt (scripts/build-bluegit.sh): %v", err)
	}
	return bin
}

// FutureProtocol staat ook in scripts/build-bluegit.sh.
const FutureProtocol = 99

func startBlueGitBin(t *testing.T, bin string) *BlueGit {
	t.Helper()
	dir := t.TempDir()
	port := freePort(t)
	g := &BlueGit{t: t, Bin: bin, URL: fmt.Sprintf("http://127.0.0.1:%d", port),
		State: filepath.Join(dir, "state"), Storage: filepath.Join(dir, "storage"), Config: filepath.Join(dir, "bluegit.yml"), log: &syncBuf{}}
	_ = os.MkdirAll(g.Storage, 0o750)
	cfg := fmt.Sprintf(`base_url: %s
listen: 127.0.0.1:%d
state_path: %s
storage_path: %s
auth:
  mode: dev
  dev_user: tim
  dev_auth_id: 1
  user_agent: bluegit-backup-it
git:
  binary: git
  default_branch: master
ssh:
  enabled: false
ci:
  enabled: false
`, g.URL, port, g.State, g.Storage)
	if err := os.WriteFile(g.Config, []byte(cfg), 0o600); err != nil {
		t.Fatal(err)
	}
	g.cmd = exec.Command(bin, "serve", "--config", g.Config)
	g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
	if err := g.cmd.Start(); err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() {
		_ = g.cmd.Process.Kill()
		_, _ = g.cmd.Process.Wait()
		if t.Failed() {
			t.Logf("BlueGit-log %s:\n%s", g.URL, tail(g.log.String(), 60))
		}
	})
	g.WaitUp(20 * time.Second)
	// Aanmelden maakt de eerste gebruiker (beheerder) aan.
	jar, _ := cookiejar.New(nil)
	hc := &http.Client{Jar: jar}
	res, err := hc.Get(g.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	res.Body.Close()
	out, err := exec.Command(bin, "token", "create", "--config", g.Config, "--user", "tim", "--name", "it").CombinedOutput()
	if err != nil {
		t.Fatalf("token: %v %s", err, out)
	}
	g.Token = strings.TrimSpace(string(out))
	return g
}

func tail(s string, n int) string {
	lines := strings.Split(s, "\n")
	if len(lines) > n {
		lines = lines[len(lines)-n:]
	}
	return strings.Join(lines, "\n")
}

// RestartAs herstart dezelfde BlueGit (zelfde gegevens) met een andere
// dev-gebruiker. Zo is er een tweede gebruiker die geen beheerder is.
func (g *BlueGit) RestartAs(user string, authID int) {
	g.t.Helper()
	_ = g.cmd.Process.Kill()
	_, _ = g.cmd.Process.Wait()
	b, err := os.ReadFile(g.Config)
	if err != nil {
		g.t.Fatal(err)
	}
	var out []string
	for _, l := range strings.Split(string(b), "\n") {
		switch {
		case strings.HasPrefix(l, "  dev_user:"):
			l = "  dev_user: " + user
		case strings.HasPrefix(l, "  dev_auth_id:"):
			l = fmt.Sprintf("  dev_auth_id: %d", authID)
		}
		out = append(out, l)
	}
	if err := os.WriteFile(g.Config, []byte(strings.Join(out, "\n")), 0o600); err != nil {
		g.t.Fatal(err)
	}
	g.cmd = exec.Command(g.Bin, "serve", "--config", g.Config)
	g.cmd.Stdout, g.cmd.Stderr = g.log, g.log
	if err := g.cmd.Start(); err != nil {
		g.t.Fatal(err)
	}
	g.WaitUp(20 * time.Second)
}

// Page haalt een HTML-pagina op met een sessie (dev-login van de huidige
// dev-gebruiker).
func (g *BlueGit) Page(hc *http.Client, p string) string {
	g.t.Helper()
	res, err := hc.Get(g.URL + p)
	if err != nil {
		g.t.Fatal(err)
	}
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	return string(b)
}

// WaitUp wacht op /healthz.
func (g *BlueGit) WaitUp(d time.Duration) {
	g.t.Helper()
	deadline := time.Now().Add(d)
	for time.Now().Before(deadline) {
		res, err := http.Get(g.URL + "/healthz")
		if err == nil {
			res.Body.Close()
			if res.StatusCode == 200 {
				return
			}
		}
		time.Sleep(100 * time.Millisecond)
	}
	g.t.Fatalf("BlueGit %s kwam niet op:\n%s", g.URL, tail(g.log.String(), 40))
}

// API doet een verzoek met het token. path begint na /api/v1.
func (g *BlueGit) API(method, path string, in any) (int, []byte) {
	g.t.Helper()
	return g.APIWith(g.Token, method, path, in)
}

// APIWith gebruikt een ander token.
func (g *BlueGit) APIWith(tok, method, path string, in any) (int, []byte) {
	g.t.Helper()
	var body io.Reader
	if in != nil {
		b, _ := json.Marshal(in)
		body = bytes.NewReader(b)
	}
	req, _ := http.NewRequest(method, g.URL+"/api/v1"+path, body)
	req.Header.Set("Authorization", "Bearer "+tok)
	if in != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		g.t.Fatalf("%s %s: %v", method, path, err)
	}
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	return res.StatusCode, b
}

// MustAPI faalt bij een fout.
func (g *BlueGit) MustAPI(method, path string, in any) []byte {
	g.t.Helper()
	code, b := g.API(method, path, in)
	if code >= 300 {
		g.t.Fatalf("%s %s: %d %s", method, path, code, b)
	}
	return b
}

// AddServer voegt een backup server toe in BlueGit en geeft id en key.
func (g *BlueGit) AddServer(name string) (string, string) {
	g.t.Helper()
	var out struct{ ID, Key string }
	_ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers", map[string]any{"name": name}), &out)
	if !strings.HasPrefix(out.Key, "bgbk_") || out.ID == "" {
		g.t.Fatalf("server %+v", out)
	}
	return out.ID, out.Key
}

// NewKey voegt een backup server toe en geeft zijn Backupserver-Key.
func (g *BlueGit) NewKey() string {
	g.t.Helper()
	id, key := g.AddServer("test")
	g.Server = id
	return key
}

// RotateKey geeft de laatst toegevoegde backup server een nieuwe key.
func (g *BlueGit) RotateKey() string {
	g.t.Helper()
	var out struct{ Key string }
	_ = json.Unmarshal(g.MustAPI("POST", "/admin/backup/servers/"+g.Server+"/key", nil), &out)
	return out.Key
}

// Action voert een actie van backup server id uit via BlueGit.
func (g *BlueGit) Action(id, name string, in any) (int, []byte) {
	g.t.Helper()
	return g.API("POST", "/admin/backup/servers/"+id+"/actions/"+name, in)
}

// Project maakt een project met één commit.
func (g *BlueGit) Project(name, file, content string) {
	g.t.Helper()
	g.MustAPI("POST", "/projects", map[string]any{"name": name, "visibility": "private"})
	g.Commit(strings.ToLower(name), file, content, "create")
}

// Commit schrijft één bestand op master.
func (g *BlueGit) Commit(repo, file, content, action string) {
	g.t.Helper()
	g.MustAPI("POST", "/projects/tim/"+repo+"/repository/commits", map[string]any{
		"branch": "master", "commit_message": "zet " + file,
		"actions": []map[string]string{{"action": action, "file_path": file, "content": content}},
	})
}

// File leest een bestand van master, of geeft de HTTP-code.
func (g *BlueGit) File(repo, file string) (int, string) {
	g.t.Helper()
	req, _ := http.NewRequest("GET", g.URL+"/api/v1/projects/tim/"+repo+"/repository/files/"+file+"?ref=master", nil)
	req.Header.Set("Authorization", "Bearer "+g.Token)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		g.t.Fatal(err)
	}
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	return res.StatusCode, string(b)
}

// Issue maakt een issue.
func (g *BlueGit) Issue(repo, title string) {
	g.t.Helper()
	g.MustAPI("POST", "/repos/tim/"+repo+"/issues", map[string]any{"title": title})
}

// IssueTitles geeft alle issuetitels.
func (g *BlueGit) IssueTitles(repo string) []string {
	g.t.Helper()
	code, b := g.API("GET", "/repos/tim/"+repo+"/issues?state=all", nil)
	if code != 200 {
		g.t.Fatalf("issues: %d %s", code, b)
	}
	var list struct {
		Issues []struct{ Title string } `json:"issues"`
	}
	_ = json.Unmarshal(b, &list)
	var out []string
	for _, i := range list.Issues {
		out = append(out, i.Title)
	}
	return out
}

// ProjectCode is de HTTP-code van GET project.
func (g *BlueGit) ProjectCode(repo string) int {
	g.t.Helper()
	code, _ := g.API("GET", "/projects/tim/"+repo, nil)
	return code
}

// BackupStatus is wat BlueGit over een backup server weet.
type BackupStatus struct {
	InstanceID string `json:"instance_id"`
	HasKey     bool   `json:"-"`
	Name       string `json:"name"`
	Connected  bool   `json:"connected"`
	ServerURL  string `json:"server_url"`
	Archives   []struct {
		Name string `json:"name"`
		Size int64  `json:"size"`
	} `json:"archives"`
	Config struct {
		Fields []struct {
			Key   string `json:"key"`
			Value string `json:"value"`
		} `json:"fields"`
	} `json:"config"`
	RemoteError string `json:"remote_error"`
	// Compat: "" (onbekend), ok, bluegit_too_old of backup_too_old.
	Compat   string `json:"compat"`
	Protocol struct {
		BlueGit    int `json:"bluegit"`
		BlueGitMin int `json:"bluegit_min"`
		Backup     int `json:"backup"`
		BackupMin  int `json:"backup_min"`
	} `json:"protocol"`
}

// BackupStatus geeft de stand van de laatst toegevoegde backup server.
func (g *BlueGit) BackupStatus() BackupStatus { return g.ServerStatus(g.Server) }

// ServerStatus geeft de stand van backup server id ("" = de eerste).
func (g *BlueGit) ServerStatus(id string) BackupStatus {
	g.t.Helper()
	var list struct {
		InstanceID string `json:"instance_id"`
		Servers    []struct {
			ID string `json:"id"`
		} `json:"servers"`
	}
	_ = json.Unmarshal(g.MustAPI("GET", "/admin/backup", nil), &list)
	st := BackupStatus{InstanceID: list.InstanceID}
	if id == "" && len(list.Servers) > 0 {
		id = list.Servers[0].ID
	}
	found := false
	for _, s := range list.Servers {
		found = found || s.ID == id
	}
	if !found {
		return st
	}
	_ = json.Unmarshal(g.MustAPI("GET", "/admin/backup/servers/"+id, nil), &st)
	st.HasKey = true
	st.InstanceID = list.InstanceID
	return st
}

// Session geeft een HTTP-client met sessiecookie (dev-login).
func (g *BlueGit) Session() *http.Client {
	g.t.Helper()
	jar, _ := cookiejar.New(nil)
	hc := &http.Client{Jar: jar}
	res, err := hc.Get(g.URL + "/login")
	if err != nil {
		g.t.Fatal(err)
	}
	res.Body.Close()
	return hc
}

// Git draait git met het token als wachtwoord.
func (g *BlueGit) Git(dir string, args ...string) string {
	g.t.Helper()
	cmd := exec.Command("git", args...)
	cmd.Dir = dir
	cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_AUTHOR_NAME=it", "GIT_AUTHOR_EMAIL=it@example.invalid", "GIT_COMMITTER_NAME=it", "GIT_COMMITTER_EMAIL=it@example.invalid")
	out, err := cmd.CombinedOutput()
	if err != nil {
		g.t.Fatalf("git %v: %v\n%s", args, err, out)
	}
	return string(out)
}

// RemoteURL is de clone-URL met token.
func (g *BlueGit) RemoteURL(repo string) string {
	u, _ := url.Parse(g.URL)
	u.User = url.UserPassword("tim", g.Token)
	u.Path = "/tim/" + repo + ".git"
	return u.String()
}

// Backup is één backup server in dit proces.
type Backup struct {
	t   *testing.T
	Srv *server.Server
	URL string
	Dir string
	Cfg config.Config
}

func startBackup(t *testing.T, mod func(*config.Config)) *Backup {
	t.Helper()
	port := freePort(t)
	b := &Backup{t: t, URL: fmt.Sprintf("http://127.0.0.1:%d", port), Dir: t.TempDir()}
	cfg := config.Config{Listen: fmt.Sprintf("127.0.0.1:%d", port), PublicURL: b.URL, DataDir: b.Dir}
	// Snel genoeg voor tests; de standaardwaarden staan in config.Defaults.
	cfg.MinSyncInterval.Duration = 50 * time.Millisecond
	cfg.ArchiveInterval.Duration = time.Hour
	cfg.FullSyncInterval.Duration = time.Hour
	cfg.RateLimitKiB = -1
	cfg.MinFreeMB = 1
	if mod != nil {
		mod(&cfg)
	}
	cfg.Defaults()
	b.Cfg = cfg
	srv, err := server.New(cfg, slog.New(slog.NewTextHandler(&testWriter{t}, &slog.HandlerOptions{Level: slog.LevelWarn})))
	if err != nil {
		t.Fatal(err)
	}
	b.Srv = srv
	ln, err := net.Listen("tcp", cfg.Listen)
	if err != nil {
		t.Fatal(err)
	}
	hs := &http.Server{Handler: srv.Handler()}
	ctx, cancel := context.WithCancel(context.Background())
	go func() { _ = hs.Serve(ln) }()
	srv.Run(ctx)
	t.Cleanup(func() {
		cancel()
		_ = hs.Close()
	})
	return b
}

type testWriter struct{ t *testing.T }

func (w *testWriter) Write(p []byte) (int, error) {
	w.t.Log(strings.TrimRight(string(p), "\n"))
	return len(p), nil
}

// Admin doet een verzoek op de lokale beheer-API.
func (b *Backup) Admin(method, path string, in any) (int, []byte) {
	b.t.Helper()
	var body io.Reader
	if in != nil {
		raw, _ := json.Marshal(in)
		body = bytes.NewReader(raw)
	}
	req, _ := http.NewRequest(method, b.URL+"/api/v1/admin"+path, body)
	req.Header.Set("Authorization", "Bearer "+b.Srv.AdminToken())
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		b.t.Fatal(err)
	}
	defer res.Body.Close()
	raw, _ := io.ReadAll(res.Body)
	return res.StatusCode, raw
}

// Connect koppelt aan g zonder conflictkeuze; faalt bij een fout.
func (b *Backup) Connect(g *BlueGit, key string) {
	b.t.Helper()
	code, raw := b.Admin("POST", "/connect", server.ConnectRequest{URL: g.URL, Key: key})
	if code != 200 {
		b.t.Fatalf("connect: %d %s", code, raw)
	}
}

// Sync synchroniseert nu.
func (b *Backup) Sync() {
	b.t.Helper()
	code, raw := b.Admin("POST", "/sync", nil)
	if code != 200 {
		b.t.Fatalf("sync: %d %s", code, raw)
	}
}

// Archive maakt nu een archief en geeft de naam.
func (b *Backup) Archive() string {
	b.t.Helper()
	code, raw := b.Admin("POST", "/archive", nil)
	if code != 201 {
		b.t.Fatalf("archive: %d %s", code, raw)
	}
	var a struct{ Name string }
	_ = json.Unmarshal(raw, &a)
	return a.Name
}

// Mirror is het pad van een logisch bestand in de kopie.
func (b *Backup) Mirror(logical string) string {
	return filepath.Join(b.Dir, "mirror", filepath.FromSlash(logical))
}

// Archives geeft de archiefnamen, nieuwste eerst.
func (b *Backup) Archives() []string {
	b.t.Helper()
	_, raw := b.Admin("GET", "/archives", nil)
	var out struct {
		Archives []struct{ Name string }
	}
	_ = json.Unmarshal(raw, &out)
	var names []string
	for _, a := range out.Archives {
		names = append(names, a.Name)
	}
	return names
}

// Status leest de status.
func (b *Backup) Status() server.Status {
	b.t.Helper()
	_, raw := b.Admin("GET", "/status", nil)
	var st server.Status
	_ = json.Unmarshal(raw, &st)
	return st
}

// Eventually herhaalt f tot hij true geeft.
func Eventually(t *testing.T, d time.Duration, what string, f func() bool) {
	t.Helper()
	deadline := time.Now().Add(d)
	for time.Now().Before(deadline) {
		if f() {
			return
		}
		time.Sleep(50 * time.Millisecond)
	}
	t.Fatalf("na %v nog steeds niet: %s", d, what)
}

// gitLog geeft de onderwerpen van een bare repo in de kopie.
func gitLog(t *testing.T, gitDir string) string {
	t.Helper()
	out, err := exec.Command("git", "--git-dir", gitDir, "log", "--format=%s", "master").CombinedOutput()
	if err != nil {
		return "FOUT: " + string(out)
	}
	return string(out)
}
