tui

type Applier interface {
	// ApplyCmd returns a command that applies the most recent saved plan file
	// with the terminal handed back to terraform, so its own output and
	// approval prompt reach the user unmediated (ADR-0052).
	ApplyCmd() tea.Cmd
}

type AttributeDiffLine struct {
	Marker string // "+", "-", "~"
	Key    string
	Before string // empty for create
	After  string // empty for delete
}

type CheckWarning struct {
	// Address is the display address of the check block, e.g.
	// "check.grafana_storage_directives".
	Address string
	// Message is the error_message the check author wrote.
	Message string
}

type Editor interface {
	Update(msg tea.Msg) (Editor, tea.Cmd)
	View() string
}

type EditorWithCursor interface {
	Editor
	CursorLine() int
}

type EditorWithValue interface {
	Editor
	CurrentValue() cty.Value
}

type Model struct {
	State *wrapper.State
	// Modules holds all module states for multi-module wrappers. When
	// len(Modules) > 1, the left pane shows section headers to group
	// variables by module. When empty or len==1, behaves as before.
	Modules []ModuleEntry

	// Module display info shown in the status bar.
	ModuleName   string
	LiteralRef   string
	ResolvedSHA  string
	SourceURL    string
	ManifestPath string

	// WrapperDir is the directory containing main.tf and terraform.tfstate.
	// Used for reloading state after apply.
	WrapperDir string

	// Planner runs `terraform plan` asynchronously when the user presses P.
	// May be nil (e.g. in tests or read-only contexts); the P key just
	// produces a friendly status message in that case.
	Planner Planner

	// Applier runs `terraform apply` when the user presses A from the plan
	// view. May be nil; the A key is hidden if unset.
	Applier Applier

	// Validator runs `terraform validate` after edits (debounced). May be
	// nil; validation is skipped if unset.
	Validator Validator

	// RefSwitcher handles the backend logic of switching module refs.
	// May be nil (e.g., local source wrappers where ref switching is N/A).
	RefSwitcher RefSwitcher

	// RefUnresolved, when non-nil, marks the primary module as opened with a
	// ref that no longer resolves on the remote (e.g. the branch was deleted).
	// The TUI auto-opens the ref-switch modal on startup and shows a banner
	// explaining why the variable schema is unavailable.
	RefUnresolved *RefUnresolvedInfo
	// contains filtered or unexported fields
}

type ModuleEntry struct {
	State *wrapper.State
	Name  string // display name (typically the module block name)

	// Ref identity for THIS specific module. Populated for git-sourced
	// modules so each module can be ref-switched independently.
	SourceURL   string
	Ref         string
	ResolvedSHA string
	// Switcher performs the ref switch for this module. Nil for local
	// sources (no remote to switch); the R key is a no-op for those.
	Switcher RefSwitcher
}

type Planner interface {
	// EnsureInit runs `terraform init` once if needed. Subsequent calls are
	// fast no-ops.
	EnsureInit(ctx context.Context) error
	// Plan runs `terraform plan -out=<tmp>; terraform show -json <tmp>` and
	// returns the parsed JSON plan.
	Plan(ctx context.Context) (*tfjson.Plan, error)
}

type RefSwitchResult struct {
	State       *wrapper.State
	ResolvedSHA string
	LiteralRef  string
	// OrphanedVars lists variable names that had user-set values in the
	// previous state but no longer exist in the module at the new ref.
	OrphanedVars []string
	// NewVars lists variables added in the new ref that were not present
	// in the previous state.
	NewVars []tfvars.Variable
	// InitIncomplete is true when the post-switch `terraform init -upgrade`
	// did not finish cleanly. The switch still succeeds: the module is
	// fetched (module installation precedes config validation) and the new
	// schema is shown. The most common cause — the new ref added a required
	// variable that isn't filled yet — is detected and phrased by the TUI
	// from its own state, so this flag only needs to convey the bare signal.
	// The planner re-runs init -upgrade on the next plan, and
	// `terraform validate` surfaces the specific diagnostics in the meantime.
	InitIncomplete bool
}

type RefSwitcher interface {
	// SwitchRef re-clones the module at the new ref, re-parses variables,
	// runs terraform init -upgrade, and returns the updated state. The
	// caller is responsible for merging user overrides from the old state.
	SwitchRef(ctx context.Context, newRef string) (*RefSwitchResult, error)

	// ListRefs returns the human-friendly ref names (branches and tags) the
	// module's remote currently has, for presentation in the ref-switch
	// modal. It is the source of truth for the "available refs" hint so the
	// list is never stale — including after an in-session switch fails or a
	// ref is deleted mid-session. Returns an error when the remote can't be
	// reached; callers treat that as non-fatal (the input stays free-text).
	ListRefs(ctx context.Context) ([]string, error)
}

type RefUnresolvedInfo struct {
	Ref       string
	Reason    string
	Available []string
	Offline   bool
}

type TfexecPlanner struct {
	Tf         *tfexec.Terraform
	WrapperDir string
	// contains filtered or unexported fields
}

type Validator interface {
	// Validate runs `terraform validate -json` and returns diagnostics.
	Validate(ctx context.Context) (*tfjson.ValidateOutput, error)
}