package server

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"gitweb/internal/store"
)

// TestIncrementalFetch covers a fetch by a client that already holds most of
// the history. Clone never exercises negotiation: it sends "want" lines and
// "done" in one request, with no "have" lines at all. A fetch does, and git
// splits negotiation across requests — it offers its first batch of haves
// (INITIAL_FLUSH, 16) terminated by a flush-pkt and *no* "done", then waits for
// the server's ACK/NAK before deciding what to ask for next. A server that
// answers that round with a packfile breaks the client, which is still reading
// pkt-lines: it reports
//
//	fatal: protocol error: bad line length character: PACK
//
// The history therefore has to be deep enough that git does not exhaust its
// haves (and so append "done") in the first round.
func TestIncrementalFetch(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git not available")
	}
	env := gitEnv(t)
	ns := t.TempDir()

	const owner = "u@d.com"
	const repoPath = owner + "/deep.git"
	bare := filepath.Join(ns, filepath.FromSlash(repoPath))

	// A history comfortably deeper than git's 16-have first batch.
	const depth = 24
	work := t.TempDir()
	mustGit(t, env, work, "init", "-q", "-b", "main")
	for i := range depth {
		writeTestFile(t, work, "f.txt", fmt.Sprintf("v%d\n", i))
		mustGit(t, env, work, "add", "-A")
		mustGit(t, env, work, "commit", "-qm", fmt.Sprintf("commit %d", i))
	}
	if err := os.MkdirAll(filepath.Dir(bare), 0o755); err != nil {
		t.Fatal(err)
	}
	mustGit(t, env, work, "clone", "-q", "--bare", work, bare)
	if err := os.WriteFile(filepath.Join(bare, "Access"), []byte("read,list: all\n*: "+owner+"\n"), 0o644); err != nil {
		t.Fatal(err)
	}

	srv, err := New(Config{
		Store:    store.NewLocalStore(ns),
		Web:      http.FS(os.DirFS("../../web")),
		CacheDir: t.TempDir(),
	})
	if err != nil {
		t.Fatal(err)
	}
	ts := httptest.NewServer(srv.Handler())
	defer ts.Close()

	// The client clones the full history, so it has every commit to offer.
	dst := filepath.Join(t.TempDir(), "client")
	mustGit(t, env, ".", "clone", "-q", cloneURL(ts.URL, repoPath, "", ""), dst)

	// One more commit lands in the bare repo, out of band.
	writeTestFile(t, work, "f.txt", "tip\n")
	mustGit(t, env, work, "add", "-A")
	mustGit(t, env, work, "commit", "-qm", "tip")
	mustGit(t, env, work, "push", "-q", bare, "main")
	wantTip := strings.TrimSpace(mustGit(t, env, work, "rev-parse", "main"))

	out, err := runGit(t, env, dst, "fetch", "origin")
	if err != nil {
		t.Fatalf("incremental fetch failed: %v\n%s", err, out)
	}
	if got := strings.TrimSpace(mustGit(t, env, dst, "rev-parse", "origin/main")); got != wantTip {
		t.Errorf("origin/main = %s, want %s", got, wantTip)
	}
	// Acknowledging the common base is what keeps this warning away; without an
	// ACK git assumes the histories are unrelated and takes far more than the
	// delta.
	if strings.Contains(out, "no common commits") {
		t.Errorf("fetch reported no common commits, so the shared base went unacknowledged:\n%s", out)
	}

	// A deep client reaches the session only after a NAK round, so the haves it
	// cannot share are filtered out before that. See
	// TestFetchWithUnpushedLocalCommits for the shallow case, where they arrive
	// alongside "done" and reach the session directly.
	t.Run("unpushed local commits", func(t *testing.T) {
		writeTestFile(t, dst, "local.txt", "mine\n")
		mustGit(t, env, dst, "add", "-A")
		mustGit(t, env, dst, "commit", "-qm", "local only")

		writeTestFile(t, work, "f.txt", "newer\n")
		mustGit(t, env, work, "add", "-A")
		mustGit(t, env, work, "commit", "-qm", "newer")
		mustGit(t, env, work, "push", "-q", bare, "main")
		newTip := strings.TrimSpace(mustGit(t, env, work, "rev-parse", "main"))

		out, err := runGit(t, env, dst, "fetch", "origin")
		if err != nil {
			t.Fatalf("fetch with unpushed local commits failed: %v\n%s", err, out)
		}
		if got := strings.TrimSpace(mustGit(t, env, dst, "rev-parse", "origin/main")); got != newTip {
			t.Errorf("origin/main = %s, want %s", got, newTip)
		}
	})
}

func writeTestFile(t *testing.T, dir, name, content string) {
	t.Helper()
	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o644); err != nil {
		t.Fatal(err)
	}
}

// TestFetchWithUnpushedLocalCommits covers a client holding commits the server
// has never seen — the ordinary "some local work, now fetch" case.
//
// The history is deliberately shallow: with fewer than git's first batch of 16
// haves to offer, the client puts its haves and "done" in a single request, so
// they reach the upload-pack session instead of being answered by a NAK round.
// The session walks req.Haves to build its exclusion set and returns
// ErrObjectNotFound for anything it cannot resolve, which turns the fetch into
// a 500 unless the unknown haves are dropped first.
func TestFetchWithUnpushedLocalCommits(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git not available")
	}
	env := gitEnv(t)
	ns := t.TempDir()

	const owner = "u@d.com"
	const repoPath = owner + "/shallow.git"
	bare := filepath.Join(ns, filepath.FromSlash(repoPath))

	work := t.TempDir()
	mustGit(t, env, work, "init", "-q", "-b", "main")
	for i := range 3 {
		writeTestFile(t, work, "f.txt", fmt.Sprintf("v%d\n", i))
		mustGit(t, env, work, "add", "-A")
		mustGit(t, env, work, "commit", "-qm", fmt.Sprintf("commit %d", i))
	}
	if err := os.MkdirAll(filepath.Dir(bare), 0o755); err != nil {
		t.Fatal(err)
	}
	mustGit(t, env, work, "clone", "-q", "--bare", work, bare)
	if err := os.WriteFile(filepath.Join(bare, "Access"), []byte("read,list: all\n*: "+owner+"\n"), 0o644); err != nil {
		t.Fatal(err)
	}

	srv, err := New(Config{
		Store:    store.NewLocalStore(ns),
		Web:      http.FS(os.DirFS("../../web")),
		CacheDir: t.TempDir(),
	})
	if err != nil {
		t.Fatal(err)
	}
	ts := httptest.NewServer(srv.Handler())
	defer ts.Close()

	dst := filepath.Join(t.TempDir(), "client")
	mustGit(t, env, ".", "clone", "-q", cloneURL(ts.URL, repoPath, "", ""), dst)

	// Local work the server will never have.
	writeTestFile(t, dst, "local.txt", "mine\n")
	mustGit(t, env, dst, "add", "-A")
	mustGit(t, env, dst, "commit", "-qm", "local only")

	// Something new to fetch.
	writeTestFile(t, work, "f.txt", "newer\n")
	mustGit(t, env, work, "add", "-A")
	mustGit(t, env, work, "commit", "-qm", "newer")
	mustGit(t, env, work, "push", "-q", bare, "main")
	wantTip := strings.TrimSpace(mustGit(t, env, work, "rev-parse", "main"))

	out, err := runGit(t, env, dst, "fetch", "origin")
	if err != nil {
		t.Fatalf("fetch with unpushed local commits failed: %v\n%s", err, out)
	}
	if got := strings.TrimSpace(mustGit(t, env, dst, "rev-parse", "origin/main")); got != wantTip {
		t.Errorf("origin/main = %s, want %s", got, wantTip)
	}
}