sync

type Config interface {
	WorktreeAutoClean() bool
}

type Deps struct {
	// Engine is the full engine: sync reconciles the whole repository —
	// trunk, remote and stack metadata, PR info, worktrees, branch cleanup —
	// so the surface it touches spans nearly every engine role, and the
	// restack and cleanup pipelines it delegates to take engine.Engine too.
	Engine engine.Engine
	Out    output.Output
	Log    output.Logger
	// GitHub returns the client, or nil when GitHub is unavailable. It is a
	// function so the client is only built when sync actually needs it.
	GitHub func() github.Client
	// GHRunner runs the GraphQL queries that fetch PR info.
	GHRunner github.GitCommandRunner
	// PRSync refreshes PR footers and titles for flagged branches and pushes
	// orphaned metadata the user chose to keep.
	PRSync actions.PRSync
	// Restack is what the restack phase runs actions.RunRestack with. Its
	// Interactive and Quiet flags also decide whether sync may prompt to
	// enable rerere.
	Restack actions.RestackDeps
	// Cleanup is what the merged/closed branch cleanup phase runs with.
	Cleanup   actions.CleanBranchesDeps
	Snapshots actions.Snapshots
	// Here is where sync runs; a managed worktree never removes itself and
	// cannot delete branches checked out elsewhere.
	Here   actions.Here
	Config Config
}

type DryRunCleanItem struct {
	Branch string
	Reason string // e.g. "merged into main", "closed on GitHub"
}

type DryRunPlan struct {
	PullBranch        string              // trunk that would be pulled (empty if up to date)
	PullRevision      string              // short remote SHA the trunk would move to
	Clean             []DryRunCleanItem   // branches that would be deleted
	Restack           []DryRunRestackItem // branches that would be restacked
	RestackStacks     []string            // deduped stack roots covering the restack set (JSON only)
	SkippedStacks     []string            // dirty-worktree anchors whose stacks are skipped
	RestackRequested  bool                // whether --restack was requested
	TrunkStateUnknown bool                // trunk's remote relationship could not be resolved
}

type DryRunRestackItem struct {
	Branch string
	Parent string
}

type DryRunResult struct {
	WouldPull          string   `json:"would_pull,omitempty"`           // Trunk branch that would be pulled
	WouldClean         []string `json:"would_clean,omitempty"`          // Branches that would be deleted
	WouldRestack       []string `json:"would_restack,omitempty"`        // Branches that would be restacked
	WouldRestackStacks []string `json:"would_restack_stacks,omitempty"` // Deduped independent stack roots covering the current dry-run's would_restack set; recompute after sync before passing to `restack --stacks <roots>` because cleanup/reparenting can change roots
	SkippedStacks      []string `json:"skipped_stacks,omitempty"`       // Stacks skipped due to dirty worktrees
	TrunkStateUnknown  bool     `json:"trunk_state_unknown,omitempty"`  // Trunk's relationship to its remote could not be resolved (objects not fetched); an absent would_pull does NOT mean trunk is current
}

type Event struct {
	Phase       Phase         // Current phase
	Type        EventType     // Event type
	Branch      string        // Branch name (if applicable)
	PRNumber    *git.PRNumber // PR number (if applicable)
	Message     string        // Human-readable description
	OldRevision string        // For position changes
	NewRevision string        // For position changes
	Conflict    bool          // Is this a conflict?
	HeldBy      string        // Why a worktree held this branch back (empty if it was not held)
	Error       error         // If non-nil, this step had an error
}

type EventType string

type GitHubSyncResult struct {
	BranchNames []string
	RepoOwner   string
	RepoName    string
	PRInfos     map[string]*github.PullRequestInfo
	// contains filtered or unexported fields
}

type Handler interface {
	// Start is called at the beginning of sync with the total operation count
	Start(totalOps int)

	// EmitEvent is called for each progress update
	EmitEvent(event Event)

	// Complete is called when sync finishes with the summary
	Complete(summary Summary)

	// Cleanup ensures terminal is restored on error (may be no-op for non-TTY handlers)
	Cleanup()

	// IsInteractive returns true if this handler supports interactive prompts.
	// Non-interactive handlers return false and their prompt methods return defaults.
	IsInteractive() bool

	// PromptMetadataConflict displays a metadata conflict and asks user to accept remote.
	// Returns true to accept remote metadata, false to keep local.
	// In non-interactive mode, returns (false, nil) to preserve local changes.
	PromptMetadataConflict(diff *engine.MetadataDiff) (acceptRemote bool, err error)

	// PromptOrphanedMetadata asks what to do when remote metadata was deleted but local has changes.
	// Returns true to push local metadata to remote, false to accept deletion.
	// In non-interactive mode, returns (false, nil) to accept the remote deletion.
	PromptOrphanedMetadata(info engine.OrphanedMetadataInfo) (pushLocal bool, err error)

	// PromptBranchDeletions displays planned branch deletions and asks user to confirm each one.
	// unpushedBranches identifies branches with local commits not yet pushed to remote.
	// Returns a map of branch names that the user confirmed for deletion.
	// In non-interactive mode, returns all branches except unpushed ones (which are skipped by default).
	PromptBranchDeletions(branches map[string]string, unpushedBranches map[string]bool) (confirmed map[string]bool, err error)

	// PromptResolveConflicts asks user if they want to resolve restack conflicts now or skip them.
	// Returns true to start conflict resolution workflow, false to skip and continue.
	// In non-interactive mode, returns (false, nil) to skip conflicts.
	PromptResolveConflicts(conflictBranches []string) (resolve bool, err error)

	// RestackHandler methods are available for restack-specific output
	// This allows the same handler to be used for standalone restack operations
	actions.RestackHandler
}

type NullHandler struct {
	handler.NullBase
	actions.NullRestackHandler
}

type Options struct {
	All          bool
	Force        bool
	Restack      bool // Explicitly restack the full current stack (opt-in)
	NoRestack    bool // Skip all restacking entirely
	DryRun       bool
	RestackScope []string // When non-nil, only restack these branches (skip current-branch expansion)
}

type ParentsToGitHubResult struct {
	BranchesUpdated []string // Branches whose PR base was updated on GitHub
}

type Phase string

type PlanEngine interface {
	actions.ManagedWorktreeSource
	Trunk() engine.Branch
	AllBranches() engine.Branches
	ReadBranchRemoteStatuses(ctx context.Context, branches engine.Branches) engine.BranchRemoteStatuses
	ReadBranchStatuses(ctx context.Context, branches engine.Branches) engine.BranchStatuses
	GetDeletionStatuses(ctx context.Context, branchNames []string) (engine.DeletionStatuses, error)
	GetStackRootForBranch(branch engine.Branch) string
}

type PlanRequest struct {
	// Restack previews restacking of every out-of-date tracked branch, as
	// `sync --restack` would.
	Restack bool
}

type StackMetadataGCResult struct {
	DeletedStackIDs []string // Stack IDs whose refs were deleted
	Errors          []string // Any errors encountered (non-fatal)
}

type Summary struct {
	TrunkUpdated      bool     // Was trunk updated?
	TrunkRevision     string   // New trunk revision (short hash)
	BranchesSynced    int      // Number of branches synced from remote
	BranchesRestacked int      // Number of branches restacked
	BranchesDeleted   int      // Number of branches deleted
	BranchesSkipped   int      // Number of branches skipped (due to conflicts)
	ConflictBranches  []string // Names of branches that conflicted
	BranchesBlocked   int      // Number of branches left untouched because their stack conflicted
	UpToDate          bool     // Everything was already current
	WorktreesCleaned  int      // Number of orphaned worktrees cleaned up
	SkippedStacks     []string // Stacks skipped due to dirty worktrees
}

type WorktreeCleanupResult struct {
	RemovedWorktrees []string // Stack roots whose worktrees were removed
	Errors           []string // Any errors encountered (non-fatal)
}