interfaces

type Configuration interface {
	Load() error
	LoadWithDefaults(defaults map[string]any) error
	Validate() error
	GetConfigSummary() string

	// Core configuration methods
	GetString(key string) string
	GetInt(key string) int
	GetBool(key string) bool
	GetDuration(key string) time.Duration
	GetFloat(key string) float64
	Get(key string) any
	Set(key string, value any)
	Has(key string) bool
	All() map[string]any

	// Pipeline-specific configuration methods
	Pipeline() PipelineConfig
	Registry() RegistryConfig
	Security() SecurityConfig
	Logging() LoggingConfig
	Environment() string
}

type ConfigurationError struct {
	Key   string
	Value any
	Cause error
}

type Container interface {
	// Core container methods
	Register(name string, factory func() (any, error))
	Get(name string) (any, error)
	Start(ctx context.Context) error
	Stop(ctx context.Context) error
	Validate() error

	// Pipeline-specific providers
	RegistryProvider
	SecurityProvider
	LoggingProvider
}

type ContainerError struct {
	Component string
	Operation string
	Cause     error
}

type GitConfig struct {
	Repo      string `json:"repo"       yaml:"repo"`
	Ref       string `json:"ref"        yaml:"ref"`
	Protocol  string `json:"protocol"   yaml:"protocol"`
	UserEmail string `json:"userEmail" yaml:"userEmail"`
	UserName  string `json:"userName"  yaml:"userName"`
	SSHKey    string `json:"sshKey"    yaml:"sshKey"`
}

type HookFunc func(ctx context.Context) error

type HookManager interface {
	RegisterHook(stepName string, hookType HookType, hook HookFunc) error
	GetHooks(stepName string, hookType HookType) []HookFunc
	ExecuteHooks(ctx context.Context, stepName string, hookType HookType) error
	RemoveHook(stepName string, hookType HookType, hook HookFunc) error
}

type HookType string

type Linter interface {
	Lint(ctx context.Context, src *dagger.Directory) error
	GetReport(ctx context.Context) (string, error)
}

type Logger interface {
	Debug(msg string, fields ...any)
	Info(msg string, fields ...any)
	Warn(msg string, fields ...any)
	Error(msg string, fields ...any)
	Fatal(msg string, fields ...any)
	WithField(key string, value any) Logger
	WithFields(fields map[string]any) Logger
}

type LoggingConfig struct {
	Level            string        `json:"level"             yaml:"level"`
	Format           string        `json:"format"            yaml:"format"`
	SamplingEnable   bool          `json:"samplingEnable"   yaml:"samplingEnable"`
	SamplingRate     float64       `json:"samplingRate"     yaml:"samplingRate"`
	SamplingInterval time.Duration `json:"samplingInterval" yaml:"samplingInterval"`
}

type LoggingProvider interface {
	GetLogger() (Logger, error)
}

type PipelineConfig struct {
	Name        string  `json:"name"         yaml:"name"`
	Environment string  `json:"environment"  yaml:"environment"`
	Coverage    float64 `json:"coverage"     yaml:"coverage"`
	SkipPush    bool    `json:"skipPush"    yaml:"skipPush"`
	OnlyBuild   bool    `json:"onlyBuild"   yaml:"onlyBuild"`
	OnlyTest    bool    `json:"onlyTest"    yaml:"onlyTest"`
	Verbose     bool    `json:"verbose"      yaml:"verbose"`
	GoVersion   string  `json:"goVersion"   yaml:"goVersion"`
	JavaVersion string  `json:"javaVersion" yaml:"javaVersion"`
}

type PipelineError struct {
	Pipeline string
	Step     string
	Message  string
	Cause    error
}

type PipelineExecutor interface {
	ExecutePipeline(ctx context.Context, pipelineName string, steps []string) error
	ExecuteStep(ctx context.Context, pipelineName string, stepName string) error
	GetPipelineStatus(pipelineName string) (PipelineStatus, error)
	GetStepStatus(pipelineName string, stepName string) (StepResult, error)
	CancelPipeline(pipelineName string) error
	GetPipelineLogs(pipelineName string) ([]string, error)
}

type PipelineStatus struct {
	PipelineName string                `json:"pipelineName"`
	Status       string                `json:"status"` // running, completed, failed, cancelled
	StartTime    time.Time             `json:"startTime"`
	EndTime      *time.Time            `json:"endTime,omitempty"`
	Duration     time.Duration         `json:"duration"`
	Steps        map[string]StepResult `json:"steps"`
	Metadata     map[string]any        `json:"metadata,omitempty"`
}

type RegistryConfig struct {
	BaseURL string `json:"baseUrl" yaml:"baseUrl"`
	User    string `json:"user"     yaml:"user"`
	Pass    string `json:"pass"     yaml:"pass"`
	Image   string `json:"image"    yaml:"image"`
	Tag     string `json:"tag"      yaml:"tag"`
}

type RegistryProvider interface {
	GetRegistryConfig() (RegistryConfig, error)
	GetRegistryAuth() (string, string, error)
}

type ReleaseConfig struct {
	Enabled        bool     `json:"enabled"         yaml:"enabled"`
	UseGoreleaser  bool     `json:"useGoreleaser"  yaml:"useGoreleaser"`
	BuildTargets   []string `json:"buildTargets"   yaml:"buildTargets"`
	ArchiveFormats []string `json:"archiveFormats" yaml:"archiveFormats"`
	Checksum       bool     `json:"checksum"        yaml:"checksum"`
	Sign           bool     `json:"sign"            yaml:"sign"`
}

type SecurityConfig struct {
	EnableVulnCheck bool     `json:"enableVulnCheck" yaml:"enableVulnCheck"`
	EnableLinting   bool     `json:"enableLinting"    yaml:"enableLinting"`
	LintTimeout     string   `json:"lintTimeout"      yaml:"lintTimeout"`
	ExcludePatterns []string `json:"excludePatterns"  yaml:"excludePatterns"`
}

type SecurityProvider interface {
	GetVulnChecker() (VulnChecker, error)
	GetLinter() (Linter, error)
}

type StepArtifact struct {
	Name        string `json:"name"`
	Path        string `json:"path"`
	Type        string `json:"type"`
	Size        int64  `json:"size"`
	Checksum    string `json:"checksum,omitempty"`
	Description string `json:"description,omitempty"`
}

type StepConfig struct {
	Name        string            `json:"name"        yaml:"name"`
	Description string            `json:"description" yaml:"description"`
	Required    bool              `json:"required"    yaml:"required"`
	Parallel    bool              `json:"parallel"    yaml:"parallel"`
	Timeout     time.Duration     `json:"timeout"     yaml:"timeout"`
	Retries     int               `json:"retries"     yaml:"retries"`
	DependsOn   []string          `json:"dependsOn"  yaml:"dependsOn"`
	Conditions  map[string]string `json:"conditions"  yaml:"conditions"`
	Metadata    map[string]any    `json:"metadata"    yaml:"metadata"`
}

type StepExecutor interface {
	Execute(ctx context.Context, stepName string, config StepConfig) error
	GetStepResult(stepName string) (StepResult, error)
	GetStepLogs(stepName string) ([]string, error)
}

type StepHandler interface {
	CanHandle(stepName string) bool
	Execute(ctx context.Context, stepName string, config StepConfig) error
	GetStepInfo(stepName string) StepConfig
	Validate(stepName string, config StepConfig) error
}

type StepRegistry interface {
	RegisterStep(stepName string, handler StepHandler) error
	GetStepHandler(stepName string) (StepHandler, error)
	ListSteps() []string
	GetStepConfig(stepName string) (StepConfig, error)
	ValidateStep(stepName string) error
	ExecuteStep(ctx context.Context, stepName string) error
	GetExecutionOrder() ([]string, error)
}

type StepResult struct {
	StepName  string         `json:"stepName"`
	Success   bool           `json:"success"`
	Duration  time.Duration  `json:"duration"`
	Error     error          `json:"error,omitempty"`
	Output    string         `json:"output,omitempty"`
	Metadata  map[string]any `json:"metadata,omitempty"`
	Artifacts []StepArtifact `json:"artifacts,omitempty"`
}

type VulnChecker interface {
	Check(ctx context.Context, src *dagger.Directory) error
	GetReport(ctx context.Context) (string, error)
}