package git

import (
	"context"
	"errors"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
)

func TestInspectTaggedSourceSupportsLightweightAndAnnotatedTags(t *testing.T) {
	fixture := newRemoteFixture(t)
	gitRun(t, fixture.work, "tag", "v1.2.3")
	gitRun(t, fixture.work, "checkout", "--detach", "HEAD")
	lightweight, err := InspectTaggedSource(context.Background(), fixture.work, "v1.2.3")
	if err != nil {
		t.Fatal(err)
	}
	if lightweight.Head != fixture.commit || lightweight.TagCommit != fixture.commit || lightweight.TagObject != fixture.commit || lightweight.TagObjectType != "commit" || lightweight.Status != "" {
		t.Fatalf("lightweight source = %#v", lightweight)
	}
	gitRun(t, fixture.work, "tag", "-d", "v1.2.3")
	gitRun(t, fixture.work, "tag", "-a", "v1.2.3", "-m", "Historical release")
	annotated, err := InspectTaggedSource(context.Background(), fixture.work, "v1.2.3")
	if err != nil {
		t.Fatal(err)
	}
	if annotated.Head != fixture.commit || annotated.TagCommit != fixture.commit || annotated.TagObject == fixture.commit || annotated.TagObjectType != "tag" || annotated.Status != "" {
		t.Fatalf("annotated source = %#v", annotated)
	}
}

func TestTagOperationsAcceptFullSlashContainingRefs(t *testing.T) {
	fixture := newRemoteFixture(t)
	tag := "integrations/check/v2.3.4"
	if err := CheckTagRef(context.Background(), fixture.work, tag); err != nil {
		t.Fatalf("CheckTagRef(%q): %v", tag, err)
	}
	object, err := CreateAnnotatedTag(context.Background(), fixture.work, tag, fixture.commit, []byte("release note\n"))
	if err != nil {
		t.Fatal(err)
	}
	source, err := InspectTaggedSource(context.Background(), fixture.work, tag)
	if err != nil {
		t.Fatal(err)
	}
	if source.TagCommit != fixture.commit || source.TagObject != object || source.TagObjectType != "tag" {
		t.Fatalf("source for %q = %#v", tag, source)
	}
}

func TestCreateAnnotatedTagReportsTemporaryCleanupFailure(t *testing.T) {
	fixture := newRemoteFixture(t)
	cleanupErr := errors.New("cleanup failed")
	var removed string
	remove := func(path string) error {
		removed = path
		if err := os.Remove(path); err != nil {
			return err
		}
		return cleanupErr
	}
	object, err := createAnnotatedTag(t.Context(), fixture.work, "v1.2.3", fixture.commit, []byte("note\n"), remove)
	if !errors.Is(err, cleanupErr) || object == "" || removed == "" || !strings.Contains(err.Error(), removed) {
		t.Fatalf("tag object = %q, cleanup path = %q, error = %v", object, removed, err)
	}
	if got := gitText(t, fixture.work, "rev-parse", "refs/tags/v1.2.3"); got != object {
		t.Fatalf("local tag = %q, want %q", got, object)
	}
	_, err = createAnnotatedTag(t.Context(), fixture.work, "v1.2.3", fixture.commit, []byte("note\n"), remove)
	var exit *exec.ExitError
	if !errors.As(err, &exit) || !errors.Is(err, cleanupErr) {
		t.Fatalf("tag creation and cleanup error = %v", err)
	}
}

func TestTagReferenceValidationUsesGitRules(t *testing.T) {
	fixture := newRemoteFixture(t)
	for _, tag := range []string{"", "v1..2.3", "v1.2.3.lock", "v1.2.3/", "v1.2.3\\bad"} {
		if err := CheckTagRef(context.Background(), fixture.work, tag); err == nil {
			t.Errorf("CheckTagRef(%q) succeeded", tag)
		}
	}
}

func TestCandidateObjectReadsStayLocalInPartialClones(t *testing.T) {
	fixture := newRemoteFixture(t)
	gitRun(t, fixture.work, "config", "uploadpack.allowFilter", "true")
	blob := strings.TrimSpace(gitText(t, fixture.work, "rev-parse", "HEAD:source.txt"))
	for _, filter := range []string{"blob:none", "tree:0"} {
		t.Run(filter, func(t *testing.T) {
			repository := filepath.Join(t.TempDir(), "partial")
			gitRun(t, fixture.work, "clone", "--filter="+filter, "--no-checkout", "file://"+filepath.ToSlash(fixture.work), repository)
			before := gitText(t, repository, "cat-file", "--batch-all-objects", "--batch-check=%(objectname)")
			if strings.Contains(before, blob) {
				t.Fatal("fixture contains the filtered blob")
			}
			gitRun(t, repository, "config", "remote.origin.url", "ssh://releasekit-test.invalid/source")
			attempts := filepath.Join(t.TempDir(), "attempts")
			transport := filepath.Join(t.TempDir(), "ssh")
			if err := os.WriteFile(transport, []byte("#!/bin/sh\nprintf 'remote accessed\\n' >> \"$RELEASEKIT_GIT_ATTEMPTS\"\nexit 1\n"), 0o755); err != nil {
				t.Fatal(err)
			}
			t.Setenv("GIT_SSH_COMMAND", transport)
			t.Setenv("RELEASEKIT_GIT_ATTEMPTS", attempts)
			t.Setenv("GIT_NO_LAZY_FETCH", "0")
			t.Setenv("GIT_ALLOW_PROTOCOL", "ssh")
			entries, treeErr := ReadTree(t.Context(), repository, fixture.commit)
			if filter == "tree:0" {
				if treeErr == nil {
					t.Fatal("tree inspection succeeded with unavailable trees")
				}
			} else {
				if treeErr != nil {
					t.Fatalf("metadata inspection required unavailable blobs: %v", treeErr)
				}
				if err := PopulateBlobSizes(t.Context(), repository, entries); err == nil {
					t.Fatal("size inspection succeeded with unavailable blobs")
				}
			}
			_, fileErr := ReadCommitFile(t.Context(), repository, fixture.commit, "source.txt")
			var fileExitError *exec.ExitError
			if !errors.As(fileErr, &fileExitError) {
				t.Fatalf("committed file error %v lost its Git process cause", fileErr)
			}
			_, err := ReadBlob(t.Context(), repository, blob)
			var exitError *exec.ExitError
			if !errors.As(err, &exitError) {
				t.Fatalf("blob error %v lost its Git process cause", err)
			}
			reader := NewBlobReader(t.Context(), repository)
			if _, err := reader.Read(t.Context(), blob); err == nil || !strings.Contains(err.Error(), "missing") {
				t.Fatalf("batch blob read error = %v, want missing-object inspection error", err)
			}
			if err := reader.Close(); err != nil {
				t.Fatalf("close missing-object batch reader: %v", err)
			}
			if data, err := os.ReadFile(attempts); !errors.Is(err, os.ErrNotExist) {
				t.Fatalf("object inspection invoked remote transport: %q, %v", data, err)
			}
			after := gitText(t, repository, "cat-file", "--batch-all-objects", "--batch-check=%(objectname)")
			if before != after {
				t.Fatal("object inspection populated the object database")
			}
		})
	}
}

func TestInspectTaggedSourceReportsDirtyCheckoutAndReadCommitFile(t *testing.T) {
	fixture := newRemoteFixture(t)
	gitRun(t, fixture.work, "tag", "v1.2.3")
	content, err := ReadCommitFile(context.Background(), fixture.work, fixture.commit, "source.txt")
	if err != nil || string(content) != "candidate" {
		t.Fatalf("committed content = %q, error = %v", content, err)
	}
	writeRepoFile(t, fixture.work, "untracked.txt", "dirty")
	source, err := InspectTaggedSource(context.Background(), fixture.work, "v1.2.3")
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(source.Status, "untracked.txt") {
		t.Fatalf("dirty status = %q", source.Status)
	}
}

func TestCommittedReadsIgnoreReplacementObjects(t *testing.T) {
	for _, kind := range []string{"commit", "tree", "blob"} {
		t.Run(kind, func(t *testing.T) {
			fixture := newRemoteFixture(t)
			original := map[string]string{
				"commit": fixture.commit,
				"tree":   gitText(t, fixture.work, "rev-parse", "HEAD^{tree}"),
				"blob":   gitText(t, fixture.work, "rev-parse", "HEAD:source.txt"),
			}
			writeRepoFile(t, fixture.work, "source.txt", "replacement")
			gitRun(t, fixture.work, "add", "source.txt")
			gitRun(t, fixture.work, "commit", "-m", "Replacement")
			replacement := map[string]string{
				"commit": gitText(t, fixture.work, "rev-parse", "HEAD"),
				"tree":   gitText(t, fixture.work, "rev-parse", "HEAD^{tree}"),
				"blob":   gitText(t, fixture.work, "rev-parse", "HEAD:source.txt"),
			}
			gitRun(t, fixture.work, "reset", "--hard", fixture.commit)
			gitRun(t, fixture.work, "replace", original[kind], replacement[kind])

			content, err := ReadCommitFile(t.Context(), fixture.work, fixture.commit, "source.txt")
			if err != nil || string(content) != "candidate" {
				t.Fatalf("committed content = %q, error = %v", content, err)
			}
			entries, err := ReadTree(t.Context(), fixture.work, fixture.commit)
			if err != nil {
				t.Fatal(err)
			}
			var object string
			for _, entry := range entries {
				if entry.Path == "source.txt" {
					object = entry.ObjectID
				}
			}
			if object != original["blob"] {
				t.Fatalf("tree blob = %q, want %q", object, original["blob"])
			}
			reader := NewBlobReader(t.Context(), fixture.work)
			content, err = reader.Read(t.Context(), object)
			if err != nil || string(content) != "candidate" {
				t.Fatalf("batch content = %q, error = %v", content, err)
			}
			if err := reader.Close(); err != nil {
				t.Fatal(err)
			}
		})
	}
}