package git

import (
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// ---------------------------------------------------------------------------
// Helpers for integration tests that use real git repos
// ---------------------------------------------------------------------------

// gitExec runs a git command in the given directory and returns trimmed stdout.
func gitExec(t *testing.T, dir string, args ...string) string {
	t.Helper()
	cmd := exec.Command("git", args...)
	cmd.Dir = dir
	cmd.Env = append(os.Environ(),
		"GIT_AUTHOR_NAME=Test",
		"GIT_AUTHOR_EMAIL=test@test.com",
		"GIT_COMMITTER_NAME=Test",
		"GIT_COMMITTER_EMAIL=test@test.com",
	)
	out, err := cmd.CombinedOutput()
	require.NoError(t, err, "git %s in %s:\n%s", strings.Join(args, " "), dir, string(out))
	return strings.TrimSpace(string(out))
}

// gitExecMayFail runs a git command allowing failure. Returns stdout and error.
func gitExecMayFail(t *testing.T, dir string, args ...string) (string, error) {
	t.Helper()
	cmd := exec.Command("git", args...)
	cmd.Dir = dir
	cmd.Env = append(os.Environ(),
		"GIT_AUTHOR_NAME=Test",
		"GIT_AUTHOR_EMAIL=test@test.com",
		"GIT_COMMITTER_NAME=Test",
		"GIT_COMMITTER_EMAIL=test@test.com",
	)
	out, err := cmd.CombinedOutput()
	return strings.TrimSpace(string(out)), err
}

// setupBareAndClone creates a bare repo, clones it, makes an initial commit on
// main, and pushes. Returns (bareDir, cloneDir).
func setupBareAndClone(t *testing.T) (string, string) {
	t.Helper()
	bareDir := filepath.Join(t.TempDir(), "bare.git")

	// Use -c safe.bareRepository=all so git init --bare works in temp dirs.
	// Use -b main to ensure a consistent default branch name across environments.
	cmd := exec.Command("git", "-c", "safe.bareRepository=all", "init", "--bare", "-b", "main", bareDir)
	out, err := cmd.CombinedOutput()
	require.NoError(t, err, "git init --bare: %s", string(out))

	cloneDir := filepath.Join(t.TempDir(), "clone")
	gitExec(t, ".", "clone", bareDir, cloneDir)

	// Initial commit so main exists.
	writeFile(t, cloneDir, "init.txt", "hello")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "initial commit")
	gitExec(t, cloneDir, "push", "origin", "main")

	return bareDir, cloneDir
}

// writeFile creates or overwrites a file in dir.
func writeFile(t *testing.T, dir, name, content string) {
	t.Helper()
	require.NoError(t, os.WriteFile(filepath.Join(dir, name), []byte(content), 0644))
}

// withGitDir temporarily sets the git client to operate in dir by changing
// the working directory. Returns a restore function.
func withGitDir(t *testing.T, dir string) func() {
	t.Helper()
	old, err := os.Getwd()
	require.NoError(t, err)
	require.NoError(t, os.Chdir(dir))
	return func() { _ = os.Chdir(old) }
}

// remoteBranchSHA returns the SHA of a branch on the bare remote.
func remoteBranchSHA(t *testing.T, bareDir, branch string) string {
	t.Helper()
	cmd := exec.Command("git", "-C", bareDir, "-c", "safe.bareRepository=all",
		"rev-parse", "refs/heads/"+branch)
	out, err := cmd.CombinedOutput()
	require.NoError(t, err, "rev-parse in bare repo %s:\n%s", bareDir, string(out))
	return strings.TrimSpace(string(out))
}

// ---------------------------------------------------------------------------
// Integration tests for FetchBranches + Push (force-with-lease)
// ---------------------------------------------------------------------------

// Test 1: Branch exists remotely with a current tracking ref.
// Push should succeed and update the remote.
func TestIntegration_Push_ExistingBranchCurrentTrackingRef(t *testing.T) {
	bareDir, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	d := &defaultOps{}

	// Create a branch, push it, then make a new commit.
	gitExec(t, cloneDir, "checkout", "-b", "b1")
	writeFile(t, cloneDir, "b1.txt", "v1")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 initial")
	gitExec(t, cloneDir, "push", "origin", "b1")

	// Make a local commit (simulating rebase).
	writeFile(t, cloneDir, "b1.txt", "v2")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 updated")

	localSHA := gitExec(t, cloneDir, "rev-parse", "b1")

	// FetchBranches should update tracking ref.
	err := d.FetchBranches("origin", []string{"b1"})
	require.NoError(t, err)

	// Push with force-with-lease should succeed.
	err = d.Push("origin", []string{"b1"}, true, false)
	require.NoError(t, err)

	// Verify remote was updated.
	remoteSHA := remoteBranchSHA(t, bareDir, "b1")
	assert.Equal(t, localSHA, remoteSHA)
}

// Test 2: Branch exists remotely but tracking ref was deleted locally.
// This is the regression test for https://github.com/github/gh-stack/issues/118.
func TestIntegration_Push_TrackingRefDeletedLocally(t *testing.T) {
	bareDir, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	d := &defaultOps{}

	// Create a branch and push it.
	gitExec(t, cloneDir, "checkout", "-b", "b1")
	writeFile(t, cloneDir, "b1.txt", "v1")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 initial")
	gitExec(t, cloneDir, "push", "origin", "b1")

	// Delete the local tracking ref to simulate the bug condition.
	gitExec(t, cloneDir, "branch", "-dr", "origin/b1")

	// Verify tracking ref is gone.
	_, err := gitExecMayFail(t, cloneDir, "rev-parse", "--verify", "--quiet", "refs/remotes/origin/b1")
	require.Error(t, err, "tracking ref should be deleted")

	// Make a local commit (simulating rebase).
	writeFile(t, cloneDir, "b1.txt", "v2")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 rebased")

	localSHA := gitExec(t, cloneDir, "rev-parse", "b1")

	// FetchBranches should recreate the tracking ref.
	err = d.FetchBranches("origin", []string{"b1"})
	require.NoError(t, err)

	// Verify tracking ref was recreated.
	_, err = gitExecMayFail(t, cloneDir, "rev-parse", "--verify", "--quiet", "refs/remotes/origin/b1")
	require.NoError(t, err, "tracking ref should be recreated by FetchBranches")

	// Push with force-with-lease should succeed.
	err = d.Push("origin", []string{"b1"}, true, false)
	require.NoError(t, err)

	// Verify remote was updated.
	remoteSHA := remoteBranchSHA(t, bareDir, "b1")
	assert.Equal(t, localSHA, remoteSHA)
}

// Test 3: Branch advanced on remote by another client.
// Push should be rejected (lease protects the other commit).
func TestIntegration_Push_RemoteAdvancedByOther(t *testing.T) {
	bareDir, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	d := &defaultOps{}

	// Create a branch and push it.
	gitExec(t, cloneDir, "checkout", "-b", "b1")
	writeFile(t, cloneDir, "b1.txt", "v1")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 initial")
	gitExec(t, cloneDir, "push", "origin", "b1")

	// Simulate another client advancing the branch on the remote.
	otherClone := filepath.Join(t.TempDir(), "other")
	gitExec(t, ".", "clone", bareDir, otherClone)
	gitExec(t, otherClone, "checkout", "b1")
	writeFile(t, otherClone, "b1.txt", "v-other")
	gitExec(t, otherClone, "add", ".")
	gitExec(t, otherClone, "commit", "-m", "other update")
	gitExec(t, otherClone, "push", "origin", "b1")

	// Record the other client's SHA on the remote.
	otherSHA := remoteBranchSHA(t, bareDir, "b1")

	// Local client makes a different commit (simulating rebase).
	writeFile(t, cloneDir, "b1.txt", "v-local")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 local update")

	// FetchBranches — this updates tracking ref to the other client's SHA.
	err := d.FetchBranches("origin", []string{"b1"})
	require.NoError(t, err)

	// But wait: after fetch, our tracking ref now matches the remote.
	// The push should succeed because the lease matches. To truly test
	// the "someone pushed after our fetch" scenario, we need to advance
	// the remote AFTER the fetch.
	//
	// Advance remote again after our fetch.
	writeFile(t, otherClone, "b1.txt", "v-other-2")
	gitExec(t, otherClone, "add", ".")
	gitExec(t, otherClone, "commit", "-m", "other update 2")
	gitExec(t, otherClone, "push", "origin", "b1", "--force")

	// Now remote is ahead of our tracking ref — push should fail.
	err = d.Push("origin", []string{"b1"}, true, false)
	require.Error(t, err, "push should be rejected when remote was advanced after fetch")

	// Confirm no overwrite: remote still has the other client's latest SHA.
	finalRemoteSHA := remoteBranchSHA(t, bareDir, "b1")
	assert.NotEqual(t, otherSHA, finalRemoteSHA, "remote should have advanced past original other SHA")
}

// Test 4: Brand-new branch, absent on remote.
// Push should create the branch via empty-expect lease.
func TestIntegration_Push_NewBranchAbsentOnRemote(t *testing.T) {
	bareDir, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	d := &defaultOps{}

	// Create a new branch locally, do NOT push it.
	gitExec(t, cloneDir, "checkout", "-b", "b1")
	writeFile(t, cloneDir, "b1.txt", "v1")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 new")

	localSHA := gitExec(t, cloneDir, "rev-parse", "b1")

	// FetchBranches — branch doesn't exist on remote, should tolerate the error.
	err := d.FetchBranches("origin", []string{"b1"})
	require.NoError(t, err)

	// No tracking ref should exist (branch is absent remotely).
	_, err = gitExecMayFail(t, cloneDir, "rev-parse", "--verify", "--quiet", "refs/remotes/origin/b1")
	require.Error(t, err, "tracking ref should not exist for branch absent on remote")

	// Push should create the branch on remote.
	err = d.Push("origin", []string{"b1"}, true, false)
	require.NoError(t, err)

	// Verify remote has the branch.
	remoteSHA := remoteBranchSHA(t, bareDir, "b1")
	assert.Equal(t, localSHA, remoteSHA)
}

// Test 5: Brand-new branch that another client created first (race).
// Push should be rejected because empty-expect means "must not exist."
func TestIntegration_Push_NewBranchRaceCondition(t *testing.T) {
	bareDir, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	d := &defaultOps{}

	// Create branch locally but don't push.
	gitExec(t, cloneDir, "checkout", "-b", "b1")
	writeFile(t, cloneDir, "b1.txt", "v1")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 new")

	// FetchBranches — branch doesn't exist on remote yet.
	err := d.FetchBranches("origin", []string{"b1"})
	require.NoError(t, err)

	// Another client creates the same branch on the remote.
	otherClone := filepath.Join(t.TempDir(), "other")
	gitExec(t, ".", "clone", bareDir, otherClone)
	gitExec(t, otherClone, "checkout", "-b", "b1")
	writeFile(t, otherClone, "b1.txt", "v-other")
	gitExec(t, otherClone, "add", ".")
	gitExec(t, otherClone, "commit", "-m", "other b1")
	gitExec(t, otherClone, "push", "origin", "b1")

	// Now our push should fail because the branch exists on remote
	// but we have an empty-expect lease.
	err = d.Push("origin", []string{"b1"}, true, false)
	require.Error(t, err, "push should be rejected when branch was created by another client")
}

// Test 6: Mixed stack — one branch with current tracking ref + one with
// deleted tracking ref. Both should push successfully after FetchBranches fix.
func TestIntegration_Push_MixedStack(t *testing.T) {
	bareDir, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	d := &defaultOps{}

	// Create and push b1.
	gitExec(t, cloneDir, "checkout", "-b", "b1")
	writeFile(t, cloneDir, "b1.txt", "v1")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 initial")
	gitExec(t, cloneDir, "push", "origin", "b1")

	// Create and push b2.
	gitExec(t, cloneDir, "checkout", "-b", "b2")
	writeFile(t, cloneDir, "b2.txt", "v1")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b2 initial")
	gitExec(t, cloneDir, "push", "origin", "b2")

	// Delete tracking ref for b2 only (simulating the bug for one branch).
	gitExec(t, cloneDir, "branch", "-dr", "origin/b2")

	// Simulate rebase: update both branches.
	gitExec(t, cloneDir, "checkout", "b1")
	writeFile(t, cloneDir, "b1.txt", "v2")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b1 rebased")

	gitExec(t, cloneDir, "checkout", "b2")
	writeFile(t, cloneDir, "b2.txt", "v2")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "b2 rebased")

	localB1 := gitExec(t, cloneDir, "rev-parse", "b1")
	localB2 := gitExec(t, cloneDir, "rev-parse", "b2")

	// FetchBranches should handle both: b1 has tracking ref, b2 does not.
	err := d.FetchBranches("origin", []string{"b1", "b2"})
	require.NoError(t, err)

	// Push both branches with force-with-lease.
	err = d.Push("origin", []string{"b1", "b2"}, true, false)
	require.NoError(t, err)

	// Verify both were updated on remote.
	assert.Equal(t, localB1, remoteBranchSHA(t, bareDir, "b1"))
	assert.Equal(t, localB2, remoteBranchSHA(t, bareDir, "b2"))
}

// A stack branch whose name begins with "+" must push its own ref, not a
// similarly named sibling. A leading "+" in a git refspec means "force update",
// so passing a bare "+feature" (or "+feature:...") lets git treat it as a
// refspec modifier for "feature". Fully-qualified refspecs keep the "+" part of
// the branch name. Force path (used by push/submit).
func TestIntegration_Push_PlusPrefixedBranch_Force(t *testing.T) {
	bareDir, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	d := &defaultOps{}

	// Create and push a normal "feature" branch (content A).
	gitExec(t, cloneDir, "checkout", "-b", "feature")
	writeFile(t, cloneDir, "feature.txt", "A")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "feature A")
	gitExec(t, cloneDir, "push", "origin", "feature")
	remoteFeatureBefore := remoteBranchSHA(t, bareDir, "feature")

	// Create a local "+feature" branch off main with different content (B).
	gitExec(t, cloneDir, "checkout", "main")
	gitExec(t, cloneDir, "checkout", "-b", "+feature")
	writeFile(t, cloneDir, "plus.txt", "B")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "plus B")
	localPlus := gitExec(t, cloneDir, "rev-parse", "refs/heads/+feature")

	// Advance local "feature" (content C) but do NOT push it. If the push
	// followed refspec syntax, "+feature" would push this ref instead.
	gitExec(t, cloneDir, "checkout", "feature")
	writeFile(t, cloneDir, "feature.txt", "C")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "feature C")
	localFeature := gitExec(t, cloneDir, "rev-parse", "refs/heads/feature")
	require.NotEqual(t, localPlus, localFeature, "test setup: +feature and feature must differ")

	// Push the "+feature" stack branch via the force path.
	gitExec(t, cloneDir, "checkout", "+feature")
	require.NoError(t, d.FetchBranches("origin", []string{"+feature"}))
	require.NoError(t, d.Push("origin", []string{"+feature"}, true, false))

	// Remote "+feature" must point at local "+feature" (B), and remote
	// "feature" must be untouched (still A).
	assert.Equal(t, localPlus, remoteBranchSHA(t, bareDir, "+feature"),
		"remote +feature should hold the +feature commit, not feature's")
	assert.Equal(t, remoteFeatureBefore, remoteBranchSHA(t, bareDir, "feature"),
		"remote feature must not be force-updated")
}

// Same as above for the non-force, atomic path (used by link and by sync when
// no rebase happened). A bare "+feature" operand would force-update remote
// "feature"; a fully-qualified refspec creates remote "+feature" instead.
func TestIntegration_Push_PlusPrefixedBranch_NonForce(t *testing.T) {
	bareDir, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	d := &defaultOps{}

	// Create and push a normal "feature" branch (content A).
	gitExec(t, cloneDir, "checkout", "-b", "feature")
	writeFile(t, cloneDir, "feature.txt", "A")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "feature A")
	gitExec(t, cloneDir, "push", "origin", "feature")
	remoteFeatureBefore := remoteBranchSHA(t, bareDir, "feature")

	// Create a local "+feature" branch off main with different content (B).
	gitExec(t, cloneDir, "checkout", "main")
	gitExec(t, cloneDir, "checkout", "-b", "+feature")
	writeFile(t, cloneDir, "plus.txt", "B")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "plus B")
	localPlus := gitExec(t, cloneDir, "rev-parse", "refs/heads/+feature")

	// Advance local "feature" (content C) but do NOT push it.
	gitExec(t, cloneDir, "checkout", "feature")
	writeFile(t, cloneDir, "feature.txt", "C")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "feature C")

	// Push "+feature" via the non-force, atomic path.
	gitExec(t, cloneDir, "checkout", "+feature")
	require.NoError(t, d.Push("origin", []string{"+feature"}, false, true))

	// Remote "+feature" must be created from local "+feature" (B), and remote
	// "feature" must be untouched (still A).
	assert.Equal(t, localPlus, remoteBranchSHA(t, bareDir, "+feature"),
		"remote +feature should be created from the +feature commit")
	assert.Equal(t, remoteFeatureBefore, remoteBranchSHA(t, bareDir, "feature"),
		"remote feature must not be force-updated")
}

func TestSplitCommitMessage(t *testing.T) {
	tests := []struct {
		name        string
		msg         string
		wantSubject string
		wantBody    string
	}{
		{
			name:        "single line",
			msg:         "Fix the bug",
			wantSubject: "Fix the bug",
			wantBody:    "",
		},
		{
			name:        "subject and body with blank separator",
			msg:         "Fix the bug\n\nMore details about the fix.",
			wantSubject: "Fix the bug",
			wantBody:    "More details about the fix.",
		},
		{
			name:        "multi-line without blank separator",
			msg:         "Fix the bug\nMore details\nEven more",
			wantSubject: "Fix the bug",
			wantBody:    "More details\nEven more",
		},
		{
			name:        "body with leading and trailing blank lines trimmed",
			msg:         "Fix the bug\n\n\nSome body text\n\n",
			wantSubject: "Fix the bug",
			wantBody:    "Some body text",
		},
		{
			name:        "whitespace-only body",
			msg:         "Fix the bug\n\n   \n\n",
			wantSubject: "Fix the bug",
			wantBody:    "",
		},
		{
			name:        "leading whitespace on message trimmed",
			msg:         "\n  Fix the bug\n\nBody here",
			wantSubject: "Fix the bug",
			wantBody:    "Body here",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			subject, body := splitCommitMessage(tt.msg)
			assert.Equal(t, tt.wantSubject, subject)
			assert.Equal(t, tt.wantBody, body)
		})
	}
}

// ---------------------------------------------------------------------------
// Integration tests for saved remote (gh-stack.remote)
// ---------------------------------------------------------------------------

func TestIntegration_ResolveRemote_UsesSavedRemote(t *testing.T) {
	_, cloneDir := setupBareAndClone(t)
	restoreDir := withGitDir(t, cloneDir)
	defer restoreDir()

	// Create a branch without upstream tracking.
	gitExec(t, cloneDir, "checkout", "-b", "feature")

	// Add a second remote so there are multiple.
	gitExec(t, cloneDir, "remote", "add", "upstream", cloneDir)

	// Without saved remote, multiple remotes should return ErrMultipleRemotes.
	_, err := ResolveRemote("feature")
	var multi *ErrMultipleRemotes
	require.ErrorAs(t, err, &multi)

	// Save a remote preference.
	gitExec(t, cloneDir, "config", "gh-stack.remote", "upstream")

	// Now ResolveRemote should return the saved remote.
	remote, err := ResolveRemote("feature")
	require.NoError(t, err)
	assert.Equal(t, "upstream", remote)
}

func TestIntegration_ResolveRemote_GitPushConfigTakesPrecedence(t *testing.T) {
	_, cloneDir := setupBareAndClone(t)
	restoreDir := withGitDir(t, cloneDir)
	defer restoreDir()

	// Add a second remote.
	gitExec(t, cloneDir, "remote", "add", "upstream", cloneDir)

	// Save gh-stack.remote to "upstream".
	gitExec(t, cloneDir, "config", "gh-stack.remote", "upstream")

	// Set standard git push config to "origin" — this should take precedence.
	gitExec(t, cloneDir, "config", "remote.pushDefault", "origin")

	remote, err := ResolveRemote("main")
	require.NoError(t, err)
	assert.Equal(t, "origin", remote)
}

func TestIntegration_SaveAndGetRemote(t *testing.T) {
	_, cloneDir := setupBareAndClone(t)
	restoreDir := withGitDir(t, cloneDir)
	defer restoreDir()

	// Initially no saved remote.
	_, err := GetSavedRemote()
	require.Error(t, err)

	// Save a remote.
	require.NoError(t, SaveRemote("upstream"))

	// Should be retrievable.
	saved, err := GetSavedRemote()
	require.NoError(t, err)
	assert.Equal(t, "upstream", saved)

	// Clear it.
	require.NoError(t, ClearRemote())

	// Should be gone.
	_, err = GetSavedRemote()
	require.Error(t, err)
}

// ---------------------------------------------------------------------------
// Integration tests for cherry-pick in-progress detection and abort
// ---------------------------------------------------------------------------

// A conflicting cherry-pick must be detected as in-progress, and CherryPickAbort
// must fully restore the working tree/index so branch checkouts succeed again.
// This underpins modify's --abort recovery for fold-down (cherry-pick) conflicts.
func TestIntegration_CherryPickInProgressAndAbort(t *testing.T) {
	_, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	// Ensure runSilent-based git commands have a committer identity.
	gitExec(t, cloneDir, "config", "user.name", "Test")
	gitExec(t, cloneDir, "config", "user.email", "test@test.com")

	// feature edits conflict.txt one way; main edits it another way.
	gitExec(t, cloneDir, "checkout", "-b", "feature")
	writeFile(t, cloneDir, "conflict.txt", "feature change\n")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "feature edit")
	featureSHA := gitExec(t, cloneDir, "rev-parse", "feature")

	gitExec(t, cloneDir, "checkout", "main")
	writeFile(t, cloneDir, "conflict.txt", "main change\n")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "main edit")

	// No cherry-pick in progress before we start.
	assert.False(t, IsCherryPickInProgress(), "no cherry-pick should be in progress initially")

	// Cherry-picking feature onto main conflicts.
	err := CherryPick([]string{featureSHA})
	require.Error(t, err, "cherry-pick should conflict")
	assert.True(t, IsCherryPickInProgress(), "cherry-pick should be in progress after a conflict")

	// While mid-conflict, a plain checkout must fail (unmerged index).
	_, coErr := gitExecMayFail(t, cloneDir, "checkout", "feature")
	require.Error(t, coErr, "checkout should fail while cherry-pick index is unmerged")

	// Aborting must fully restore: no longer in progress, clean tree, checkout works.
	require.NoError(t, CherryPickAbort())
	assert.False(t, IsCherryPickInProgress(), "cherry-pick should not be in progress after abort")

	status, err := gitExecMayFail(t, cloneDir, "status", "--porcelain")
	require.NoError(t, err)
	assert.Empty(t, status, "working tree should be clean after abort")

	_, coErr = gitExecMayFail(t, cloneDir, "checkout", "feature")
	require.NoError(t, coErr, "checkout should succeed after abort restores a clean index")
}

// CherryPickQuit clears the sequencer state but intentionally leaves the index
// as-is, so a plain checkout still fails. This documents why Unwind uses the
// full --abort rather than --quit.
func TestIntegration_CherryPickQuitLeavesIndexUnmerged(t *testing.T) {
	_, cloneDir := setupBareAndClone(t)
	restore := withGitDir(t, cloneDir)
	defer restore()

	gitExec(t, cloneDir, "config", "user.name", "Test")
	gitExec(t, cloneDir, "config", "user.email", "test@test.com")

	gitExec(t, cloneDir, "checkout", "-b", "feature")
	writeFile(t, cloneDir, "conflict.txt", "feature change\n")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "feature edit")
	featureSHA := gitExec(t, cloneDir, "rev-parse", "feature")

	gitExec(t, cloneDir, "checkout", "main")
	writeFile(t, cloneDir, "conflict.txt", "main change\n")
	gitExec(t, cloneDir, "add", ".")
	gitExec(t, cloneDir, "commit", "-m", "main edit")

	require.Error(t, CherryPick([]string{featureSHA}))
	require.True(t, IsCherryPickInProgress())

	// --quit clears sequencer state (no longer "in progress") ...
	CherryPickQuit()
	assert.False(t, IsCherryPickInProgress(), "quit should clear cherry-pick sequencer state")

	// ... but leaves the unmerged index behind, so checkout still fails.
	_, coErr := gitExecMayFail(t, cloneDir, "checkout", "feature")
	require.Error(t, coErr, "checkout should still fail after --quit because the index is unmerged")
}