package backup

import (
	"archive/tar"
	"bytes"
	"compress/gzip"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"fmt"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"
)

func TestSignVerify(t *testing.T) {
	sec := SigningSecret("bgbk_x")
	now := time.Unix(1_800_000_000, 0)
	body := []byte(`{"archive":"a"}`)
	req, _ := http.NewRequest("POST", "http://b/api/v1/rollback", bytes.NewReader(body))
	Sign(req, sec, "inst", body, now)
	if err := Verify(req, sec, body, now.Add(time.Minute)); err != nil {
		t.Fatal(err)
	}
	if Verify(req, sec, []byte(`{"archive":"b"}`), now) == nil {
		t.Fatal("andere body geaccepteerd")
	}
	if Verify(req, SigningSecret("bgbk_y"), body, now) == nil {
		t.Fatal("ander geheim geaccepteerd")
	}
	if Verify(req, sec, body, now.Add(10*time.Minute)) == nil {
		t.Fatal("oude timestamp geaccepteerd")
	}
	req.URL.Path = "/api/v1/notify"
	if Verify(req, sec, body, now) == nil {
		t.Fatal("ander pad geaccepteerd")
	}
}

func TestKeyLifecycle(t *testing.T) {
	m := &Manager{Dir: t.TempDir()}
	if _, ok := m.Check("bgbk_nope"); ok {
		t.Fatal("check zonder key")
	}
	key, c, err := m.Add("  nas   kelder ", "tim")
	if err != nil || !strings.HasPrefix(key, KeyPrefix) || c.KeyHash == "" || c.Name != "nas kelder" || c.ID == "" {
		t.Fatal(key, c, err)
	}
	raw, _ := os.ReadFile(filepath.Join(m.Dir, "backup.json"))
	if strings.Contains(string(raw), key) {
		t.Fatal("key staat leesbaar op schijf")
	}
	fi, _ := os.Stat(filepath.Join(m.Dir, "backup.json"))
	if fi.Mode().Perm() != 0o600 {
		t.Fatalf("mode %v", fi.Mode())
	}
	if got, ok := m.Check(key); !ok || got.ID != c.ID {
		t.Fatal("eigen key geweigerd")
	}
	if _, err := m.Connect(c.ID, "http://backup:9000/", "srv1"); err != nil {
		t.Fatal(err)
	}
	c, _ = m.Get(c.ID)
	if !c.Connected() || c.ServerURL != "http://backup:9000" || c.SignSecret != SigningSecret(key) {
		t.Fatalf("%+v", c)
	}
	// Een tweede backup server met een eigen key; de eerste blijft werken.
	keyB, b, err := m.Add("offsite", "tim")
	if err != nil {
		t.Fatal(err)
	}
	if got, ok := m.Check(keyB); !ok || got.ID != b.ID {
		t.Fatal("tweede key")
	}
	if got, ok := m.Check(key); !ok || got.ID != c.ID {
		t.Fatal("eerste key werkt niet meer")
	}
	if list, _ := m.List(); len(list) != 2 {
		t.Fatalf("%d servers", len(list))
	}
	// Nieuwe key voor de eerste: oude key dood, koppeling weg, tweede blijft.
	key2, _, err := m.RotateKey(c.ID, "tim")
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := m.Check(key); ok {
		t.Fatal("oude key werkt nog")
	}
	if _, ok := m.Check(key2); !ok {
		t.Fatal("nieuwe key geweigerd")
	}
	if c, _ := m.Get(c.ID); c.Connected() {
		t.Fatal("nieuwe key houdt oude server vast")
	}
	if _, err := m.Rename(b.ID, "Offsite 2"); err != nil {
		t.Fatal(err)
	}
	if b, _ := m.Get(b.ID); b.Name != "Offsite 2" {
		t.Fatal(b.Name)
	}
	id1, _ := m.InstanceID()
	id2, _ := m.InstanceID()
	if id1 == "" || id1 != id2 {
		t.Fatal("instance-id niet vast")
	}
	if err := m.Remove(c.ID); err != nil {
		t.Fatal(err)
	}
	if _, ok := m.Check(key2); ok {
		t.Fatal("ingetrokken key werkt")
	}
	if _, ok := m.Check(keyB); !ok {
		t.Fatal("andere server verloor zijn key")
	}
	if err := m.Remove("bestaatniet"); err != ErrUnknown {
		t.Fatal(err)
	}
	for i := 0; i < MaxServers; i++ {
		_, _, _ = m.Add("x", "tim")
	}
	if _, _, err := m.Add("x", "tim"); err != ErrTooMany {
		t.Fatal(err)
	}
}

func TestLegacySingleConn(t *testing.T) {
	d := t.TempDir()
	key := "bgbk_" + strings.Repeat("ab", 32)
	old := `{"key_hash":"` + HashKey(key) + `","sign_secret":"` + SigningSecret(key) + `","key_hint":"bgbk_ababab","server_url":"http://b:8080"}`
	_ = os.WriteFile(filepath.Join(d, "backup.json"), []byte(old), 0o600)
	m := &Manager{Dir: d}
	c, ok := m.Check(key)
	if !ok || c.ID == "" || c.Name != "backup" || !c.Connected() {
		t.Fatalf("%+v %v", c, ok)
	}
}

func TestCleanLogical(t *testing.T) {
	good := []string{"state/bluegit.db", "state/secret.key", "state/ssh/host_ed25519", "data/repos/tim/a.git/HEAD", "data/releases/tim/a/v1/x.tgz"}
	bad := []string{"", "/etc/passwd", "state/../x", "state/storage_path", "state/backup.json", "state/instance_id", "data/work/1/x", "data/releases/.incoming/x", "data/repos", "state/ssh", "x/y", "data/repos/../../etc", "state//secret.key", "data\\repos\\x"}
	for _, p := range good {
		if _, ok := CleanLogical(p); !ok {
			t.Errorf("geweigerd: %s", p)
		}
	}
	for _, p := range bad {
		if _, ok := CleanLogical(p); ok {
			t.Errorf("toegestaan: %s", p)
		}
	}
}

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

func fakeTree(t *testing.T) Tree {
	st, data := t.TempDir(), t.TempDir()
	write(t, filepath.Join(st, "bluegit.db"), "live-db")
	write(t, filepath.Join(st, "secret.key"), "k")
	write(t, filepath.Join(st, "storage_path"), data)
	write(t, filepath.Join(st, "backup.json"), "{}")
	write(t, filepath.Join(st, "ssh", "host_ed25519"), "hk")
	write(t, filepath.Join(data, "repos", "tim", "a.git", "HEAD"), "ref: refs/heads/master")
	write(t, filepath.Join(data, "repos", "tim", "a.git", "index.lock"), "x")
	write(t, filepath.Join(data, "releases", ".incoming", "x"), "x")
	write(t, filepath.Join(data, "releases", "tim", "a", "v1", "a.bin"), "bin")
	write(t, filepath.Join(data, "work", "1", "f"), "x")
	_ = os.Symlink("/etc/passwd", filepath.Join(data, "repos", "tim", "evil"))
	return Tree{StateDir: st, DataDir: data, Snapshot: func(dst string) error {
		return os.WriteFile(dst, []byte("snapshot-db"), 0o600)
	}}
}

func TestManifestAndResolve(t *testing.T) {
	tr := fakeTree(t)
	m, err := tr.Build("inst")
	if err != nil {
		t.Fatal(err)
	}
	var paths []string
	for _, e := range m.Files {
		paths = append(paths, e.Path)
	}
	got := strings.Join(paths, ",")
	want := "data/releases/tim/a/v1/a.bin,data/repos/tim/a.git/HEAD,state/bluegit.db,state/secret.key,state/ssh/host_ed25519"
	if got != want {
		t.Fatalf("manifest\n got %s\nwant %s", got, want)
	}
	if m.Files[2].SHA256 == "" {
		t.Fatal("database zonder hash")
	}
	p, err := tr.Resolve(DBPath)
	if err != nil {
		t.Fatal(err)
	}
	if b, _ := os.ReadFile(p); string(b) != "snapshot-db" {
		t.Fatalf("database komt niet uit de kopie: %s", b)
	}
	for _, bad := range []string{"state/storage_path", "data/repos/tim/evil", "data/repos/../../etc/passwd"} {
		if _, err := tr.Resolve(bad); err == nil {
			t.Errorf("resolve %s toegestaan", bad)
		}
	}
}

type tf struct {
	name, body string
	typ        byte
}

func tgz(t *testing.T, files []tf) []byte {
	var buf bytes.Buffer
	gz := gzip.NewWriter(&buf)
	tw := tar.NewWriter(gz)
	for _, f := range files {
		typ := f.typ
		if typ == 0 {
			typ = tar.TypeReg
		}
		h := &tar.Header{Name: f.name, Mode: 0o644, Size: int64(len(f.body)), Typeflag: typ, ModTime: time.Unix(1_700_000_000, 0)}
		if typ == tar.TypeSymlink {
			h.Size, h.Linkname = 0, "/etc/passwd"
		}
		if err := tw.WriteHeader(h); err != nil {
			t.Fatal(err)
		}
		if typ == tar.TypeReg {
			_, _ = tw.Write([]byte(f.body))
		}
	}
	tw.Close()
	gz.Close()
	return buf.Bytes()
}

func TestStageAndApply(t *testing.T) {
	tr := fakeTree(t)
	archive := tgz(t, []tf{
		{name: "state/bluegit.db", body: "old-db"},
		{name: "state/secret.key", body: "old-key"},
		{name: "data/repos/tim/b.git/HEAD", body: "ref: refs/heads/main"},
	})
	n, err := tr.Stage(bytes.NewReader(archive))
	if err != nil || n != 3 {
		t.Fatal(n, err)
	}
	if b, _ := os.ReadFile(filepath.Join(tr.StateDir, "bluegit.db")); string(b) != "live-db" {
		t.Fatal("stage raakte de live database")
	}
	if !HasPending(tr.StateDir) {
		t.Fatal("geen READY")
	}
	ok, err := ApplyPending(tr.StateDir)
	if err != nil || !ok {
		t.Fatal(ok, err)
	}
	check := func(p, want string) {
		t.Helper()
		b, err := os.ReadFile(p)
		if want == "" {
			if err == nil {
				t.Errorf("%s bestaat nog", p)
			}
			return
		}
		if string(b) != want {
			t.Errorf("%s = %q, wil %q", p, b, want)
		}
	}
	check(filepath.Join(tr.StateDir, "bluegit.db"), "old-db")
	check(filepath.Join(tr.StateDir, "secret.key"), "old-key")
	check(filepath.Join(tr.StateDir, "ssh", "host_ed25519"), "")
	check(filepath.Join(tr.StateDir, "backup.json"), "{}")
	check(filepath.Join(tr.StateDir, "storage_path"), tr.DataDir)
	check(filepath.Join(tr.DataDir, "repos", "tim", "b.git", "HEAD"), "ref: refs/heads/main")
	check(filepath.Join(tr.DataDir, "repos", "tim", "a.git", "HEAD"), "")
	check(filepath.Join(tr.DataDir, "releases", "tim", "a", "v1", "a.bin"), "")
	check(filepath.Join(tr.DataDir, "work", "1", "f"), "x")
	if HasPending(tr.StateDir) {
		t.Fatal("READY blijft staan")
	}
	if ok, _ := ApplyPending(tr.StateDir); ok {
		t.Fatal("tweede keer toegepast")
	}
}

func TestStageRejects(t *testing.T) {
	cases := map[string][]tf{
		"traversal":  {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/../../../etc/x", body: "x"}},
		"symlink":    {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "data/repos/a/l", typ: tar.TypeSymlink}},
		"onbekend":   {{name: "state/bluegit.db", body: "x"}, {name: "state/secret.key", body: "k"}, {name: "state/storage_path", body: "/"}},
		"zonder-db":  {{name: "state/secret.key", body: "k"}},
		"zonder-key": {{name: "state/bluegit.db", body: "x"}},
	}
	for name, files := range cases {
		tr := fakeTree(t)
		if _, err := tr.Stage(bytes.NewReader(tgz(t, files))); err == nil {
			t.Errorf("%s: geaccepteerd", name)
		}
		if HasPending(tr.StateDir) {
			t.Errorf("%s: READY na fout", name)
		}
		if _, err := os.Stat(filepath.Join(tr.StateDir, ".restore")); err == nil {
			t.Errorf("%s: staging blijft staan", name)
		}
	}
	if _, err := fakeTree(t).Stage(strings.NewReader("geen gzip")); err == nil {
		t.Error("geen gzip geaccepteerd")
	}
}

// Vaste vector: bluegit-backup (internal/protocol) test dezelfde waarden.
func TestSignatureVector(t *testing.T) {
	sec := SigningSecret("bgbk_test")
	if sec != "c04d0bdbac2260c010f61c9b063b28026eed1d2292c928708708821449e72c2a" {
		t.Fatalf("geheim %s", sec)
	}
	if got := Signature(sec, "post", "/api/v1/notify", "1800000000", []byte("{}")); got != "51c5ec72528304632383637b99dfda1e14b68194bbec2d4faa36c9d5ef892548" {
		t.Fatalf("handtekening %s", got)
	}
}

// Twee backup servers die tegelijk een manifest ophalen krijgen elk hun
// eigen databasekopie; de ene vervangt de kopie van de andere niet.
func TestSnapshotPerConnection(t *testing.T) {
	base := fakeTree(t)
	var mu sync.Mutex
	busy := 0
	n := 0
	base.Snapshot = func(dst string) error {
		mu.Lock()
		busy++
		n++
		if busy > 1 {
			mu.Unlock()
			return errors.New("twee kopieën tegelijk")
		}
		body := fmt.Sprintf("snapshot-%d", n)
		mu.Unlock()
		time.Sleep(5 * time.Millisecond)
		err := os.WriteFile(dst, []byte(body), 0o600)
		mu.Lock()
		busy--
		mu.Unlock()
		return err
	}
	a, b := base, base
	a.Conn, b.Conn = "aaa", "bbb"
	var wg sync.WaitGroup
	errs := make(chan error, 20)
	for i := 0; i < 10; i++ {
		for _, tr := range []Tree{a, b} {
			wg.Add(1)
			go func(tr Tree) {
				defer wg.Done()
				if _, err := tr.Build("inst"); err != nil {
					errs <- err
				}
			}(tr)
		}
	}
	wg.Wait()
	close(errs)
	for err := range errs {
		t.Fatal(err)
	}
	ma, err := a.Build("inst")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := b.Build("inst"); err != nil {
		t.Fatal(err)
	}
	// De kopie van a is niet veranderd door de build van b.
	p, _ := a.Resolve(DBPath)
	raw, _ := os.ReadFile(p)
	sum := sha256.Sum256(raw)
	for _, e := range ma.Files {
		if e.Path == DBPath && e.SHA256 != hex.EncodeToString(sum[:]) {
			t.Fatal("kopie van a is overschreven door b")
		}
	}
	a.RemoveSnapshot()
	if _, err := a.Resolve(DBPath); err == nil {
		t.Fatal("kopie niet opgeruimd")
	}
	if _, err := b.Resolve(DBPath); err != nil {
		t.Fatal("kopie van b is mee opgeruimd")
	}
}
