llm

type BatchEmbeddingClient interface {
	EmbeddingClient

	// EmbedBatch generates embeddings for multiple texts in a single request.
	// This is more efficient than calling Embed in a loop.
	//
	// Parameters:
	//   - ctx: Context for cancellation and timeout
	//   - texts: The texts to embed
	//
	// Returns:
	//   - [][]float64: The embedding vectors, one per input text
	//   - error if batch embedding fails
	EmbedBatch(ctx context.Context, texts []string) ([][]float64, error)
}

type Capability string

type CapabilityChecker interface {
	// HasCapability checks if the provider supports the given capability.
	HasCapability(cap Capability) bool

	// Capabilities returns all supported capabilities.
	Capabilities() []Capability
}

type Client interface {
	// Complete 生成文本补全
	Complete(ctx context.Context, req *CompletionRequest) (*CompletionResponse, error)

	// Chat 进行对话
	Chat(ctx context.Context, messages []Message) (*CompletionResponse, error)

	// Provider 返回提供商类型
	Provider() constants.Provider

	// IsAvailable 检查 LLM 是否可用
	IsAvailable() bool
}

type ClientFactory interface {
	CreateClient(opts *LLMOptions) (Client, error)
}

type ClientOption func(*LLMOptions)

type CompletionRequest struct {
	Messages    []Message `json:"messages"`              // 消息列表
	Temperature float64   `json:"temperature,omitempty"` // 温度参数 (0.0-2.0)
	MaxTokens   int       `json:"max_tokens,omitempty"`  // 最大 token 数
	Model       string    `json:"model,omitempty"`       // 模型名称
	Stop        []string  `json:"stop,omitempty"`        // 停止序列
	TopP        float64   `json:"top_p,omitempty"`       // Top-p 采样
}

type CompletionResponse struct {
	Content      string                 `json:"content"`                 // 生成的内容
	Model        string                 `json:"model"`                   // 使用的模型
	TokensUsed   int                    `json:"tokens_used,omitempty"`   // 使用的 token 数 (deprecated: use Usage instead)
	FinishReason string                 `json:"finish_reason,omitempty"` // 结束原因
	Provider     string                 `json:"provider,omitempty"`      // 提供商
	Usage        *interfaces.TokenUsage `json:"usage,omitempty"`         // 详细的 Token 使用统计
}

type EmbeddingClient interface {
	// Embed generates a vector embedding for the given text.
	// The embedding can be used for semantic search, similarity, clustering, etc.
	//
	// Parameters:
	//   - ctx: Context for cancellation and timeout
	//   - text: The text to embed
	//
	// Returns:
	//   - []float64: The embedding vector
	//   - error if embedding generation fails
	Embed(ctx context.Context, text string) ([]float64, error)
}

type FullClient interface {
	Client
	StreamClient
	ToolCallingClient
	EmbeddingClient
	CapabilityChecker
}

type LLMOptions struct {
	// 基础配置
	Provider constants.Provider `json:"provider"`           // 提供商
	APIKey   string             `json:"api_key"`            // API 密钥
	BaseURL  string             `json:"base_url,omitempty"` // 自定义 API 端点
	Model    string             `json:"model"`              // 默认模型

	// 生成参数
	MaxTokens   int     `json:"max_tokens"`      // 默认最大 token 数
	Temperature float64 `json:"temperature"`     // 默认温度 (0.0-2.0)
	TopP        float64 `json:"top_p,omitempty"` // Top-P 采样参数 (0.0-1.0)

	// 网络配置
	Timeout  int    `json:"timeout"`             // 请求超时（秒）
	ProxyURL string `json:"proxy_url,omitempty"` // 代理 URL

	// 重试配置
	RetryCount int           `json:"retry_count,omitempty"` // 重试次数
	RetryDelay time.Duration `json:"retry_delay,omitempty"` // 重试延迟

	// 速率限制
	RateLimitRPM int `json:"rate_limit_rpm,omitempty"` // 每分钟请求数限制

	// 缓存配置
	CacheEnabled bool          `json:"cache_enabled,omitempty"` // 是否启用缓存
	CacheTTL     time.Duration `json:"cache_ttl,omitempty"`     // 缓存 TTL

	// 流式响应
	StreamingEnabled bool `json:"streaming_enabled,omitempty"` // 是否启用流式响应

	// 其他配置
	OrganizationID string            `json:"organization_id,omitempty"` // 组织 ID (用于 OpenAI)
	SystemPrompt   string            `json:"system_prompt,omitempty"`   // 默认系统提示
	CustomHeaders  map[string]string `json:"custom_headers,omitempty"`  // 自定义 HTTP 头
}

type Message struct {
	Role    string `json:"role"`           // "system", "user", "assistant"
	Content string `json:"content"`        // 消息内容
	Name    string `json:"name,omitempty"` // 可选的消息名称
}

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

type PresetOption int

type StreamChunk struct {
	// Content 完整内容（累积）
	Content string `json:"content"`

	// Delta 增量内容
	Delta string `json:"delta"`

	// Role 角色
	Role string `json:"role,omitempty"`

	// FinishReason 结束原因
	FinishReason string `json:"finish_reason,omitempty"`

	// Usage 使用情况（仅在最后一个块）
	Usage *Usage `json:"usage,omitempty"`

	// Index 块序号
	Index int `json:"index"`

	// Timestamp 时间戳
	Timestamp time.Time `json:"timestamp"`

	// Done 是否完成
	Done bool `json:"done"`

	// Error 错误信息
	Error error `json:"error,omitempty"`
}

type StreamClient interface {
	Client // 继承基础接口

	// CompleteStream 流式补全
	CompleteStream(ctx context.Context, req *CompletionRequest) (<-chan *StreamChunk, error)

	// ChatStream 流式对话
	ChatStream(ctx context.Context, messages []Message) (<-chan *StreamChunk, error)
}

type StreamOptions struct {
	// BufferSize 缓冲区大小
	BufferSize int

	// IncludeUsage 是否包含使用情况
	IncludeUsage bool

	// OnChunk 块处理回调
	OnChunk func(*StreamChunk) error

	// OnComplete 完成回调
	OnComplete func(string) error

	// OnError 错误回调
	OnError func(error) error
}

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

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

type TokenStreamingClient interface {
	// Stream generates tokens for the given prompt and streams them as strings.
	// This is simpler than CompleteStream but provides less metadata.
	//
	// Parameters:
	//   - ctx: Context for cancellation and timeout
	//   - prompt: The input prompt
	//
	// Returns:
	//   - channel of string tokens
	//   - error if stream setup fails
	Stream(ctx context.Context, prompt string) (<-chan string, error)
}

type ToolCall struct {
	ID       string `json:"id"`
	Type     string `json:"type"` // "function"
	Function struct {
		Name      string `json:"name"`
		Arguments string `json:"arguments"` // JSON string
	} `json:"function"`
}

type ToolCallResponse struct {
	Content   string                 `json:"content"`
	ToolCalls []ToolCall             `json:"tool_calls,omitempty"`
	Usage     *interfaces.TokenUsage `json:"usage,omitempty"`
}

type ToolCallingClient interface {
	// GenerateWithTools sends a prompt with available tools and returns the response.
	// The LLM may respond with content, tool calls, or both.
	//
	// Parameters:
	//   - ctx: Context for cancellation and timeout
	//   - prompt: The user's input prompt
	//   - tools: Available tools that the LLM can call
	//
	// Returns:
	//   - ToolCallResponse containing content and/or tool calls
	//   - error if the request fails
	GenerateWithTools(ctx context.Context, prompt string, tools []interfaces.Tool) (*ToolCallResponse, error)

	// StreamWithTools is like GenerateWithTools but streams the response.
	// Tool calls are streamed as ToolChunk with type "tool_call", "tool_name", "tool_args".
	//
	// Parameters:
	//   - ctx: Context for cancellation and timeout
	//   - prompt: The user's input prompt
	//   - tools: Available tools that the LLM can call
	//
	// Returns:
	//   - channel of ToolChunk for streaming response
	//   - error if stream setup fails
	StreamWithTools(ctx context.Context, prompt string, tools []interfaces.Tool) (<-chan ToolChunk, error)
}

type ToolChunk struct {
	Type  string      `json:"type"`  // "content", "tool_call", "tool_name", "tool_args", "error"
	Value interface{} `json:"value"` // Content string, ToolCall, or error
}

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

type UseCase int