types

type Action struct {
	// Type specifies what kind of action this is
	Type ActionType

	// Description is a human-readable description of what this action does
	Description string

	// Source is the source path (for link, copy operations)
	Source string

	// Target is the target path (for link, copy, write operations)
	Target string

	// Content is the content to write (for write, append operations)
	Content string

	// Mode is the file permissions (for write, mkdir operations)
	Mode uint32

	// Command is the command to run (for run operations)
	Command string

	// Args are the arguments for the command (for run operations)
	Args []string

	// Pack is the name of the pack that generated this action
	Pack string

	// PowerUpName is the name of the power-up that generated this action
	PowerUpName string

	// Priority determines the order of execution (higher = executed first)
	Priority int

	// Metadata contains any additional data for this action
	Metadata map[string]interface{}
}

type ActionType string

type DisplayFile struct {
	PowerUp      string     `json:"powerUp"`
	Path         string     `json:"path"`
	Status       string     `json:"status"` // File-level: "success", "error", "queue", "config", "ignored"
	Message      string     `json:"message"`
	IsOverride   bool       `json:"isOverride"`   // File power-up was overridden in .dodot.toml
	LastExecuted *time.Time `json:"lastExecuted"` // When operation was last executed
}

type DisplayPack struct {
	Name      string        `json:"name"`
	Status    string        `json:"status"` // Aggregated: "alert", "success", "queue"
	Files     []DisplayFile `json:"files"`
	HasConfig bool          `json:"hasConfig"` // Pack has .dodot.toml
	IsIgnored bool          `json:"isIgnored"` // Pack has .dodotignore
}

type DisplayResult struct {
	Command   string        `json:"command"` // "status", "deploy", "install"
	Packs     []DisplayPack `json:"packs"`
	DryRun    bool          `json:"dryRun"` // For deploy/install commands
	Timestamp time.Time     `json:"timestamp"`
}

type ExecutionContext struct {
	// Command is the command being executed (deploy, install, etc.)
	Command string

	// PackResults contains results organized by pack
	PackResults map[string]*PackExecutionResult

	// StartTime is when execution began
	StartTime time.Time

	// EndTime is when execution completed
	EndTime time.Time

	// DryRun indicates if this was a dry run
	DryRun bool

	// TotalOperations is the total count of operations across all packs
	TotalOperations int

	// CompletedOperations is the count of successfully completed operations
	CompletedOperations int

	// FailedOperations is the count of failed operations
	FailedOperations int

	// SkippedOperations is the count of skipped operations
	SkippedOperations int
}

type ExecutionResult struct {
	Packs      []string    `json:"packs"`      // Packs that were processed
	Operations []Operation `json:"operations"` // Operations planned (not yet executed)
	DryRun     bool        `json:"dryRun"`     // Whether this was a dry run
}

type ExecutionStatus string

type FileStatus struct {
	// Path is the file or directory path
	Path string

	// PowerUp is the power-up that manages this file
	PowerUp string

	// Status is the current status of the file
	Status OperationStatus

	// Message provides additional context about the status
	Message string

	// LastApplied is when the file was last successfully applied
	LastApplied time.Time

	// Metadata contains power-up specific status information
	// For example:
	// - Symlinks: target path, whether link is valid
	// - Profiles: which shell files contain entries
	// - PATH: whether directory is in PATH
	// - Homebrew: package version, installation status
	Metadata map[string]interface{}
}

type FillResult struct {
	PackName     string      `json:"packName"`
	FilesCreated []string    `json:"filesCreated"`
	Operations   []Operation `json:"operations"`
}

type IgnoreRule struct {
	Path string `toml:"path"`
}

type InitResult struct {
	PackName     string      `json:"packName"`
	Path         string      `json:"path"`
	FilesCreated []string    `json:"filesCreated"`
	Operations   []Operation `json:"operations"`
}

type ListPacksResult struct {
	Packs []PackInfo `json:"packs"`
}

type Matcher struct {
	// Name is an optional name for this matcher
	Name string

	// TriggerName specifies which trigger to use
	TriggerName string

	// PowerUpName specifies which power-up to invoke on match
	PowerUpName string

	// Priority determines the order of matcher evaluation (higher = first)
	Priority int

	// Options contains configuration for both trigger and power-up
	Options map[string]interface{}

	// TriggerOptions contains trigger-specific options
	TriggerOptions map[string]interface{}

	// PowerUpOptions contains power-up-specific options
	PowerUpOptions map[string]interface{}

	// Enabled indicates if this matcher is active
	Enabled bool
}

type MatcherConfig struct {
	// Name is an optional name for this matcher
	Name string `toml:"name"`

	// Trigger specifies which trigger to use
	Trigger string `toml:"trigger"`

	// PowerUp specifies which power-up to invoke
	PowerUp string `toml:"powerup"`

	// Priority for this matcher
	Priority int `toml:"priority"`

	// Pattern is a common trigger option (for convenience)
	Pattern string `toml:"pattern"`

	// Target is a common power-up option (for convenience)
	Target string `toml:"target"`

	// Options for trigger and power-up configuration
	Options map[string]interface{} `toml:"options"`

	// TriggerOptions for trigger-specific configuration
	TriggerOptions map[string]interface{} `toml:"trigger_options"`

	// PowerUpOptions for power-up-specific configuration
	PowerUpOptions map[string]interface{} `toml:"powerup_options"`

	// Enabled indicates if this matcher is active (default: true)
	Enabled *bool `toml:"enabled"`
}

type Operation struct {
	// Type is the type of operation
	Type OperationType

	// Source is the source path (for symlinks, copies)
	Source string

	// Target is the target path
	Target string

	// Content is the content to write (for write operations)
	Content string

	// Mode is the file permissions (optional)
	Mode *uint32

	// Description is a human-readable description
	Description string

	// Status is the current state of the operation
	Status OperationStatus

	// Command is the command to execute (for execute operations)
	Command string

	// Args are the arguments for the command (for execute operations)
	Args []string

	// WorkingDir is the working directory for execution (optional)
	WorkingDir string

	// EnvironmentVars are additional environment variables (optional)
	EnvironmentVars map[string]string

	// Pack is the name of the pack that originated this operation
	Pack string

	// PowerUp is the name of the PowerUp that generated this operation
	PowerUp string

	// TriggerInfo contains information about the original trigger match
	TriggerInfo *TriggerMatchInfo

	// Metadata preserves custom metadata from the Action
	Metadata map[string]interface{}

	// GroupID allows grouping related operations together
	GroupID string
}

type OperationResult struct {
	// Operation that was executed
	Operation *Operation

	// Status is the final status after execution
	Status OperationStatus

	// Error contains any error that occurred
	Error error

	// StartTime is when the operation began
	StartTime time.Time

	// EndTime is when the operation completed
	EndTime time.Time

	// Output contains any output from the operation (for execute operations)
	Output string

	// Metadata can contain additional execution information
	Metadata map[string]interface{}
}

type OperationStatus string

type OperationType string

type OverrideRule struct {
	Path    string                 `toml:"path"`
	Powerup string                 `toml:"powerup"`
	With    map[string]interface{} `toml:"with"`
}

type Pack struct {
	// Name is the pack name (usually the directory name)
	Name string

	// Path is the absolute path to the pack directory
	Path string

	// Config contains pack-specific configuration from .dodot.toml
	Config PackConfig

	// Metadata contains any additional pack information
	Metadata map[string]interface{}
}

type PackConfig struct {
	Ignore   []IgnoreRule   `toml:"ignore"`
	Override []OverrideRule `toml:"override"`
}

type PackExecutionResult struct {
	// Pack is the pack being executed
	Pack *Pack

	// Operations contains all operations and their results
	Operations []*OperationResult

	// Status is the aggregated status for this pack
	Status ExecutionStatus

	// StartTime is when this pack's execution began
	StartTime time.Time

	// EndTime is when this pack's execution completed
	EndTime time.Time

	// TotalOperations in this pack
	TotalOperations int

	// CompletedOperations in this pack
	CompletedOperations int

	// FailedOperations in this pack
	FailedOperations int

	// SkippedOperations in this pack
	SkippedOperations int
}

type PackInfo struct {
	Name string `json:"name"`
	Path string `json:"path"`
}

type PowerUp interface {
	// Name returns the unique name of this power-up
	Name() string

	// Description returns a human-readable description of what this power-up does
	Description() string

	// RunMode returns whether this power-up runs once or many times
	RunMode() RunMode

	// Process takes a group of trigger matches and generates actions
	// The matches are grouped by pack and options before being passed here
	Process(matches []TriggerMatch) ([]Action, error)

	// ValidateOptions checks if the provided options are valid for this power-up
	ValidateOptions(options map[string]interface{}) error

	// GetTemplateContent returns the template content for this power-up
	// Returns empty string if the power-up doesn't provide a template
	GetTemplateContent() string
}

type PowerUpFactory func(options map[string]interface{}) (PowerUp, error)

type RunMode string

type Trigger interface {
	// Name returns the unique name of this trigger
	Name() string

	// Description returns a human-readable description of what this trigger matches
	Description() string

	// Match checks if the given file or directory matches this trigger's pattern
	// It returns true if the file matches, along with any extracted metadata
	Match(path string, info fs.FileInfo) (bool, map[string]interface{})

	// Priority returns the priority of this trigger (higher = evaluated first)
	Priority() int

	// Type returns whether this is a specific or catchall trigger
	Type() TriggerType
}

type TriggerFactory func(options map[string]interface{}) (Trigger, error)

type TriggerMatch struct {
	// TriggerName is the name of the trigger that matched
	TriggerName string

	// Pack is the name of the pack containing the matched file
	Pack string

	// Path is the relative path within the pack
	Path string

	// AbsolutePath is the absolute path to the file
	AbsolutePath string

	// Metadata contains any additional data extracted by the trigger
	Metadata map[string]interface{}

	// PowerUpName is the name of the power-up that should process this match
	PowerUpName string

	// PowerUpOptions contains options to pass to the power-up
	PowerUpOptions map[string]interface{}

	// Priority determines the order of processing (higher = processed first)
	Priority int
}

type TriggerMatchInfo struct {
	// TriggerName is the name of the trigger that matched
	TriggerName string

	// OriginalPath is the relative path within the pack that was matched
	OriginalPath string

	// Priority from the original trigger match
	Priority int
}

type TriggerType int