engine

type ArenaConfig struct {
	APIVersion string            `yaml:"apiVersion"`
	Kind       string            `yaml:"kind"`
	Metadata   metav1.ObjectMeta `yaml:"metadata,omitempty"`
	Spec       config.Config     `yaml:"spec"`
}

type AssertionsSummary struct {
	Failed  int                                       `json:"failed"`
	Passed  bool                                      `json:"passed"`
	Results []assertions.ConversationValidationResult `json:"results"`
	Total   int                                       `json:"total"`
}

type ConversationExecutor interface {
	// ExecuteConversation runs a complete conversation based on scenario
	ExecuteConversation(ctx context.Context, req ConversationRequest) *ConversationResult

	// ExecuteConversationStream runs a conversation with streaming
	ExecuteConversationStream(ctx context.Context, req ConversationRequest) (<-chan ConversationStreamChunk, error)
}

type ConversationRequest struct {
	// Required fields
	Provider providers.Provider
	Scenario *config.Scenario
	Config   *config.Config
	Region   string

	// Optional overrides (for future use)
	Temperature *float64 // Override scenario temperature
	MaxTokens   *int     // Override scenario max tokens
	Timeout     *int     // Timeout in seconds

	// For distributed execution and tracing (v0.2.0+)
	RunID    string            // Unique identifier for this run
	Metadata map[string]string // Additional metadata for debugging/tracing

	// Event bus for runtime/TUI events
	EventBus *events.EventBus

	// State management
	StateStoreConfig *StateStoreConfig // Optional state store configuration
	ConversationID   string            // Conversation identifier for state persistence
}

type ConversationResult struct {
	Messages     []types.Message         // Flat list of all messages in the conversation
	Cost         types.CostInfo          // Total cost across all messages
	ToolStats    *types.ToolStats        // Tool usage statistics
	Violations   []types.ValidationError // Validation errors
	MediaOutputs []MediaOutput           // Media outputs generated by LLMs

	// Conversation-level assertions
	ConversationAssertionResults []assertions.ConversationValidationResult `json:"conv_assertions_results,omitempty"`

	// Self-play metadata
	SelfPlay  bool   `json:"self_play,omitempty"`
	PersonaID string `json:"persona_id,omitempty"`

	// Error handling
	Error  string `json:"error,omitempty"`  // Error message if execution failed
	Failed bool   `json:"failed,omitempty"` // Whether execution failed (but partial results may be available)
}

type ConversationStreamChunk struct {
	// Current turn number (0-indexed)
	TurnIndex int

	// Delta content from this specific chunk
	Delta string

	// Token count (accumulated for current turn)
	TokenCount int

	// Finish reason for current turn (only in last chunk of turn)
	FinishReason *string

	// Complete conversation result (accumulated, updated with each chunk)
	Result *ConversationResult

	// Error if streaming failed
	Error error

	// Metadata
	Metadata map[string]interface{}
}

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

type DistributedExecutor interface {
	// Execute runs work units across distributed workers
	Execute(ctx context.Context, units []WorkUnit) error

	// Status returns current execution status
	Status() ExecutionStatus

	// Workers returns information about available workers
	Workers() []WorkerInfo

	// Scale adjusts the number of workers
	Scale(ctx context.Context, workerCount int) error
}

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

type ExecutionStatus struct {
	Total     int           `json:"total"`      // Total work units
	Completed int           `json:"completed"`  // Completed work units
	Running   int           `json:"running"`    // Currently executing
	Failed    int           `json:"failed"`     // Failed work units
	StartTime time.Time     `json:"start_time"` // Execution start time
	Duration  time.Duration `json:"duration"`   // Total duration so far
	Workers   int           `json:"workers"`    // Active worker count
}

type MediaOutput struct {
	Type       string `json:"type"`                // "image", "audio", "video"
	MIMEType   string `json:"mime_type"`           // e.g., "image/jpeg", "audio/mp3"
	SizeBytes  int64  `json:"size_bytes"`          // Size of the media file
	Duration   *int   `json:"duration,omitempty"`  // Duration in seconds (for audio/video)
	Width      *int   `json:"width,omitempty"`     // Width in pixels (for image/video)
	Height     *int   `json:"height,omitempty"`    // Height in pixels (for image/video)
	FilePath   string `json:"file_path,omitempty"` // Path where media was saved
	Thumbnail  string `json:"thumbnail,omitempty"` // Base64-encoded thumbnail for HTML reports
	MessageIdx int    `json:"message_index"`       // Index of message containing this media
	PartIdx    int    `json:"part_index"`          // Index of content part within the message
}

type MediaOutputStats struct {
	Total          int            `json:"total"`
	ImageCount     int            `json:"image_count"`
	AudioCount     int            `json:"audio_count"`
	VideoCount     int            `json:"video_count"`
	TotalSizeBytes int64          `json:"total_size_bytes"`
	ByType         map[string]int `json:"by_type"`
}

type ResultSink interface {
	// Store saves a work result
	Store(ctx context.Context, result WorkResult) error

	// Retrieve gets a work result by work unit ID
	Retrieve(ctx context.Context, workUnitID string) (WorkResult, error)

	// Query searches for results matching criteria
	Query(ctx context.Context, criteria map[string]interface{}) ([]WorkResult, error)

	// Subscribe to real-time result updates
	Subscribe(ctx context.Context, filter func(WorkResult) bool) (<-chan WorkResult, error)
}

type RunCombination struct {
	Region     string
	ScenarioID string
	ProviderID string
}

type RunPlan struct {
	Combinations []RunCombination
}

type RunResult struct {
	RunID      string                  `json:"RunID"`
	PromptPack string                  `json:"PromptPack"`
	Region     string                  `json:"Region"`
	ScenarioID string                  `json:"ScenarioID"`
	ProviderID string                  `json:"ProviderID"`
	Params     map[string]interface{}  `json:"Params"`
	Messages   []types.Message         `json:"Messages"`
	Commit     map[string]interface{}  `json:"Commit"`
	Cost       types.CostInfo          `json:"Cost"`
	ToolStats  *types.ToolStats        `json:"ToolStats"`
	Violations []types.ValidationError `json:"Violations"`
	StartTime  time.Time               `json:"StartTime"`
	EndTime    time.Time               `json:"EndTime"`
	Duration   time.Duration           `json:"Duration"`
	Error      string                  `json:"Error"`
	SelfPlay   bool                    `json:"SelfPlay"`
	PersonaID  string                  `json:"PersonaID"`

	UserFeedback  *statestore.Feedback `json:"UserFeedback"`
	SessionTags   []string             `json:"SessionTags"`
	AssistantRole *SelfPlayRoleInfo    `json:"AssistantRole"`
	UserRole      *SelfPlayRoleInfo    `json:"UserRole"`

	// Media outputs generated by LLMs during test execution
	MediaOutputs []MediaOutput `json:"MediaOutputs,omitempty"`

	// Conversation-level assertions evaluated after the conversation completes (summary format)
	ConversationAssertions AssertionsSummary `json:"conversation_assertions,omitempty"`
}

type SelfPlayRoleInfo struct {
	Provider string
	Model    string
	Region   string
}

type StateStoreConfig struct {
	Store    interface{}            // State store implementation (statestore.Store)
	UserID   string                 // User identifier (optional)
	Metadata map[string]interface{} // Additional metadata to store (optional)
}

type WorkResult interface {
	// WorkUnitID returns the ID of the work unit that produced this result
	WorkUnitID() string

	// Success indicates if the work unit completed successfully
	Success() bool

	// Data returns the result data (conversation, analysis, etc.)
	Data() interface{}

	// Error returns any error that occurred during execution
	Error() error

	// Metadata returns additional metadata about the execution
	Metadata() map[string]interface{}
}

type WorkSource interface {
	// Generate creates work units from configuration
	Generate(ctx context.Context, config interface{}) ([]WorkUnit, error)

	// Stream provides work units as they become available
	Stream(ctx context.Context, config interface{}) (<-chan WorkUnit, error)

	// EstimateWorkload returns expected number of work units
	EstimateWorkload(ctx context.Context, config interface{}) (int, error)
}

type WorkUnit interface {
	// ID returns unique identifier for this work unit
	ID() string

	// Execute performs the work unit and returns results
	Execute(ctx context.Context) (WorkResult, error)

	// Dependencies returns work units that must complete before this one
	Dependencies() []string

	// Priority returns execution priority (higher number = higher priority)
	Priority() int

	// EstimatedDuration returns expected execution time
	EstimatedDuration() time.Duration
}

type WorkerInfo struct {
	ID       string                 `json:"id"`        // Worker identifier
	Status   string                 `json:"status"`    // online, offline, busy
	Capacity int                    `json:"capacity"`  // Max concurrent work units
	Current  int                    `json:"current"`   // Current work units
	LastSeen time.Time              `json:"last_seen"` // Last heartbeat
	Metadata map[string]interface{} `json:"metadata"`  // Additional worker info
}