package archive

import (
	"archive/tar"
	"bytes"
	"compress/gzip"
	"os"
	"path/filepath"
	"testing"
	"time"
)

func mkMirror(t *testing.T) string {
	d := t.TempDir()
	files := map[string]string{"state/bluegit.db": "db", "state/secret.key": "k", "data/repos/tim/a.git/HEAD": "ref", "stray.txt": "nee"}
	for p, c := range files {
		full := filepath.Join(d, filepath.FromSlash(p))
		_ = os.MkdirAll(filepath.Dir(full), 0o755)
		_ = os.WriteFile(full, []byte(c), 0o644)
	}
	mt := time.UnixMilli(1_700_000_000_123)
	_ = os.Chtimes(filepath.Join(d, "data/repos/tim/a.git/HEAD"), mt, mt)
	return d
}

func TestCreateListExtractRoundtrip(t *testing.T) {
	s := &Store{Dir: t.TempDir(), Free: func(string) (uint64, error) { return 1 << 40, nil }}
	now := time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC)
	a, removed, err := s.Create(mkMirror(t), now, 10, 0)
	if err != nil || len(removed) != 0 || a.Name != "bluegit-20261115-120000.tar.gz" {
		t.Fatal(a, removed, err)
	}
	b, _, _ := s.Create(mkMirror(t), now, 10, 0)
	if b.Name != "bluegit-20261115-120000-1.tar.gz" {
		t.Fatalf("dubbele naam: %s", b.Name)
	}
	list, _ := s.List()
	if len(list) != 2 {
		t.Fatal(list)
	}
	dst := filepath.Join(t.TempDir(), "x")
	p, _ := s.Path(a.Name)
	if err := Extract(p, dst); err != nil {
		t.Fatal(err)
	}
	fi, err := os.Stat(filepath.Join(dst, "data/repos/tim/a.git/HEAD"))
	if err != nil || fi.ModTime().UnixMilli() != 1_700_000_000_123 {
		t.Fatalf("mtime in milliseconden niet bewaard: %v %v", err, fi)
	}
	if _, err := os.Stat(filepath.Join(dst, "stray.txt")); err == nil {
		t.Fatal("onbekend pad in archief")
	}
	if _, err := s.Path("../etc/passwd"); err == nil {
		t.Fatal("pad buiten de map")
	}
}

func TestPruneRules(t *testing.T) {
	free := uint64(1 << 40)
	s := &Store{Dir: t.TempDir(), Free: func(string) (uint64, error) { return free, nil }}
	now := time.Date(2026, 11, 15, 12, 0, 0, 0, time.UTC)
	var names []string
	for i := 0; i < 4; i++ {
		a, _, err := s.Create(mkMirror(t), now.Add(time.Duration(i)*time.Second), 1, 0)
		if err != nil {
			t.Fatal(err)
		}
		names = append(names, a.Name)
	}
	// Leeftijd: 40, 31 en 29 dagen; nieuwste vandaag.
	for i, d := range []int{40, 31, 29} {
		old := now.Add(-time.Duration(d) * 24 * time.Hour)
		_ = os.Chtimes(filepath.Join(s.Dir, names[i]), old, old)
	}
	removed, err := s.Prune(now, 30, 0)
	if err != nil || len(removed) != 2 {
		t.Fatal(removed, err)
	}
	// 0 dagen = niet op leeftijd.
	if r, _ := s.Prune(now.Add(1000*24*time.Hour), 0, 0); len(r) != 0 {
		t.Fatal(r)
	}
	// Alles te oud: het nieuwste blijft.
	if r, _ := s.Prune(now.Add(1000*24*time.Hour), 1, 0); len(r) != 1 {
		t.Fatal(r)
	}
	if l, _ := s.List(); len(l) != 1 || l[0].Name != names[3] {
		t.Fatal(l)
	}
	// Schijf vol: nieuwste blijft.
	free = 0
	if r, _ := s.Prune(now, 0, 1<<20); len(r) != 0 {
		t.Fatal(r)
	}
	// Nieuw archief bij volle schijf: oude weg, dan pas schrijven; lukt
	// dat niet, dan een fout.
	if _, _, err := s.Create(mkMirror(t), now.Add(time.Hour), 1, 1<<20); err == nil {
		t.Fatal("archief zonder ruimte")
	}
	if l, _ := s.List(); len(l) != 0 {
		t.Fatalf("het oude archief had weg gemoeten voor ruimte: %v", l)
	}
}

func TestExtractRejects(t *testing.T) {
	for name, hdr := range map[string]*tar.Header{
		"traversal": {Name: "data/repos/../../x", Typeflag: tar.TypeReg, Mode: 0o644},
		"symlink":   {Name: "data/repos/a/l", Typeflag: tar.TypeSymlink, Linkname: "/etc/passwd"},
		"absoluut":  {Name: "/etc/passwd", Typeflag: tar.TypeReg, Mode: 0o644},
	} {
		var buf bytes.Buffer
		gz := gzip.NewWriter(&buf)
		tw := tar.NewWriter(gz)
		_ = tw.WriteHeader(hdr)
		_ = tw.Close()
		_ = gz.Close()
		if err := ExtractReader(&buf, filepath.Join(t.TempDir(), "x")); err == nil {
			t.Errorf("%s geaccepteerd", name)
		}
	}
	if ValidName("bluegit-x.tar.gz") || !ValidName("bluegit-20261115-120000.tar.gz") || ValidName("../bluegit-20261115-120000.tar.gz") {
		t.Fatal("ValidName")
	}
}
