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 ActionResult struct {
	// Action contains the action that was executed
	Action Action `json:"action"`

	// Status is the execution status
	Status OperationStatus `json:"status"`

	// Error contains any error that occurred during execution
	Error error `json:"error,omitempty"`

	// StartTime is when execution began
	StartTime time.Time `json:"startTime"`

	// EndTime is when execution completed
	EndTime time.Time `json:"endTime"`

	// Message provides additional context about the execution
	Message string `json:"message,omitempty"`

	// SynthfsOperationIDs tracks the synthfs operations that were executed for this action
	// This is useful for debugging and correlation with synthfs results
	SynthfsOperationIDs []string `json:"synthfsOperationIds,omitempty"`
}

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

	// TotalActions is the total count of actions across all packs
	TotalActions int

	// CompletedActions is the count of successfully completed actions
	CompletedActions int

	// FailedActions is the count of failed actions
	FailedActions int

	// SkippedActions is the count of skipped actions
	SkippedActions int
}

type ExecutionStatus string

type FS interface {
	// File operations
	Stat(name string) (fs.FileInfo, error)
	ReadFile(name string) ([]byte, error)
	WriteFile(name string, data []byte, perm fs.FileMode) error

	// Directory operations
	MkdirAll(path string, perm fs.FileMode) error
	ReadDir(name string) ([]fs.DirEntry, error)

	// Symlink operations
	Symlink(oldname, newname string) error
	Readlink(name string) (string, error)

	// Other operations
	Remove(name string) error
	RemoveAll(path string) error

	// Optional operations - implementations should check for support
	// For testing, Lstat can fall back to Stat
	Lstat(name string) (fs.FileInfo, error)
}

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"`
}

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

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

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 OperationStatus 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

	// PowerUpResults contains all PowerUp results and their status
	PowerUpResults []*PowerUpResult

	// 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

	// TotalPowerUps in this pack
	TotalPowerUps int

	// CompletedPowerUps in this pack
	CompletedPowerUps int

	// FailedPowerUps in this pack
	FailedPowerUps int

	// SkippedPowerUps in this pack
	SkippedPowerUps int
}

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

type Pather interface {
	// DotfilesRoot returns the root directory for dotfiles
	DotfilesRoot() string

	// DataDir returns the XDG data directory for dodot
	DataDir() string

	// ConfigDir returns the XDG config directory for dodot
	ConfigDir() string

	// CacheDir returns the XDG cache directory for dodot
	CacheDir() string

	// StateDir returns the XDG state directory for dodot
	StateDir() string
}

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 PowerUpResult struct {
	// PowerUpName is the name of the PowerUp (symlink, homebrew, etc.)
	PowerUpName string

	// Files are the files processed by this PowerUp
	Files []string

	// Status is the final status after execution
	Status OperationStatus

	// Error contains any error that occurred
	Error error

	// StartTime is when the PowerUp execution began
	StartTime time.Time

	// EndTime is when the PowerUp execution completed
	EndTime time.Time

	// Message provides additional context
	Message string

	// Pack is the pack this PowerUp belongs to
	Pack string
}

type RunMode string

type SentinelInfo struct {
	// Path is the full path to the sentinel file
	Path string
	// Name is just the filename of the sentinel
	Name string
	// Dir is the directory containing the sentinel
	Dir string
}

type Status struct {
	// State is the current status state
	State StatusState

	// Message is a human-readable status message
	Message string

	// Timestamp is when the action was last executed (optional)
	Timestamp *time.Time
}

type StatusState 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 TriggerType int