package archive

import (
	"archive/tar"
	"bytes"
	"compress/gzip"
	"io"
	"io/fs"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
)

func runGit(t *testing.T, dir string, args ...string) string {
	t.Helper()
	cmd := exec.Command("git", args...)
	cmd.Dir = dir
	cmd.Env = append(os.Environ(), "GIT_CONFIG_NOSYSTEM=1", "HOME="+t.TempDir(),
		"GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@example.invalid", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@example.invalid")
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("git %v: %v\n%s", args, err, out)
	}
	return strings.TrimSpace(string(out))
}

// packedMirror maakt een kopie (alleen gewone bestanden, zoals de mirror)
// met een bare repo waarvan alle refs in packed-refs staan: refs/ is leeg
// en ontbreekt dus in de kopie.
func packedMirror(t *testing.T) (mirror, head string) {
	t.Helper()
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git niet gevonden")
	}
	src := filepath.Join(t.TempDir(), "gepackt.git")
	runGit(t, t.TempDir(), "init", "--bare", "-b", "master", src)
	work := t.TempDir()
	runGit(t, work, "init", "-b", "master")
	_ = os.WriteFile(filepath.Join(work, "a.txt"), []byte("a"), 0o644)
	runGit(t, work, "add", ".")
	runGit(t, work, "commit", "-m", "eerste")
	runGit(t, work, "tag", "v1")
	runGit(t, work, "push", src, "master", "v1")
	runGit(t, src, "gc", "--quiet")
	runGit(t, src, "pack-refs", "--all")
	head = runGit(t, src, "rev-parse", "master")
	mirror = t.TempDir()
	for p, c := range map[string]string{"state/bluegit.db": "db", "state/secret.key": "k"} {
		full := filepath.Join(mirror, filepath.FromSlash(p))
		_ = os.MkdirAll(filepath.Dir(full), 0o755)
		_ = os.WriteFile(full, []byte(c), 0o644)
	}
	dstRepo := filepath.Join(mirror, "data", "repos", "tim", "gepackt.git")
	err := filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error {
		if err != nil || !d.Type().IsRegular() {
			return err
		}
		rel, _ := filepath.Rel(src, p)
		b, err := os.ReadFile(p)
		if err != nil {
			return err
		}
		out := filepath.Join(dstRepo, rel)
		_ = os.MkdirAll(filepath.Dir(out), 0o755)
		return os.WriteFile(out, b, 0o644)
	})
	if err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(filepath.Join(dstRepo, "refs")); err == nil {
		t.Fatal("testopzet: refs/ hoort te ontbreken")
	}
	return mirror, head
}

func requireValidRepo(t *testing.T, repo, head string) {
	t.Helper()
	runGit(t, repo, "--git-dir", repo, "fsck", "--full", "--strict")
	if got := runGit(t, repo, "--git-dir", repo, "rev-parse", "master"); got != head {
		t.Fatalf("master %s, verwacht %s", got, head)
	}
	if got := runGit(t, repo, "--git-dir", repo, "rev-parse", "v1^{commit}"); got != head {
		t.Fatalf("v1 %s, verwacht %s", got, head)
	}
}

// Backup, restore, geldige repo: het archief bevat de verplichte mappen en
// Extract levert een repo op die git herkent.
func TestPackedRefsOnlyRepoRoundtrip(t *testing.T) {
	mirror, head := packedMirror(t)
	var buf bytes.Buffer
	if err := WriteTarGz(&buf, mirror); err != nil {
		t.Fatal(err)
	}
	raw := buf.Bytes()

	// Het archief heeft mapitems voor refs/heads en refs/tags, zodat ook
	// een gewone tar -x een geldige repo oplevert.
	gz, _ := gzip.NewReader(bytes.NewReader(raw))
	tr := tar.NewReader(gz)
	dirs := map[string]bool{}
	for {
		h, err := tr.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			t.Fatal(err)
		}
		if h.Typeflag == tar.TypeDir {
			dirs[h.Name] = true
		}
	}
	for _, want := range []string{"data/repos/tim/gepackt.git/refs/heads/", "data/repos/tim/gepackt.git/refs/tags/", "data/repos/tim/gepackt.git/objects/pack/"} {
		if !dirs[want] {
			t.Fatalf("map %s ontbreekt in archief: %v", want, dirs)
		}
	}

	dst := filepath.Join(t.TempDir(), "x")
	if err := ExtractReader(bytes.NewReader(raw), dst); err != nil {
		t.Fatal(err)
	}
	requireValidRepo(t, filepath.Join(dst, "data/repos/tim/gepackt.git"), head)

	if tarBin, err := exec.LookPath("tar"); err == nil {
		plain := t.TempDir()
		cmd := exec.Command(tarBin, "-xzf", "-", "-C", plain)
		cmd.Stdin = bytes.NewReader(raw)
		if out, err := cmd.CombinedOutput(); err != nil {
			t.Fatalf("tar: %v %s", err, out)
		}
		requireValidRepo(t, filepath.Join(plain, "data/repos/tim/gepackt.git"), head)
	}
}

// Een archief van vóór de fix (zonder mapitems) wordt bij Extract hersteld.
func TestExtractRepairsOldArchiveWithoutDirs(t *testing.T) {
	mirror, head := packedMirror(t)
	var buf bytes.Buffer
	gz := gzip.NewWriter(&buf)
	tw := tar.NewWriter(gz)
	_ = filepath.WalkDir(mirror, func(p string, d fs.DirEntry, err error) error {
		if err != nil || !d.Type().IsRegular() {
			return err
		}
		rel, _ := filepath.Rel(mirror, p)
		return addFile(tw, p, filepath.ToSlash(rel))
	})
	_ = tw.Close()
	_ = gz.Close()
	dst := filepath.Join(t.TempDir(), "x")
	if err := ExtractReader(&buf, dst); err != nil {
		t.Fatal(err)
	}
	requireValidRepo(t, filepath.Join(dst, "data/repos/tim/gepackt.git"), head)
}
