package gitrepo

import (
	"errors"
	"os"
	"os/exec"
	"path/filepath"
	"testing"
	"time"

	"github.com/go-git/go-billy/v5/osfs"
	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/plumbing/object"

	"gitweb/internal/store"
)

// makeBareRepo builds a real bare repo at <root>/<user>/<name> via the git CLI
// and returns the store-relative repo path "<user>/<name>". Skips the test if
// git is unavailable.
func makeBareRepo(t *testing.T, root, user, name string) string {
	t.Helper()
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git not available")
	}

	work := t.TempDir()
	run := func(dir string, args ...string) {
		t.Helper()
		cmd := exec.Command("git", args...)
		cmd.Dir = dir
		cmd.Env = append(os.Environ(),
			"GIT_AUTHOR_NAME=Test", "GIT_AUTHOR_EMAIL=test@example.com",
			"GIT_COMMITTER_NAME=Test", "GIT_COMMITTER_EMAIL=test@example.com",
		)
		if out, err := cmd.CombinedOutput(); err != nil {
			t.Fatalf("git %v: %v\n%s", args, err, out)
		}
	}

	run(work, "init", "-b", "main")
	if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("# Demo\n\nhi\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(work, "main.go"), []byte("package main\n\nfunc main() {}\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	run(work, "add", ".")
	run(work, "commit", "-m", "initial commit")
	run(work, "checkout", "-b", "feature/x")
	if err := os.WriteFile(filepath.Join(work, "main.go"), []byte("package main\n\nfunc main() { _ = 1 }\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	run(work, "commit", "-am", "tweak main")
	run(work, "tag", "v1.0.0")
	run(work, "checkout", "main")

	bare := filepath.Join(root, user, name)
	if err := os.MkdirAll(filepath.Dir(bare), 0o755); err != nil {
		t.Fatal(err)
	}
	run(work, "clone", "--bare", work, bare)
	return user + "/" + name
}

// newTestCache builds a Cache over st rooted at a test tempdir.
func newTestCache(t *testing.T, st store.Store, opts CacheOptions) *Cache {
	t.Helper()
	if opts.Dir == "" {
		opts.Dir = t.TempDir()
	}
	c, err := NewCache(st, opts)
	if err != nil {
		t.Fatalf("NewCache: %v", err)
	}
	return c
}

func TestMaterializeAndOpen(t *testing.T) {
	root := t.TempDir()
	repoPath := makeBareRepo(t, root, "u@d.com", "demo.git")
	st := store.NewLocalStore(root)

	c := newTestCache(t, st, CacheOptions{})
	repo, release, err := c.Get(repoPath)
	if err != nil {
		t.Fatalf("Get: %v", err)
	}
	defer release()

	head, err := repo.Head()
	if err != nil {
		t.Fatalf("Head: %v", err)
	}
	if head.Name().Short() != "main" {
		t.Fatalf("head = %q, want main", head.Name().Short())
	}

	// Log walks.
	iter, err := repo.Log(&git.LogOptions{From: head.Hash()})
	if err != nil {
		t.Fatalf("Log: %v", err)
	}
	var n int
	err = iter.ForEach(func(*object.Commit) error { n++; return nil })
	if err != nil {
		t.Fatalf("Log iter: %v", err)
	}
	if n == 0 {
		t.Fatal("expected at least one commit")
	}

	// Tree walks: README.md present at HEAD.
	commit, err := repo.CommitObject(head.Hash())
	if err != nil {
		t.Fatalf("CommitObject: %v", err)
	}
	tree, err := commit.Tree()
	if err != nil {
		t.Fatalf("Tree: %v", err)
	}
	if _, err := tree.File("README.md"); err != nil {
		t.Fatalf("README.md not in tree: %v", err)
	}

	// Branch + tag are visible.
	if _, err := repo.Reference("refs/heads/feature/x", false); err != nil {
		t.Fatalf("feature/x branch missing: %v", err)
	}
	if _, err := repo.Tag("v1.0.0"); err != nil {
		t.Fatalf("v1.0.0 tag missing: %v", err)
	}
}

func TestMaterializeToDisk(t *testing.T) {
	root := t.TempDir()
	repoPath := makeBareRepo(t, root, "u@d.com", "demo.git")
	st := store.NewLocalStore(root)

	dir := t.TempDir()
	man, err := materialize(st, repoPath, osfs.New(dir), defaultMaxRepoBytes)
	if err != nil {
		t.Fatalf("materialize: %v", err)
	}
	// The bare-repo layout lands on the real filesystem.
	if _, err := os.Stat(filepath.Join(dir, "HEAD")); err != nil {
		t.Fatalf("HEAD not on disk: %v", err)
	}
	if fi, err := os.Stat(filepath.Join(dir, "objects")); err != nil || !fi.IsDir() {
		t.Fatalf("objects/ not a dir on disk: %v", err)
	}
	// Manifest entries match what is on disk.
	for name, info := range man {
		fi, err := os.Stat(filepath.Join(dir, filepath.FromSlash(name)))
		if err != nil {
			t.Fatalf("manifest file %s missing on disk: %v", name, err)
		}
		if fi.Size() != info.Size {
			t.Errorf("%s: size %d on disk, %d in manifest", name, fi.Size(), info.Size)
		}
	}
}

func TestMaterializeTooLarge(t *testing.T) {
	root := t.TempDir()
	repoPath := makeBareRepo(t, root, "u@d.com", "demo.git")
	st := store.NewLocalStore(root)

	_, err := materialize(st, repoPath, osfs.New(t.TempDir()), 10)
	if !errors.Is(err, ErrRepoTooLarge) {
		t.Fatalf("err = %v, want ErrRepoTooLarge", err)
	}
}

func TestCacheReusesAndInvalidates(t *testing.T) {
	root := t.TempDir()
	repoPath := makeBareRepo(t, root, "u@d.com", "demo.git")
	st := store.NewLocalStore(root)
	c := newTestCache(t, st, CacheOptions{})

	r1, release1, err := c.Get(repoPath)
	if err != nil {
		t.Fatalf("Get: %v", err)
	}
	defer release1()
	r2, release2, err := c.Get(repoPath)
	if err != nil {
		t.Fatalf("Get: %v", err)
	}
	defer release2()
	if r1 != r2 {
		t.Fatal("expected cached repo to be reused (same pointer)")
	}

	// Bump the repo's mtime so LocalStore.Seq changes -> re-materialization.
	later := time.Now().Add(2 * time.Second)
	if err := os.Chtimes(filepath.Join(root, repoPath, "HEAD"), later, later); err != nil {
		t.Fatal(err)
	}
	r3, release3, err := c.Get(repoPath)
	if err != nil {
		t.Fatalf("Get: %v", err)
	}
	defer release3()
	if r3 == r1 {
		t.Fatal("expected re-materialization after edit (different pointer)")
	}
}