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 ExecutionResult struct {
	Packs      []string    `json:"packs"`
	Operations []Operation `json:"operations"`
	DryRun     bool        `json:"dryRun"`
}

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

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 PackInfo struct {
	Name string `json:"name"`
	Path string `json:"path"`
}

type PackStatus struct {
	Name         string          `json:"name"`
	PowerUpState []PowerUpStatus `json:"powerUpState"`
}

type PackStatusResult struct {
	Packs []PackStatus `json:"packs"`
}

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
}

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

type PowerUpStatus struct {
	Name        string `json:"name"`
	State       string `json:"state"` // e.g., "Installed", "Not Installed", "Changed"
	Description string `json:"description"`
}

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