package main

import (
    "fmt"
    "jas-agent/agent"
    "jas-agent/llm"
    "github.com/sashabaranov/go-openai"
)

func main() {
    // 创建 LLM 客户端
    chat := llm.NewChat(&llm.Config{
        ApiKey:  "your-api-key",
        BaseURL: "your-api-base-url",
    })
    
    // 创建代理上下文
    context := agent.NewContext(
        agent.WithModel(openai.GPT3Dot5Turbo),
        agent.WithChat(chat),
    )
    
    // 创建执行器
    executor := agent.NewAgentExecutor(context)
    
    // 运行查询
    result := executor.Run("计算 15 + 27 的结果")
    fmt.Println(result)
}

type Agent interface {
    Type() AgentType
    Step() string
}

type Tool interface {
    Name() string
    Description() string
    Handler(ctx context.Context, input string) (string, error)
    Input() any          // JSON Schema（用于 Function Calling）
    Type() ToolType      // Normal 或 Mcp
}

package tools

import (
    "context"
    "jas-agent/core"
    "jas-agent/tools"
)

type MyTool struct{}

func (t *MyTool) Name() string {
    return "myTool"
}

func (t *MyTool) Description() string {
    return "我的自定义工具"
}

func (t *MyTool) Handler(ctx context.Context, input string) (string, error) {
    // 工具逻辑
    return "结果", nil
}

func (t *MyTool) Input() any {
    return nil // 或返回 JSON Schema
}

func (t *MyTool) Type() core.ToolType {
    return core.Normal
}

// 注册工具
func init() {
    tools.GetToolManager().RegisterTool(&MyTool{})
}

import "jas-agent/tools"

// 创建 MCP 工具管理器（HTTP Transport）
mcpManager, err := tools.NewMCPToolManager("my-mcp", "http://localhost:8080/mcp")
if err != nil {
    log.Fatal(err)
}

// 启动工具发现（后台自动刷新，每5秒）
mcpManager.Start()

// 设置模型
agent.WithModel(openai.GPT4)

// 设置聊天客户端
agent.WithChat(chat)

// 设置内存
agent.WithMemory(memory)

// 设置工具管理器
agent.WithToolManager(toolManager)

// ReAct Agent（默认10步）
executor := agent.NewAgentExecutor(context)

// SQL Agent（默认15步，适应复杂查询）
executor := agent.NewSQLAgentExecutor(context, "MySQL: dbname")

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
    "jas-agent/agent"
    "jas-agent/tools"
)

func main() {
    // 1. 连接数据库
    db, _ := sql.Open("mysql", "user:pass@tcp(localhost:3306)/dbname")
    defer db.Close()
    
    // 2. 注册 SQL 工具
    sqlConn := &tools.SQLConnection{DB: db}
    tools.RegisterSQLTools(sqlConn)
    
    // 3. 创建上下文
    context := agent.NewContext(
        agent.WithModel(openai.GPT3Dot5Turbo),
        agent.WithChat(chat),
    )
    
    // 4. 创建 SQL Agent 执行器
    executor := agent.NewSQLAgentExecutor(context, "MySQL: dbname")
    
    // 5. 执行查询
    result := executor.Run("查询：查询销售额最高的前10个产品")
    fmt.Println(result)
}

executor := agent.NewAgentExecutor(context)
result := executor.Run("计算 (15 + 27) * 3 的结果")
// 输出: 基于执行过程分析，15加27等于42，乘以3等于126。因此结果是126。

result := executor.Run("我有3只狗，一只边境牧羊犬、一只苏格兰梗和一只玩具贵宾犬。它们的总重量是多少？")
// 执行流程：
// 1. 查询边境牧羊犬平均体重: 37 lbs
// 2. 查询苏格兰梗平均体重: 20 lbs
// 3. 查询玩具贵宾犬平均体重: 7 lbs
// 4. 计算总重量: 37 + 20 + 7 = 64 lbs
// 5. 总结: 三只狗的总重量约为64磅

// 创建 MCP 工具管理器
mcpManager, _ := tools.NewMCPToolManager("weather-mcp", "http://weather-api:8080/mcp")
mcpManager.Start()

result := executor.Run("北京的天气怎么样？")
// LLM 会通过 Function Calling 调用 MCP 工具

import "database/sql"
import _ "github.com/go-sql-driver/mysql"

// 连接数据库
db, _ := sql.Open("mysql", "root:password@tcp(localhost:3306)/testdb")
defer db.Close()

// 注册 SQL 工具
sqlConn := &tools.SQLConnection{DB: db}
tools.RegisterSQLTools(sqlConn)

// 创建 SQL Agent 执行器
executor := agent.NewSQLAgentExecutor(context, "MySQL Database: testdb")

// 查询示例
result := executor.Run("查询：查询每个用户的订单总金额")

// 执行流程：
// 1. Thought: 需要了解数据库表结构
// 2. Action: list_tables[] 
// 3. Observation: Tables: users, orders
// 4. Thought: 需要查看 users 和 orders 表的结构
// 5. Action: tables_schema[users,orders]
// 6. Observation: [表结构详情]
// 7. Thought: 编写 SQL 查询
// 8. Action: execute_sql[SELECT u.username, SUM(o.amount) as total FROM users u LEFT JOIN orders o ON u.id=o.user_id GROUP BY u.id]
// 9. Observation: [查询结果]
// 10. Summary: 根据查询结果，每个用户的订单总金额为...

// BaseReact.Action()
toolCalls := agent.tools  // 从 LLM 响应获取工具调用

for _, toolCall := range toolCalls {
    // 执行工具
    result, err := agent.context.toolManager.ExecTool(ctx, toolCall)
    
    // 添加观察结果到内存
    agent.context.memory.AddMessage(core.Message{
        Role:    core.MessageRoleUser,
        Content: fmt.Sprintf("Observation: %s", result),
    })
}

type MyAgent struct {
    *BaseReact
    systemPrompt string
}

func (a *MyAgent) Type() AgentType {
    return "MyAgent"
}

func NewMyAgent(context *Context, executor *AgentExecutor) Agent {
    // 构建系统提示词
    systemPrompt := "你是一个..."
    context.memory.AddMessage(core.Message{
        Role:    core.MessageRoleSystem,
        Content: systemPrompt,
    })
    
    return &MyAgent{
        BaseReact:    NewBaseReact(context, executor),
        systemPrompt: systemPrompt,
    }
}

type MyMemory struct {
    // 实现 core.Memory 接口
}

func (m *MyMemory) AddMessage(message core.Message) {
    // 实现添加消息
}

// 1. 确保 MCP 工具管理器已启动
mcpManager, _ := tools.NewMCPToolManager("my-mcp", "http://localhost:8080/mcp")
mcpManager.Start()

// 2. 检查工具列表
tools := context.GetToolManager().AvailableTools()
for _, tool := range tools {
    fmt.Printf("Tool: %s - %s (Type: %v)\n", 
        tool.Name(), tool.Description(), tool.Type())
}

// 3. 确保工具名称一致
// MCP 工具会自动添加前缀: "my-mcp@toolName"