mocker

type Conditions struct {
	Providers    []string   `json:"providers"`     // Match specific providers (e.g., ["openai", "anthropic"])
	Models       []string   `json:"models"`        // Match specific models (e.g., ["gpt-4", "claude-3"])
	MessageRegex *string    `json:"message_regex"` // Regex pattern to match against message content
	RequestSize  *SizeRange `json:"request_size"`  // Request size constraints in bytes
}

type ErrorResponse struct {
	Message    string  `json:"message"`     // Error message to return
	Type       *string `json:"type"`        // Error type (e.g., "rate_limit", "auth_error")
	Code       *string `json:"code"`        // Error code (e.g., "429", "401")
	StatusCode *int    `json:"status_code"` // HTTP status code for the error
}

type Latency struct {
	Min  time.Duration `json:"min"`  // Minimum latency as time.Duration (e.g., 100*time.Millisecond, NOT raw int)
	Max  time.Duration `json:"max"`  // Maximum latency as time.Duration (e.g., 500*time.Millisecond, NOT raw int)
	Type string        `json:"type"` // Latency type: "fixed" or "uniform"
}

type MockRule struct {
	Name        string     `json:"name"`        // Unique rule name for identification and statistics tracking
	Enabled     bool       `json:"enabled"`     // Enable/disable this rule (disabled rules are skipped)
	Priority    int        `json:"priority"`    // Higher priority rules are checked first (higher numbers = higher priority)
	Conditions  Conditions `json:"conditions"`  // Conditions that must match for this rule to apply
	Responses   []Response `json:"responses"`   // Possible responses (selected using weighted random selection)
	Latency     *Latency   `json:"latency"`     // Rule-specific latency override (overrides global latency if set)
	Probability float64    `json:"probability"` // Probability of rule activation (0.0=never, 1.0=always, 0=disabled)
}

type MockStats struct {
	TotalRequests      int64            `json:"total_requests"`      // Total number of requests processed
	MockedRequests     int64            `json:"mocked_requests"`     // Number of requests that were mocked (rules matched)
	RuleHits           map[string]int64 `json:"rule_hits"`           // Rule name -> hit count mapping
	ErrorsGenerated    int64            `json:"errors_generated"`    // Number of error responses generated
	ResponsesGenerated int64            `json:"responses_generated"` // Number of success responses generated
}

type MockerConfig struct {
	Enabled         bool       `json:"enabled"`          // Enable/disable the mocker plugin
	GlobalLatency   *Latency   `json:"global_latency"`   // Global latency settings applied to all rules (can be overridden per rule)
	Rules           []MockRule `json:"rules"`            // List of mock rules to be evaluated in priority order
	DefaultBehavior string     `json:"default_behavior"` // Action when no rules match: "passthrough", "error", or "success"
}

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

type Response struct {
	Type           string           `json:"type"`            // Response type: "success" or "error"
	Weight         float64          `json:"weight"`          // Weight for random selection (higher = more likely)
	Content        *SuccessResponse `json:"content"`         // Success response content (required if Type="success")
	Error          *ErrorResponse   `json:"error"`           // Error response content (required if Type="error")
	AllowFallbacks *bool            `json:"allow_fallbacks"` // Control fallback behavior for errors (nil=true, false=no fallbacks)
}

type SizeRange struct {
	Min int `json:"min"` // Minimum request size in bytes
	Max int `json:"max"` // Maximum request size in bytes
}

type SuccessResponse struct {
	Message         string                 `json:"message"`          // Static response message
	Model           *string                `json:"model"`            // Override model name in response (optional)
	Usage           *Usage                 `json:"usage"`            // Token usage info (optional, defaults applied if nil)
	FinishReason    *string                `json:"finish_reason"`    // Completion reason (optional, defaults to "stop")
	MessageTemplate *string                `json:"message_template"` // Template with variables like {{model}}, {{provider}} (overrides Message)
	CustomFields    map[string]interface{} `json:"custom_fields"`    // Additional fields stored in response metadata
}

type Usage struct {
	PromptTokens     int `json:"prompt_tokens"`
	CompletionTokens int `json:"completion_tokens"`
	TotalTokens      int `json:"total_tokens"`
}