sync

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
}

type Event struct {
	Phase               Phase             // Current phase
	Type                EventType         // Event type
	Branch              string            // Branch name (if applicable)
	PRNumber            *int              // 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?
	LockReason          engine.LockReason // Why the branch is locked (empty if not locked)
	Frozen              bool              // Is the branch frozen?
	IsCurrent           bool              // Is this the current branch?
	Parent              string            // Parent branch name (if applicable)
	RerereResolvedCount int               // Number of rebase continuations handled by git rerere
	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
	RestackHandler
}

type NullHandler struct {
	handler.NullBase
}

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 RestackHandler = handlers.RestackHandler

type RestackResult = handlers.RestackResult

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
	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)
}