labels

type BatchResult struct {
	// TotalOperations is the number of operations attempted
	TotalOperations int

	// SuccessfulOperations is the number of operations that succeeded
	SuccessfulOperations int

	// FailedOperations is the number of operations that failed
	FailedOperations int

	// Errors contains any errors that occurred during the batch operation
	Errors []error

	// Duration is how long the batch operation took
	Duration time.Duration
}

type DynamicLabelExtraction struct {
	// FilePath is the file path in the PR to read
	FilePath string

	// Key is the simple YAML key to extract (mutually exclusive with JSONPath)
	Key string

	// JSONPath is the JSONPath expression to extract complex values
	JSONPath string

	// LabelName is the name of the label to create (e.g., "cd/version")
	LabelName string

	// Required indicates whether this extraction must succeed
	Required bool

	// DefaultValue is used if extraction fails and not required
	DefaultValue string
}

type FailureSeverity string

type GitHubClient interface {
	AddLabel(ctx context.Context, repo github.Repository, number int, label string) error
	RemoveLabel(ctx context.Context, repo github.Repository, number int, label string) error
	GetPR(ctx context.Context, repo github.Repository, number int) (*github.PullRequest, error)
}

type LabelConfig struct {
	// LabelColors maps states to their GitHub label colors (hex without #)
	LabelColors map[State]string

	// DryRun if true, operations will be logged but not executed
	DryRun bool

	// MaxRetries is the number of times to retry failed GitHub API calls
	MaxRetries int

	// RetryDelay is the delay between retries
	RetryDelay time.Duration

	// DynamicLabelPrefix is the prefix for dynamic labels (default: "cd/")
	DynamicLabelPrefix string
}

type LabelManager interface {
	// ApplyState applies a state to a PR by updating its labels atomically.
	// It removes any existing cd/state: labels and adds the new one.
	// Returns an error if the state transition is invalid or GitHub API fails.
	ApplyState(ctx context.Context, pr github.PullRequest, state State) error

	// GetCurrentState determines the current state of a PR from its labels.
	// Returns StateUnknown if no cd/state: label is found.
	GetCurrentState(pr github.PullRequest) State

	// SyncToGitHub ensures the PR's GitHub labels match the desired state.
	// This is used for reconciliation and recovery scenarios.
	SyncToGitHub(ctx context.Context, pr github.PullRequest, state State) (*SyncResult, error)

	// TransitionState performs a validated state transition.
	// It checks if the transition is valid before applying the new state.
	TransitionState(ctx context.Context, pr github.PullRequest, toState State) error

	// RemoveAllStateLabels removes all cd/state: labels from a PR.
	// Used for cleanup or manual intervention scenarios.
	RemoveAllStateLabels(ctx context.Context, pr github.PullRequest) error

	// AddDynamicLabel adds a dynamic label (e.g., cd/version:1.2.3) to a PR.
	// These labels provide metadata and don't affect state transitions.
	AddDynamicLabel(ctx context.Context, pr github.PullRequest, key, value string) error

	// RemoveDynamicLabels removes all labels with a specific prefix.
	// Used to clean up old dynamic labels before applying new ones.
	RemoveDynamicLabels(ctx context.Context, pr github.PullRequest, prefix string) error
}

type LabelOperation struct {
	// Type is the operation type (add, remove)
	Type LabelOperationType

	// Label is the label name to operate on
	Label string

	// PR is the pull request number
	PRNumber int
}

type LabelOperationType string

type Logger interface {
	Debug(msg string, fields ...zap.Field)
	Info(msg string, fields ...zap.Field)
	Warn(msg string, fields ...zap.Field)
	Error(msg string, fields ...zap.Field)
}

type State = pr.State

type SyncResult struct {
	// InitialState is the state before synchronization
	InitialState State

	// FinalState is the state after synchronization
	FinalState State

	// LabelsAdded contains labels that were added to the PR
	LabelsAdded []string

	// LabelsRemoved contains labels that were removed from the PR
	LabelsRemoved []string

	// Errors contains any non-fatal errors that occurred during sync
	Errors []error

	// SyncTime is when the sync operation completed
	SyncTime time.Time
}

type Transition = pr.Transition

type TransitionError = pr.TransitionError

type TransitionRequest struct {
	// PR is the pull request to transition
	PR github.PullRequest

	// ToState is the target state
	ToState State

	// Reason is an optional human-readable reason for the transition
	Reason string

	// Metadata contains optional key-value pairs for context
	Metadata map[string]string

	// Force bypasses transition validation (use with caution)
	Force bool
}

type TransitionResult struct {
	// Success indicates whether the transition succeeded
	Success bool

	// PreviousState is the state before transition
	PreviousState State

	// NewState is the state after transition
	NewState State

	// Timestamp is when the transition occurred
	Timestamp time.Time

	// Error contains any error that occurred during transition
	Error error

	// SyncResult contains the label synchronization details
	SyncResult *SyncResult
}

type ValidationFailure struct {
	// ValidatorName is the name of the validator that failed
	ValidatorName string

	// Reason is a human-readable description of why validation failed
	Reason string

	// Details provides additional context (e.g., expected vs actual values)
	Details map[string]interface{}

	// Severity indicates how critical this failure is
	Severity FailureSeverity
}