parallel

type BackpressureAction struct {
	Name       string          `json:"name"`
	Threshold  float64         `json:"threshold"`
	Action     string          `json:"action"` // throttle, reject, shed_load, degrade
	Parameters json.RawMessage `json:"parameters"`
}

type BackpressureConfig struct {
	Enabled          bool                          `json:"enabled"`
	LoadThreshold    float64                       `json:"loadThreshold"`
	Actions          map[string]BackpressureAction `json:"actions"`
	EvaluationWindow time.Duration                 `json:"evaluationWindow"`
}

type BackpressureManager struct {
	// contains filtered or unexported fields
}

type BackpressureMetrics struct {
	CurrentLoad       float64   `json:"currentLoad"`
	ThrottledRequests int64     `json:"throttledRequests"`
	RejectedRequests  int64     `json:"rejectedRequests"`
	ShedRequests      int64     `json:"shedRequests"`
	DegradedRequests  int64     `json:"degradedRequests"`
	LastAction        string    `json:"lastAction"`
	LastActionTime    time.Time `json:"lastActionTime"`
}

type BackpressureThresholds struct {
	Low    float64 `json:"low"`
	Medium float64 `json:"medium"`
	High   float64 `json:"high"`
}

type BatchProcessor struct {
	// contains filtered or unexported fields
}

type ControllerTaskResult struct {
	TaskID      string          `json:"task_id"`
	Success     bool            `json:"success"`
	Error       error           `json:"error,omitempty"`
	Duration    time.Duration   `json:"duration"`
	CompletedAt time.Time       `json:"completed_at"`
	Metadata    json.RawMessage `json:"metadata,omitempty"`
}

type DependencyAwareStrategy struct {
	// contains filtered or unexported fields
}

type DependencyGraph struct {
	// contains filtered or unexported fields
}

type DependencyNode struct {
	TaskID       string
	Dependencies []*DependencyNode
	Dependents   []*DependencyNode
	Completed    bool
	Failed       bool
	// contains filtered or unexported fields
}

type IntentProcessor struct {
	// contains filtered or unexported fields
}

type LLMProcessor struct {
	// contains filtered or unexported fields
}

type LeastConnectionsLoadBalancer struct {
	// contains filtered or unexported fields
}

type LoadBalancedStrategy struct {
	// contains filtered or unexported fields
}

type LoadBalancer struct {
	// contains filtered or unexported fields
}

type LoadBalancingStrategy interface {
	SelectPool(pools map[string]*WorkerPool, task *Task) (string, error)
	GetStrategyName() string
	UpdateMetrics(poolName string, metrics *PoolMetrics)
}

type ParallelProcessingConfig struct {
	// MaxConcurrentIntents limits concurrent intent processing
	MaxConcurrentIntents int

	// Worker pool sizes for different stages
	IntentPoolSize     int
	LLMPoolSize        int
	RAGPoolSize        int
	ResourcePoolSize   int
	ManifestPoolSize   int
	GitOpsPoolSize     int
	DeploymentPoolSize int

	// Task queue size
	TaskQueueSize int

	// Health check interval
	HealthCheckInterval time.Duration

	// Processing timeouts
	IntentTimeout     time.Duration
	LLMTimeout        time.Duration
	ManifestTimeout   time.Duration
	DeploymentTimeout time.Duration

	// Retry configurations
	MaxRetries      int
	RetryBackoff    time.Duration
	RetryMultiplier float64
}

type ParallelProcessingEngine struct {
	// contains filtered or unexported fields
}

type ParallelProcessor struct {
	// contains filtered or unexported fields
}

type ParallelReconciler struct {
	Client    client.Client
	Scheme    *runtime.Scheme
	Processor *ParallelProcessor
	Logger    logr.Logger
}

type PoolMetrics struct {
	ActiveWorkers  int32
	ProcessedTasks int64
	FailedTasks    int64
	AverageLatency time.Duration
	MemoryUsage    int64
	CPUUsage       float64
	QueueLength    int
	QueueCapacity  int
	Throughput     float64
	SuccessRate    float64
	LastUpdated    time.Time
}

type PriorityFirstStrategy struct {
	// contains filtered or unexported fields
}

type PriorityQueue struct {
	// contains filtered or unexported fields
}

type ProcessingEngineConfig struct {
	// Worker pool configurations.
	IntentWorkers     int `json:"intentWorkers"`
	LLMWorkers        int `json:"llmWorkers"`
	RAGWorkers        int `json:"ragWorkers"`
	ResourceWorkers   int `json:"resourceWorkers"`
	ManifestWorkers   int `json:"manifestWorkers"`
	GitOpsWorkers     int `json:"gitopsWorkers"`
	DeploymentWorkers int `json:"deploymentWorkers"`

	// Queue configurations.
	MaxQueueSize int           `json:"maxQueueSize"`
	QueueTimeout time.Duration `json:"queueTimeout"`

	// Performance tuning.
	MaxConcurrentIntents int           `json:"maxConcurrentIntents"`
	ProcessingTimeout    time.Duration `json:"processingTimeout"`
	HealthCheckInterval  time.Duration `json:"healthCheckInterval"`

	// Resource limits.
	MaxMemoryPerWorker int64   `json:"maxMemoryPerWorker"`
	MaxCPUPerWorker    float64 `json:"maxCpuPerWorker"`

	// Backpressure settings.
	BackpressureEnabled   bool    `json:"backpressureEnabled"`
	BackpressureThreshold float64 `json:"backpressureThreshold"`

	// Load balancing.
	LoadBalancingStrategy string `json:"loadBalancingStrategy"`

	// Retry and circuit breaker.
	MaxRetries            int  `json:"maxRetries"`
	CircuitBreakerEnabled bool `json:"circuitBreakerEnabled"`

	// Monitoring.
	MetricsEnabled  bool `json:"metricsEnabled"`
	DetailedLogging bool `json:"detailedLogging"`
}

type ProcessingMetrics struct {
	// Total number of tasks processed
	TotalTasks int64

	// Number of successful tasks
	SuccessfulTasks int64

	// Number of failed tasks
	FailedTasks int64

	// Current number of running tasks
	RunningTasks int64

	// Current number of pending tasks
	PendingTasks int64

	// Average task processing latency
	AverageLatency time.Duration

	// Success rate (0.0 to 1.0)
	SuccessRate float64

	// Tasks per second throughput
	Throughput float64

	// Worker pool utilization
	WorkerUtilization map[TaskType]float64

	// Queue depths for different task types
	QueueDepths map[TaskType]int

	// Last updated timestamp
	LastUpdated time.Time
}

type ProcessingTask struct {
	ID        string
	Priority  int
	Timeout   time.Duration
	Processor func(context.Context) error
	Metadata  map[string]interface{}
}

type ProcessorConfig struct {
	MaxConcurrency int           `json:"max_concurrency"`
	DefaultTimeout time.Duration `json:"default_timeout"`
	QueueSize      int           `json:"queue_size"`
	EnableMetrics  bool          `json:"enable_metrics"`
	RetryAttempts  int           `json:"retry_attempts"`
	RetryBackoff   time.Duration `json:"retry_backoff"`
}

type ProcessorMetrics struct {
	TotalTasks     int64         `json:"total_tasks"`
	CompletedTasks int64         `json:"completed_tasks"`
	FailedTasks    int64         `json:"failed_tasks"`
	AverageTime    time.Duration `json:"average_time"`
	MaxTime        time.Duration `json:"max_time"`
	MinTime        time.Duration `json:"min_time"`
	// contains filtered or unexported fields
}

type ReconcileTask struct {
	ID         string
	Priority   int
	Timeout    time.Duration
	Object     client.Object
	Req        ctrl.Request
	Client     client.Client
	Scheme     *runtime.Scheme
	Reconciler func(context.Context, ctrl.Request) (ctrl.Result, error)
}

type ResourceLimiter struct {
	// contains filtered or unexported fields
}

type RoundRobinLoadBalancer struct {
	// contains filtered or unexported fields
}

type SchedulingStrategy interface {
	ScheduleTask(task *Task, availableWorkers map[string]int) (string, error)
	GetStrategyName() string
	GetMetrics() map[string]float64
}

type Task struct {
	// ID is a unique identifier for the task
	ID string `json:"id"`

	// IntentID links the task to a NetworkIntent
	IntentID string `json:"intent_id"`

	// CorrelationID for tracing and error correlation (Go 1.24+ migration)
	// Added for backward compatibility with existing tests
	CorrelationID string `json:"correlation_id,omitempty"`

	// Type specifies the type of task
	Type TaskType `json:"type"`

	// Priority determines processing priority
	Priority int `json:"priority"`

	// Status tracks the current task status
	Status TaskStatus `json:"status"`

	// InputData contains input parameters for the task
	InputData json.RawMessage `json:"input_data,omitempty"`

	// OutputData contains results from task execution
	OutputData json.RawMessage `json:"output_data,omitempty"`

	// Error contains error information if task failed
	Error error `json:"-"`

	// Context for the task execution
	Context context.Context `json:"-"`

	// Cancel function for task cancellation
	Cancel context.CancelFunc `json:"-"`

	// Timeout for task execution
	Timeout time.Duration `json:"timeout"`

	// RetryConfig for advanced retry configuration (Go 1.24+ evolution)
	RetryConfig *TaskRetryConfig `json:"retry_config,omitempty"`

	// RetryCount tracks number of retry attempts (maintained for compatibility)
	RetryCount int `json:"retry_count"`

	// CreatedAt timestamp
	CreatedAt time.Time `json:"created_at"`

	// StartedAt timestamp
	StartedAt *time.Time `json:"started_at,omitempty"`

	// CompletedAt timestamp
	CompletedAt *time.Time `json:"completed_at,omitempty"`

	// ScheduledAt timestamp when task was scheduled
	ScheduledAt *time.Time `json:"scheduled_at,omitempty"`

	// Dependencies are tasks that must complete before this task
	Dependencies []string `json:"dependencies,omitempty"`

	// Metadata for additional task information
	Metadata map[string]string `json:"metadata,omitempty"`

	// Intent reference for context
	Intent *v1.NetworkIntent `json:"-"`

	// Callback functions
	OnSuccess func(*TaskResult) `json:"-"`
	OnFailure func(*TaskResult) `json:"-"`

	// Version field for struct evolution tracking
	Version int `json:"version,omitempty"`
}

type TaskBuilder struct {
	// contains filtered or unexported fields
}

type TaskCompatibilityLayer struct{}

type TaskEvolution struct{}

type TaskInterface interface {
	Execute(ctx context.Context) error
	GetID() string
	GetPriority() int
	GetTimeout() time.Duration
}

type TaskPriorityQueue struct {
	// contains filtered or unexported fields
}

type TaskProcessor interface {
	ProcessTask(ctx context.Context, task *Task) (*TaskResult, error)
	GetProcessorType() TaskType
	HealthCheck(ctx context.Context) error
	GetMetrics() map[string]interface{}
}

type TaskResult struct {
	// Task identification
	TaskID   string
	WorkerID int
	PoolName string

	// Result status
	Success      bool
	Error        error
	ErrorMessage string

	// Timing information
	Duration       time.Duration
	QueueTime      time.Duration
	ProcessingTime time.Duration
	CompletedAt    time.Time

	// Resource usage
	MemoryUsed int64
	CPUUsed    float64

	// Output data
	OutputData       map[string]interface{}
	ProcessingResult *contracts.ProcessingResult
}

type TaskRetryConfig struct {
	MaxAttempts   int           `json:"maxAttempts"`
	InitialDelay  time.Duration `json:"initialDelay"`
	BackoffFactor float64       `json:"backoffFactor"`
	MaxDelay      time.Duration `json:"maxDelay"`
}

type TaskScheduler struct {
	// contains filtered or unexported fields
}

type TaskStatus string

type TaskType string

type ValidationRule struct {
	Name        string
	Description string
	Validator   func(context.Context, client.Object, client.Client) error
}

type ValidationTask struct {
	ID       string
	Priority int
	Timeout  time.Duration
	Object   client.Object
	Rules    []ValidationRule
	Client   client.Client
}

type WeightedResponseTimeLoadBalancer struct {
	// contains filtered or unexported fields
}

type Worker struct {
	// Basic identification
	ID      int
	Type    TaskType
	Queue   chan *Task
	Results chan *Task
	Context context.Context
	Cancel  context.CancelFunc
	Engine  *ParallelProcessingEngine
	// contains filtered or unexported fields
}

type WorkerPool struct {
	// contains filtered or unexported fields
}

type WorkflowResult struct {
	// IntentID is the ID of the processed intent
	IntentID string

	// Success indicates if the workflow completed successfully
	Success bool

	// Error contains error information if workflow failed
	Error error

	// Tasks contains information about all tasks in the workflow
	Tasks []*Task

	// StartTime when workflow processing began
	StartTime time.Time

	// EndTime when workflow processing completed
	EndTime time.Time

	// Duration of workflow processing
	Duration time.Duration

	// Results contains structured output from the workflow
	Results map[string]interface{}
}