merge

type BranchMergeInfo struct {
	BranchName    string
	PRNumber      int
	PRURL         string
	IsDraft       bool
	ChecksStatus  ChecksStatus
	MatchesRemote bool
}

type CIWaiter struct {
	// contains filtered or unexported fields
}

type CIWaiterOptions struct {
	Client       github.Client
	Output       output.Output
	Timeout      time.Duration // Default: 10 minutes
	PollInterval time.Duration // Default: 15 seconds
}

type ChecksStatus string

type CollectedBranches struct {
	BranchesToMerge []BranchMergeInfo
	UpstackBranches []string
	CurrentBranch   string
	Validation      *PlanValidation
}

type ConsolidateMergeExecutor struct {
	// contains filtered or unexported fields
}

type ConsolidationResult struct {
	BranchName string
	PRNumber   int
	PRURL      string
}

type CreatePlanOptions struct {
	Strategy     Strategy
	Force        bool
	Scope        string
	TargetBranch string // Optional branch to merge from (instead of current)
	Wait         bool   // Whether to wait for CI/merge (applies to consolidate strategy)
}

type Event struct {
	Phase     Phase
	Type      EventType
	StepIndex int
	Step      *PlanStep
	Message   string
	Error     error

	// Waiting-specific fields
	Elapsed time.Duration
	Timeout time.Duration
	Checks  []github.CheckDetail

	// Estimate fields
	EstimatedDuration time.Duration
}

type EventHandler interface {
	// Start is called when the merge plan is ready to execute.
	// The plan contains all steps that will be executed.
	Start(plan *Plan)

	// EmitEvent sends a progress event to the handler.
	// Called for each step transition (started, completed, failed, waiting).
	// May be called concurrently from multiple goroutines.
	EmitEvent(event Event)

	// Complete is called when the merge operation is finished.
	// Result contains success status and any consolidation result.
	Complete(result *Result)

	// Cleanup ensures terminal state is restored.
	// Should be called via defer after creating the handler.
	// No-op for non-TTY handlers.
	Cleanup()
}

type EventType string

type ExecuteOptions struct {
	Plan                    *Plan
	Strategy                Strategy
	Force                   bool
	Wait                    bool                       // Whether to wait for CI/merge (applies to consolidate)
	Handler                 EventHandler               // Optional progress handler
	UndoStackDepth          int                        // Maximum undo stack depth (from config)
	ConsolidationResultFunc func(*ConsolidationResult) // Callback for consolidation results
	MergeMethod             github.MergeMethod         // Optional: override merge method (empty = auto-detect/prompt)
}

type IndividualMergeStatus struct {
	CanMerge       bool            // True if all PRs can be merged individually
	MergeableState map[string]bool // Per-branch mergeable state (true = mergeable)
	BlockingReason string          // Reason why individual merge is blocked (if any)
}

type InteractiveHandler interface {
	EventHandler

	// IsInteractive returns true if this handler supports interactive prompts.
	// Non-interactive handlers (e.g., SimpleMergeEventHandler) return false,
	// and their prompt methods will return errors.
	// Check this before calling prompt methods to provide better error messages.
	IsInteractive() bool

	// PromptMergeType asks user what to merge (this/scope/stacks).
	// Called at the start of the wizard when no merge target is pre-selected.
	// canMergeThisBranch indicates if "This branch" is a valid option (false on trunk or empty worktree).
	// Returns ErrCanceled if user cancels.
	PromptMergeType(canMergeThisBranch bool, availableScopes []string, availableStacks []MultiStackInfo) (MergeType, error)

	// PromptScope asks user to select a scope from available options.
	// Called when user selects MergeTypeScope.
	// Returns ErrCanceled if user cancels.
	PromptScope(availableScopes []string) (string, error)

	// PromptStacks asks user to select stacks (multi-select with ordering).
	// Returns selected stack root names in priority order.
	// Called when user selects MergeTypeStacks.
	// Returns ErrCanceled if user cancels.
	PromptStacks(availableStacks []MultiStackInfo) ([]string, error)

	// PromptStrategy asks user to select merge strategy.
	// plan provides context (branch count, etc.) for display.
	// recommended is the suggested default based on stack size.
	// Returns ErrCanceled if user cancels.
	PromptStrategy(plan *Plan, recommended Strategy) (StrategyChoice, error)

	// PromptConfirm asks user to confirm an action.
	// Returns ErrCanceled if user cancels.
	PromptConfirm(message string, defaultYes bool) (bool, error)

	// ShowPlan displays the merge plan for review.
	// This is informational - no return value needed.
	// Called before prompting for strategy selection.
	ShowPlan(plan *Plan, validation *PlanValidation)

	// ShowMidStackWarning displays a warning when user is mid-stack in a scope.
	// Called when branches above the current branch share the same scope.
	ShowMidStackWarning(scope string, upstackBranchesInScope []string)

	// PromptPostMerge asks user what to do after merge completes.
	// Called after successful merge execution.
	// Returns ErrCanceled if user cancels (treated as "done").
	PromptPostMerge(hasUncommittedChanges bool, trunkName string) (PostMergeAction, error)

	// PromptSimpleMergeConfirm shows a simplified confirmation for single-branch merges.
	// This provides a cleaner UX than ShowPlan + PromptConfirm for simple cases.
	// Returns true to proceed, false to cancel.
	PromptSimpleMergeConfirm(branch BranchMergeInfo, baseBranch string) (bool, error)
}

type LocalCISearchResult struct {
	WorkingStacks []MultiStackInfo     // Stacks that pass CI together
	FailedStacks  []MultiStackExcluded // Stacks that failed CI
}

type LocalCIValidator struct {
	Command string
	Timeout time.Duration
	// contains filtered or unexported fields
}

type MergeType string

type MultiStackExcluded struct {
	Stack  MultiStackInfo
	Reason string // "conflict" | "ci_failure"
}

type MultiStackInfo struct {
	RootBranch  string   // Stack root branch name (direct child of trunk)
	AllBranches []string // All branches in the stack (root to tip, in order)
	PRCount     int      // Number of PRs in this stack
	Scope       string   // Stack scope if any
}

type MultiStackOptions struct {
	SelectedStacks []string // Stack roots selected by user (skips picker if provided)
	SkipLocalCI    bool     // Skip local CI validation
	Wait           bool     // Wait for CI and auto-merge
}

type MultiStackPRCreator struct {
	// contains filtered or unexported fields
}

type MultiStackResult struct {
	IncludedStacks []MultiStackInfo     // Stacks that were successfully included
	ExcludedStacks []MultiStackExcluded // Stacks that were excluded with reasons
	PRNumber       int                  // Created PR number
	PRURL          string               // Created PR URL
	BranchName     string               // Consolidation branch name
}

type MultiStackWorktreeExecutor struct {
	// contains filtered or unexported fields
}

type MultiStackWorktreeResult struct {
	MergedStacks   []MultiStackInfo     // Stacks that were successfully merged
	ConflictStacks []MultiStackExcluded // Stacks that conflicted
	WorktreePath   string               // Path to the worktree
	WorktreeEngine engine.Engine        // Engine for the worktree
	Cleanup        func()               // Function to clean up the worktree
}

type NullEventHandler struct{}

type Options struct {
	DryRun         bool
	Confirm        bool
	Strategy       Strategy
	Force          bool
	Wait           bool // Whether to wait for CI/merge (applies to consolidate)
	Scope          string
	TargetBranch   string
	Plan           *Plan // Optional pre-calculated plan
	UndoStackDepth int   // Maximum undo stack depth (from config)
	Handler        EventHandler
	MergeMethod    github.MergeMethod // Optional: override merge method (empty = auto-detect/prompt)
}

type PRCleaner struct {
	// contains filtered or unexported fields
}

type PRCleanupConfig struct {
	// Source identifies the cleanup source for footer text
	Source PRCleanupSource

	// ConsolidationPRNumber is the PR number of the consolidation PR
	ConsolidationPRNumber int

	// UserName is the username to include in the footer (optional)
	UserName string
}

type PRCleanupResult struct {
	ClosedPRs  []int // PR numbers that were closed
	FailedPRs  []int // PR numbers that failed to close
	SkippedPRs []int // PR numbers that were already closed
}

type PRCleanupSource string

type PRContentGenerator struct {
	// contains filtered or unexported fields
}

type Phase string

type Plan struct {
	Strategy        Strategy
	CurrentBranch   string
	BranchesToMerge []BranchMergeInfo // Branches that will be merged (bottom to top)
	UpstackBranches []string          // Branches above current that will be restacked
	Steps           []PlanStep        // Ordered steps to execute
	Warnings        []string          // Non-blocking warnings
	Infos           []string          // Informational messages
	CreatedAt       time.Time
}

type PlanStep struct {
	StepType     StepType
	BranchName   string
	PRNumber     int
	Description  string        // Human-readable description for display
	WaitTimeout  time.Duration // Timeout for waiting steps (e.g., CI checks)
	ExpectChecks bool          // Whether we expect CI checks to be present
}

type PlanValidation struct {
	Valid    bool
	Errors   []string // Blocking errors
	Warnings []string // Non-blocking warnings
	Infos    []string // Informational messages
}

type PostMergeAction string

type PostMergeActionRequired struct {
	Action PostMergeAction
}

type Result struct {
	Success             bool
	ConsolidationResult *ConsolidationResult
	Error               error
}

type StepType string

type Strategy string

type StrategyChoice struct {
	Strategy Strategy
	Wait     bool // Whether to wait for CI (consolidate strategy only)
}

type WaitResult struct {
	Passed      bool
	MaxDuration time.Duration // Maximum duration of any check (for estimating future runs)
}

type WizardOptions struct {
	DryRun       bool     // If true, show plan but don't execute
	Force        bool     // Skip validation checks
	Scope        string   // Pre-selected scope (empty = prompt or use current branch)
	TargetBranch string   // Pre-selected target branch (empty = current branch)
	Strategy     Strategy // Pre-selected strategy (empty = prompt)
	Wait         bool     // Pre-selected wait option (for consolidate)
}