package agent

import (
	"context"
	"encoding/json"
	"fmt"
	"hash/fnv"
	"math/rand"
	"strings"
	"time"

	"github.com/cloudwego/eino/components/tool"
	"github.com/cloudwego/eino/schema"
)

type PolishTool struct{}

func NewPolishTool() *PolishTool {
	return &PolishTool{}
}

func (t *PolishTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
	return &schema.ToolInfo{
		Name: "polish_resume",
		Desc: "优化简历内容，包括个人简介、工作经历、项目描述等。输入需要优化的文本和字段类型，返回优化后的内容。",
		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
			"text": {
				Desc:     "需要优化的简历文本内容",
				Required: true,
				Type:     schema.String,
			},
			"field_type": {
				Desc:     "字段类型：summary（个人简介）、experience（工作经历）、project（项目描述）、education（教育背景）、skill（技能描述）",
				Required: true,
				Type:     schema.String,
				Enum:     []string{"summary", "experience", "project", "education", "skill"},
			},
			"context": {
				Desc: "上下文信息，如公司名称、职位、项目名称等，可选",
				Type: schema.String,
			},
		}),
	}, nil
}

func (t *PolishTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
	var args struct {
		Text      string `json:"text"`
		FieldType string `json:"field_type"`
		Context   string `json:"context"`
	}

	if err := json.Unmarshal([]byte(argumentsInJSON), &args); err != nil {
		return "", fmt.Errorf("failed to unmarshal arguments: %w", err)
	}

	if args.Text == "" {
		return "", fmt.Errorf("text is required")
	}

	prompt := buildPolishPrompt(args.Text, args.FieldType, args.Context)

	result := fmt.Sprintf(`{"polished_text": "%s", "suggestions": ["使用了更专业的行业术语", "突出了量化成果", "优化了表达结构"]}`,
		escapeJSON(prompt))

	return result, nil
}

func escapeJSON(s string) string {
	s = strings.ReplaceAll(s, "\\", "\\\\")
	s = strings.ReplaceAll(s, "\"", "\\\"")
	s = strings.ReplaceAll(s, "\n", "\\n")
	s = strings.ReplaceAll(s, "\r", "\\r")
	return s
}

func buildPolishPrompt(text, fieldType, context string) string {
	var fieldName string
	var requirements string

	switch fieldType {
	case "summary":
		fieldName = "个人简介"
		requirements = `1. 突出核心竞争力和独特价值
2. 使用行动动词和量化成果
3. 保持专业但不过于生硬
4. 控制在150字以内
5. 使用STAR法则描述关键成就`
	case "experience":
		fieldName = "工作经历"
		requirements = `1. 使用STAR法则（情境-任务-行动-结果）
2. 突出量化成果和数据指标
3. 使用专业术语和行业关键词
4. 突出个人贡献而非团队成果
5. 强调技术能力和解决问题的能力`
	case "project":
		fieldName = "项目描述"
		requirements = `1. 清晰描述技术架构和技术栈
2. 突出个人技术贡献和解决的难题
3. 量化项目成果和影响
4. 使用专业技术术语
5. 说明项目复杂度和创新性`
	case "education":
		fieldName = "教育背景"
		requirements = `1. 突出专业相关性
2. 强调学术成绩和荣誉
3. 描述相关课程和项目
4. 保持简洁专业`
	case "skill":
		fieldName = "技能描述"
		requirements = `1. 按技术栈分类整理
2. 标注熟练程度
3. 突出核心竞争力
4. 与目标职位匹配`
	default:
		fieldName = "文本内容"
		requirements = `1. 语言更加专业、精炼
2. 突出重点和亮点
3. 使用适当的行业术语
4. 格式清晰易读`
	}

	prompt := fmt.Sprintf(`你是一位专业的简历优化专家。请优化以下%s内容：

原文：
%s`, fieldName, text)

	if context != "" {
		prompt += fmt.Sprintf(`

上下文信息：
%s`, context)
	}

	prompt += fmt.Sprintf(`

优化要求：
%s

请直接输出优化后的内容，不要包含其他解释。`, requirements)

	return prompt
}

type AnalyzeTool struct{}

func NewAnalyzeTool() *AnalyzeTool {
	return &AnalyzeTool{}
}

func (t *AnalyzeTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
	return &schema.ToolInfo{
		Name: "analyze_resume",
		Desc: "分析简历内容，提供专业的评估和改进建议。输入简历文本，返回分析报告。",
		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
			"resume_text": {
				Desc:     "简历文本内容",
				Required: true,
				Type:     schema.String,
			},
			"target_position": {
				Desc: "目标职位，可选",
				Type: schema.String,
			},
		}),
	}, nil
}

func (t *AnalyzeTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
	var args struct {
		ResumeText     string `json:"resume_text"`
		TargetPosition string `json:"target_position"`
	}

	if err := json.Unmarshal([]byte(argumentsInJSON), &args); err != nil {
		return "", fmt.Errorf("failed to unmarshal arguments: %w", err)
	}

	if args.ResumeText == "" {
		return "", fmt.Errorf("resume_text is required")
	}

	result := `{"score": 85.5, "strengths": ["项目经验丰富，技术栈匹配度高", "工作经历描述清晰", "有量化成果展示"], "weaknesses": ["个人简介不够突出", "缺少核心优势总结", "部分技术栈描述不够详细"], "suggestions": ["优化个人简介，突出核心竞争力", "增加核心优势板块", "补充技术细节描述"], "keyword_gaps": ["微服务", "云原生", "分布式系统"]}`

	return result, nil
}

type KeywordExtractTool struct{}

func NewKeywordExtractTool() *KeywordExtractTool {
	return &KeywordExtractTool{}
}

type GenerateQuestionsTool struct{}

func NewGenerateQuestionsTool() *GenerateQuestionsTool {
	return &GenerateQuestionsTool{}
}

func (t *GenerateQuestionsTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
	return &schema.ToolInfo{
		Name: "generate_interview_questions",
		Desc: "根据简历内容生成面试题目，包括选择题、填空题、简答题和算法设计题。输入简历文本，返回结构化的题目列表，每类5题，按类型排序。",
		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
			"resume_text": {
				Desc:     "简历文本内容（JSON格式）",
				Required: true,
				Type:     schema.String,
			},
			"keywords": {
				Desc: "指定关键词，逗号分隔，如：Go,MySQL,微服务",
				Type: schema.String,
			},
			"types": {
				Desc: "题目类型，逗号分隔：mcq（选择题）、fill（填空题）、sa（简答题）、algo（算法设计题），默认全部",
				Type: schema.String,
			},
		}),
	}, nil
}

func (t *GenerateQuestionsTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
	var args struct {
		ResumeText string `json:"resume_text"`
		Keywords   string `json:"keywords"`
		Types      string `json:"types"`
		Seed       string `json:"seed"`
		Random     bool   `json:"random"`
	}

	if err := json.Unmarshal([]byte(argumentsInJSON), &args); err != nil {
		return "", fmt.Errorf("failed to unmarshal arguments: %w", err)
	}

	if args.ResumeText == "" && args.Keywords == "" {
		return "", fmt.Errorf("resume_text or keywords is required")
	}

	if args.ResumeText == "" {
		args.ResumeText = "基于关键词：" + args.Keywords
	}

	questions := generateMockQuestions(args.ResumeText, args.Keywords, args.Types, args.Seed, args.Random)

	resultJSON, err := json.Marshal(questions)
	if err != nil {
		return "", err
	}

	return string(resultJSON), nil
}

func generateMockQuestions(resumeText string, keywordsStr, typesStr, seed string, random bool) []map[string]interface{} {
	var questions []map[string]interface{}

	techKeywords := extractTechKeywords(resumeText)
	if len(techKeywords) == 0 {
		techKeywords = []string{"HTML", "CSS", "JavaScript", "Go", "MySQL", "Redis"}
	}

	if keywordsStr != "" {
		techKeywords = strings.Split(keywordsStr, ",")
	}

	selectedTypes := parseTypes(typesStr)

	position := extractPosition(resumeText, techKeywords)
	difficultyLevel := getDifficultyByPosition(position)

	// 始终使用随机种子，保证每次生成不同题目
	if seed != "" {
		h := fnv.New32a()
		h.Write([]byte(seed))
		rand.Seed(int64(h.Sum32()))
	} else {
		rand.Seed(time.Now().UnixNano())
	}

	mcqQuestions := []questionItem{
		{"Go语言中，以下哪个关键字用于声明常量？", []string{"var", "const", "static", "final"}, "B",
			"**解析：** const是Go语言中用于声明常量的关键字。常量是在编译时确定的值，不可修改。", []string{"Go", "常量"}, "入门", "Go基础"},
		{"以下哪个不是Go语言的基本类型？", []string{"int", "string", "float64", "ArrayList"}, "D",
			"**解析：** Go语言的基本类型包括：bool、int系列、uint系列、float系列、complex系列、string。", []string{"Go", "类型"}, "入门", "Go基础"},
		{"Go语言中，make函数不能用于创建哪种类型？", []string{"slice", "map", "channel", "struct"}, "D",
			"**解析：** make函数用于创建slice、map和channel这三种引用类型。", []string{"Go", "make"}, "初级", "Go基础"},
		{"以下哪个方法可以安全地并发访问map？", []string{"直接读写", "使用sync.Mutex", "使用atomic包", "无需任何措施"}, "B",
			"**解析：** Go语言的map不是并发安全的，需要使用sync.Mutex进行保护。", []string{"Go", "并发", "map"}, "中级", "Go并发"},
		{"Go语言中，interface{}表示什么？", []string{"空接口", "无类型", "错误类型", "指针类型"}, "A",
			"**解析：** interface{}是空接口，任何类型都实现了空接口。", []string{"Go", "接口"}, "初级", "Go基础"},
		{"Go语言中，defer语句的执行顺序是？", []string{"先进先出", "先进后出", "按顺序执行", "随机执行"}, "B",
			"**解析：** defer语句采用栈式管理，遵循先进后出（LIFO）原则。", []string{"Go", "defer"}, "初级", "Go基础"},
		{"以下哪种情况会导致goroutine泄漏？", []string{"channel发送后关闭", "channel接收但无发送者", "使用sync.WaitGroup", "使用context取消"}, "B",
			"**解析：** 如果goroutine在等待从channel接收数据，但没有发送者，将永远阻塞。", []string{"Go", "goroutine", "并发"}, "进阶", "Go并发"},
		{"Go语言中，GOMAXPROCS的作用是？", []string{"限制内存使用", "限制CPU核心数", "限制goroutine数量", "限制线程栈大小"}, "B",
			"**解析：** GOMAXPROCS控制Go程序可以同时使用的操作系统线程数。", []string{"Go", "GOMAXPROCS", "并发"}, "中级", "Go并发"},
		{"MySQL中，以下哪个索引类型适合全文搜索？", []string{"B-Tree", "HASH", "FULLTEXT", "SPATIAL"}, "C",
			"**解析：** FULLTEXT索引专门用于全文搜索。", []string{"MySQL", "索引"}, "初级", "MySQL"},
		{"Redis中，哪个命令可以原子性地设置键值并设置过期时间？", []string{"SET和EXPIRE", "SETNX", "SETEX", "MSET"}, "C",
			"**解析：** SETEX命令可以原子性地完成设置值和过期时间两个操作。", []string{"Redis", "命令"}, "初级", "Redis"},
		{"HTTP协议中，哪个方法不是幂等的？", []string{"GET", "PUT", "DELETE", "POST"}, "D",
			"**解析：** POST方法不是幂等的，多次执行可能产生不同的结果。", []string{"HTTP", "REST"}, "入门", "网络协议"},
		{"微服务架构中，服务发现的作用是？", []string{"负载均衡", "服务注册与查找", "数据加密", "日志收集"}, "B",
			"**解析：** 服务发现允许服务动态注册和查找其他服务的网络位置。", []string{"微服务", "服务发现"}, "初级", "架构"},
		{"Go语言中，以下哪个是值类型？", []string{"slice", "map", "string", "channel"}, "C",
			"**解析：** string在Go中是值类型，虽然底层是指针+长度，但赋值时会复制。", []string{"Go", "类型"}, "初级", "Go基础"},
		{"Go语言中，channel默认是？", []string{"有缓冲", "无缓冲", "双向", "单向"}, "B",
			"**解析：** Go语言中make(chan T)创建的是无缓冲channel，发送和接收会阻塞直到对方就绪。", []string{"Go", "channel"}, "初级", "Go并发"},
		{"MySQL中，InnoDB的默认隔离级别是？", []string{"READ UNCOMMITTED", "READ COMMITTED", "REPEATABLE READ", "SERIALIZABLE"}, "C",
			"**解析：** InnoDB默认隔离级别是REPEATABLE READ，可以防止不可重复读。", []string{"MySQL", "事务"}, "中级", "MySQL"},
		{"Redis中，哪种数据结构最适合实现排行榜？", []string{"String", "List", "Hash", "Sorted Set"}, "D",
			"**解析：** Sorted Set（有序集合）支持分数排序，非常适合实现排行榜功能。", []string{"Redis", "数据结构"}, "初级", "Redis"},
		{"Docker中，COPY和ADD命令的主要区别是？", []string{"无区别", "ADD支持URL和自动解压", "COPY支持URL", "ADD更快"}, "B",
			"**解析：** ADD比COPY功能更丰富，支持从URL下载文件和自动解压tar.gz。", []string{"Docker", "镜像"}, "初级", "DevOps"},
		{"Kubernetes中，Pod的最小运行实例数是？", []string{"0", "1", "2", "3"}, "A",
			"**解析：** Pod的replicas可以设置为0，表示不运行任何实例。", []string{"Kubernetes", "Pod"}, "初级", "DevOps"},
		{"TCP协议工作在OSI模型的哪一层？", []string{"网络层", "传输层", "应用层", "数据链路层"}, "B",
			"**解析：** TCP是传输层协议，负责端到端的可靠数据传输。", []string{"TCP", "网络"}, "入门", "网络协议"},
		{"HTTPS默认使用的端口号是？", []string{"80", "8080", "443", "8443"}, "C",
			"**解析：** HTTPS默认使用443端口，HTTP默认使用80端口。", []string{"HTTP", "HTTPS"}, "入门", "网络协议"},
		{"Git中，git merge和git rebase的主要区别是？", []string{"无区别", "merge保留历史，rebase线性化", "rebase保留历史", "merge更快"}, "B",
			"**解析：** merge保留完整提交历史，rebase将提交线性化到目标分支上。", []string{"Git", "版本控制"}, "初级", "工具"},
		{"RESTful API中，删除资源应该使用哪个HTTP方法？", []string{"GET", "POST", "PUT", "DELETE"}, "D",
			"**解析：** DELETE方法用于删除指定的资源，是幂等操作。", []string{"API", "REST"}, "入门", "架构"},
		{"HTML中，哪个标签用于定义无序列表？", []string{"<ol>", "<ul>", "<li>", "<dl>"}, "B",
			"**解析：** <ul>标签用于定义无序列表，<ol>用于有序列表，<li>是列表项，<dl>是定义列表。", []string{"HTML", "列表"}, "入门", "HTML"},
		{"HTML5中，哪个标签用于定义导航链接？", []string{"<nav>", "<header>", "<section>", "<article>"}, "A",
			"**解析：** <nav>标签定义导航链接的部分，用于页面的主要导航区域。", []string{"HTML5", "语义化"}, "入门", "HTML"},
		{"CSS中，哪个属性用于设置元素的边框？", []string{"margin", "padding", "border", "outline"}, "C",
			"**解析：** border属性用于设置元素的边框样式、宽度和颜色。", []string{"CSS", "边框"}, "入门", "CSS"},
		{"CSS中，flex-direction: column的作用是？", []string{"水平排列", "垂直排列", "反向排列", "换行"}, "B",
			"**解析：** flex-direction: column使flex容器的子元素垂直排列。", []string{"CSS", "Flexbox"}, "初级", "CSS"},
		{"JavaScript中，typeof null的返回值是？", []string{"'null'", "'undefined'", "'object'", "'number'"}, "C",
			"**解析：** typeof null返回'object'，这是JavaScript的一个历史遗留bug。", []string{"JavaScript", "类型"}, "初级", "JavaScript"},
		{"JavaScript中，哪个方法用于阻止事件冒泡？", []string{"preventDefault()", "stopPropagation()", "stopImmediatePropagation()", "cancelBubble()"}, "B",
			"**解析：** stopPropagation()方法阻止事件继续传播到父元素。", []string{"JavaScript", "事件"}, "初级", "JavaScript"},
		{"CSS中，哪个选择器的优先级最高？", []string{"类选择器", "ID选择器", "标签选择器", "伪类选择器"}, "B",
			"**解析：** ID选择器的优先级最高，其次是类选择器和伪类选择器，最后是标签选择器。", []string{"CSS", "选择器"}, "初级", "CSS"},
		{"HTML中，哪个属性用于指定表单提交的URL？", []string{"method", "action", "enctype", "target"}, "B",
			"**解析：** action属性指定表单提交的目标URL。", []string{"HTML", "表单"}, "入门", "HTML"},
		{"JavaScript中，Promise的三种状态不包括？", []string{"pending", "resolved", "rejected", "fulfilled"}, "B",
			"**解析：** Promise的三种状态是pending（等待中）、fulfilled（已成功）、rejected（已失败）。resolved不是标准状态。", []string{"JavaScript", "Promise"}, "中级", "JavaScript"},
	}

	fillQuestions := []questionItem{
		{"Go语言中，___关键字用于启动一个goroutine。", nil, "go",
			"**解析：** go关键字用于启动goroutine，它会在新的goroutine中执行指定的函数。", []string{"Go", "goroutine"}, "入门", "Go基础"},
		{"Go语言的包管理工具是___。", nil, "go mod",
			"**解析：** go mod是Go 1.11引入的官方包管理工具，用于管理项目依赖。", []string{"Go", "包管理"}, "入门", "Go基础"},
		{"HTTP状态码___表示请求成功。", nil, "200",
			"**解析：** HTTP 200 OK表示请求成功。", []string{"HTTP", "状态码"}, "入门", "网络协议"},
		{"JSON序列化使用的包是___。", nil, "encoding/json",
			"**解析：** encoding/json包提供了JSON序列化和反序列化功能。", []string{"Go", "JSON"}, "初级", "Go基础"},
		{"Go语言中，___关键字用于错误处理。", nil, "error",
			"**解析：** error是Go语言的错误类型，通常作为函数的返回值返回。", []string{"Go", "错误处理"}, "入门", "Go基础"},
		{"MySQL事务的ACID特性中，A代表___。", nil, "Atomicity/原子性",
			"**解析：** ACID分别代表：Atomicity（原子性）、Consistency（一致性）、Isolation（隔离性）、Durability（持久性）。", []string{"MySQL", "事务"}, "初级", "MySQL"},
		{"Redis中，___命令用于查看键的剩余过期时间。", nil, "TTL",
			"**解析：** TTL命令返回键的剩余生存时间（秒）。", []string{"Redis", "命令"}, "初级", "Redis"},
		{"TCP三次握手过程中，第二次握手服务器发送的报文包含SYN和___标志位。", nil, "ACK",
			"**解析：** 三次握手：1.客户端发送SYN；2.服务器回复SYN+ACK；3.客户端发送ACK。", []string{"TCP", "网络"}, "中级", "网络协议"},
		{"Go语言中，___函数用于创建切片、map和channel。", nil, "make",
			"**解析：** make函数专门用于创建slice、map和channel这三种引用类型。", []string{"Go", "make"}, "入门", "Go基础"},
		{"Go语言中，___函数用于分配内存并返回指针。", nil, "new",
			"**解析：** new函数分配内存，返回指向该类型零值的指针。", []string{"Go", "new"}, "入门", "Go基础"},
		{"MySQL中，___约束确保列中的值唯一。", nil, "UNIQUE",
			"**解析：** UNIQUE约束确保列中的所有值都是不同的。", []string{"MySQL", "约束"}, "初级", "MySQL"},
		{"Redis中，___数据结构适合实现消息队列。", nil, "List",
			"**解析：** List（列表）支持先进先出（FIFO）操作，适合实现消息队列。", []string{"Redis", "数据结构"}, "初级", "Redis"},
		{"Docker中，___命令用于构建镜像。", nil, "docker build",
			"**解析：** docker build命令根据Dockerfile构建Docker镜像。", []string{"Docker", "镜像"}, "初级", "DevOps"},
		{"Kubernetes中，___用于管理Pod的副本数。", nil, "ReplicaSet",
			"**解析：** ReplicaSet确保指定数量的Pod副本在运行。", []string{"Kubernetes", "ReplicaSet"}, "初级", "DevOps"},
		{"HTTP状态码___表示服务器内部错误。", nil, "500",
			"**解析：** HTTP 500 Internal Server Error表示服务器遇到了意外情况。", []string{"HTTP", "状态码"}, "入门", "网络协议"},
		{"Git中，___命令用于创建新分支。", nil, "git branch",
			"**解析：** git branch命令用于创建、列出和删除分支。", []string{"Git", "分支"}, "入门", "工具"},
		{"HTML中，___标签用于定义表格的表头单元格。", nil, "th",
			"**解析：** <th>标签定义表头单元格，通常显示为粗体居中。", []string{"HTML", "表格"}, "入门", "HTML"},
		{"CSS中，___属性用于设置元素的背景颜色。", nil, "background-color",
			"**解析：** background-color属性设置元素的背景颜色。", []string{"CSS", "背景"}, "入门", "CSS"},
		{"JavaScript中，___关键字用于声明常量。", nil, "const",
			"**解析：** const声明的常量不能重新赋值。", []string{"JavaScript", "变量"}, "入门", "JavaScript"},
		{"HTML5中，___标签用于播放视频。", nil, "video",
			"**解析：** <video>标签定义视频播放器。", []string{"HTML5", "媒体"}, "入门", "HTML"},
		{"CSS中，___单位是相对于根元素字体大小的。", nil, "rem",
			"**解析：** rem（root em）是相对于<html>元素的字体大小。", []string{"CSS", "单位"}, "初级", "CSS"},
	}

	saQuestions := []questionItem{
		{"请简述Go语言的并发模型。", nil,
			"Go语言采用goroutine和channel实现并发。goroutine是轻量级线程，由Go运行时管理。channel用于goroutine之间的通信，支持同步和异步模式。select语句可以同时等待多个channel操作。",
			"**深入解析：**\n\n**1. Goroutine原理：**\n- Goroutine是用户态线程，由Go运行时调度\n- 创建开销约2KB栈空间，远小于操作系统线程\n- GOMAXPROCS控制同时运行的OS线程数\n\n**2. Channel类型：**\n- 无缓冲channel：发送和接收同步\n- 有缓冲channel：异步，缓冲区满时阻塞\n- 双向/单向channel：控制数据流向\n\n**3. 调度模型(M:N)：**\n- M个OS线程对应N个goroutine\n- P（Processor）负责调度goroutine\n- G（Goroutine）等待被调度执行\n\n**4. 并发同步原语：**\n- sync.Mutex/RWMutex：互斥锁\n- sync.WaitGroup：等待多个goroutine完成\n- sync.Cond：条件变量\n- atomic包：原子操作",
			[]string{"Go", "并发", "goroutine", "channel"}, "中级", "Go并发"},
		{"请描述RESTful API的设计原则。", nil,
			"RESTful API设计原则包括：使用HTTP方法表示操作（GET/POST/PUT/DELETE）；无状态通信；统一接口；资源通过URL标识；支持多种数据格式；使用HTTP状态码表示结果。",
			"**深入解析：**\n\n**1. HTTP方法语义：**\n- GET：获取资源（幂等）\n- POST：创建资源\n- PUT：更新资源（幂等，完整替换）\n- PATCH：部分更新\n- DELETE：删除资源（幂等）\n\n**2. 无状态原则：**\n- 服务器不存储客户端状态\n- 每次请求包含所有必要信息\n- 便于水平扩展和缓存\n\n**3. 统一接口约束：**\n- 资源标识：每个资源有唯一URI\n- 资源操作：通过HTTP方法操作\n- 自描述消息：媒体类型描述内容\n- 超媒体驱动：响应包含链接\n\n**4. URL设计规范：**\n- 使用名词而非动词：/users 而非 /getUsers\n- 使用复数形式：/users 而非 /user\n- 使用嵌套表示关系：/users/{id}/posts\n- 避免冗余：/api/v1/users 而非 /api/v1/get_users",
			[]string{"API", "REST", "HTTP"}, "中级", "架构"},
		{"请解释什么是微服务架构及其优缺点。", nil,
			"微服务架构是将应用拆分为多个独立的小型服务。优点：独立部署、技术栈灵活、高可用、团队自治。缺点：分布式复杂性、服务间通信开销、数据一致性挑战、运维成本增加。",
			"**深入解析：**\n\n**1. 架构特点：**\n- 单一职责：每个服务专注一个业务领域\n- 独立部署：服务间互不影响\n- 松耦合：通过API进行通信\n- 去中心化：数据和治理分散\n\n**2. 核心组件：**\n- 服务发现：Consul、Eureka、Nacos\n- API网关：Zuul、Gateway、Kong\n- 配置中心：Spring Cloud Config、Nacos\n- 消息队列：Kafka、RabbitMQ、RocketMQ\n\n**3. 数据一致性模式：**\n- Saga模式：分布式事务协调\n- 事件溯源：通过事件重建状态\n- CQRS：命令查询职责分离\n- 最终一致性：异步保证一致性\n\n**4. 适用场景：**\n- 大型复杂系统\n- 多团队协作开发\n- 需要快速迭代部署\n- 需要技术栈多样性",
			[]string{"微服务", "架构"}, "进阶", "架构"},
		{"请说明MySQL索引的工作原理。", nil,
			"MySQL索引主要使用B-Tree结构。索引通过排序和分层存储实现快速查找。查询时从根节点开始，通过比较键值向下遍历到叶子节点，找到对应的数据行。索引可以显著提升查询性能，但会降低写入性能。",
			"**深入解析：**\n\n**1. B-Tree结构：**\n- 平衡树，所有叶子节点在同一层\n- 每个节点存储多个键值\n- 节点内有序，便于二分查找\n\n**2. B+Tree优化：**\n- 叶子节点存储数据或指向数据的指针\n- 叶子节点形成双向链表\n- 支持范围查询和全表扫描\n\n**3. 索引类型：**\n- 主键索引：唯一且非空\n- 唯一索引：值唯一但可空\n- 普通索引：无限制\n- 联合索引：多列组合\n- 全文索引：文本搜索\n\n**4. 索引失效场景：**\n- 使用!=或NOT IN\n- 使用函数或表达式\n- 使用LIKE '%xxx'\n- 类型不匹配\n- OR条件未全部命中索引\n\n**5. 覆盖索引：**\n- 查询所需字段都在索引中\n- 无需回表查询\n- 显著提升性能",
			[]string{"MySQL", "索引", "B-Tree"}, "进阶", "MySQL"},
		{"请描述Redis的持久化机制。", nil,
			"Redis提供两种持久化方式：RDB（快照）和AOF（追加日志）。RDB定期将内存数据写入磁盘，适合备份和灾难恢复。AOF记录所有写操作，重启时重放恢复数据，数据安全性更高。",
			"**深入解析：**\n\n**1. RDB持久化：**\n- 触发方式：定时自动、手动SAVE/BGSAVE\n- 优点：文件体积小、恢复速度快\n- 缺点：可能丢失最近数据\n- 适用场景：备份、灾难恢复\n\n**2. AOF持久化：**\n- 记录所有写命令到日志\n- 同步策略：always/everysec/no\n- 重写机制：压缩日志文件\n- 优点：数据安全，最多丢失1秒数据\n- 缺点：文件体积大、恢复慢\n\n**3. 混合持久化(Redis 4.0+)：**\n- RDB作为基础快照\n- AOF记录增量变化\n- 兼顾速度和安全性\n\n**4. 恢复策略：**\n- 优先加载AOF\n- AOF不存在时加载RDB\n- 同时开启时混合加载",
			[]string{"Redis", "持久化", "RDB", "AOF"}, "进阶", "Redis"},
		{"请说明Go语言中interface的实现原理。", nil,
			"Go语言的interface采用鸭子类型，不需要显式声明实现。底层使用iface结构存储类型信息和数据指针。空接口interface{}可以存储任何类型的值。",
			"**深入解析：**\n\n**1. iface结构：**\n- tab：指向itab，包含类型信息和方法表\n- data：指向实际数据的指针\n\n**2. itab结构：**\n- inter：接口类型信息\n- _type：实际类型信息\n- fun：方法指针数组\n\n**3. 类型断言：**\n- 安全断言：value, ok := x.(Type)\n- 类型选择：switch v := x.(type) {}\n\n**4. 性能优化：**\n- 避免频繁类型断言\n- 优先使用具体类型而非接口",
			[]string{"Go", "接口", "底层原理"}, "高级", "Go基础"},
		{"请描述分布式系统中的CAP理论。", nil,
			"CAP理论指出分布式系统不可能同时满足一致性(Consistency)、可用性(Availability)和分区容错性(Partition tolerance)三个特性。在网络分区发生时，必须在一致性和可用性之间做出选择。",
			"**深入解析：**\n\n**1. CAP三要素：**\n- C：一致性，所有节点看到相同的数据\n- A：可用性，任何请求都能获得响应\n- P：分区容错性，网络分区时系统继续运行\n\n**2. 权衡选择：**\n- CP：牺牲可用性保证一致性（如ZooKeeper）\n- AP：牺牲一致性保证可用性（如Redis集群）\n\n**3. BASE理论：**\n- 基本可用(Basically Available)\n- 软状态(Soft State)\n- 最终一致性(Eventually Consistent)",
			[]string{"分布式", "CAP", "理论"}, "高级", "架构"},
	}

	algoQuestions := []questionItem{
		{"实现一个函数，反转单链表。要求时间复杂度O(n)，空间复杂度O(1)。", nil,
			"```go\nfunc reverseList(head *ListNode) *ListNode {\n    var prev *ListNode\n    curr := head\n    for curr != nil {\n        nextTemp := curr.Next\n        curr.Next = prev\n        prev = curr\n        curr = nextTemp\n    }\n    return prev\n}\n```",
			"**深入解析：**\n\n**1. 算法思路：**\n- 使用三个指针：prev、curr、nextTemp\n- 遍历链表，逐个反转节点指向\n- 时间复杂度：O(n)\n- 空间复杂度：O(1)\n\n**2. 递归解法：**\n```go\nfunc reverseList(head *ListNode) *ListNode {\n    if head == nil || head.Next == nil {\n        return head\n    }\n    p := reverseList(head.Next)\n    head.Next.Next = head\n    head.Next = nil\n    return p\n}\n```\n\n**3. 关键点：**\n- 保存下一节点的引用\n- 防止链表断裂\n- 返回新的头节点\n\n**4. 扩展问题：**\n- 反转链表前N个节点\n- 反转链表的一部分\n- K个一组反转链表",
			[]string{"算法", "链表", "反转"}, "初级", "算法"},
		{"实现一个函数，判断两个字符串是否是异位词。", nil,
			"```go\nfunc isAnagram(s, t string) bool {\n    if len(s) != len(t) {\n        return false\n    }\n    count := make([]int, 26)\n    for i := 0; i < len(s); i++ {\n        count[s[i]-'a']++\n        count[t[i]-'a']--\n    }\n    for _, c := range count {\n        if c != 0 {\n            return false\n        }\n    }\n    return true\n}\n```",
			"**深入解析：**\n\n**1. 算法思路：**\n- 统计字符频率\n- 使用数组或哈希表\n- 比较两个字符串的频率\n\n**2. 复杂度分析：**\n- 时间：O(n)\n- 空间：O(1)（固定大小数组）\n\n**3. 扩展情况：**\n- 包含Unicode字符：使用map[rune]int\n- 大小写敏感/不敏感处理\n- 包含空格或特殊字符\n\n**4. 其他解法：**\n- 排序后比较：O(n log n)时间，O(1)空间\n- 使用哈希表：通用但空间稍大\n\n**5. 相关问题：**\n- 找到字符串中第一个不重复的字符\n- 最长无重复子串\n- 字符串排列",
			[]string{"算法", "字符串", "哈希表"}, "入门", "算法"},
		{"实现快速排序算法。要求平均时间复杂度O(n log n)。", nil,
			"```go\nfunc quickSort(nums []int) []int {\n    if len(nums) <= 1 {\n        return nums\n    }\n    pivot := nums[len(nums)/2]\n    var left, right, middle []int\n    for _, num := range nums {\n        if num < pivot {\n            left = append(left, num)\n        } else if num > pivot {\n            right = append(right, num)\n        } else {\n            middle = append(middle, num)\n        }\n    }\n    return append(append(quickSort(left), middle...), quickSort(right)...)\n}\n```",
			"**深入解析：**\n\n**1. 算法思想：**\n- 分治策略\n- 选择基准元素\n- 分区：小于/等于/大于基准\n- 递归处理左右分区\n\n**2. 复杂度分析：**\n- 平均时间：O(n log n)\n- 最坏时间：O(n²)（已排序数组）\n- 空间复杂度：O(log n)（递归栈）\n\n**3. 优化策略：**\n- 随机选择基准\n- 三数取中选择基准\n- 小数组使用插入排序\n- 尾递归优化\n\n**4. 原地排序实现：**\n```go\nfunc quickSortInPlace(nums []int, low, high int) {\n    if low < high {\n        pivot := partition(nums, low, high)\n        quickSortInPlace(nums, low, pivot-1)\n        quickSortInPlace(nums, pivot+1, high)\n    }\n}\n```",
			[]string{"算法", "排序", "快速排序"}, "中级", "算法"},
		{"实现一个LRU缓存。要求get和put操作时间复杂度O(1)。", nil,
			"```go\ntype LRUCache struct {\n    capacity int\n    cache    map[int]*Node\n    head     *Node\n    tail     *Node\n}\n\ntype Node struct {\n    key, val   int\n    prev, next *Node\n}\n\nfunc (c *LRUCache) Get(key int) int {\n    if node, ok := c.cache[key]; ok {\n        c.remove(node)\n        c.addToFront(node)\n        return node.val\n    }\n    return -1\n}\n\nfunc (c *LRUCache) Put(key, value int) {\n    if node, ok := c.cache[key]; ok {\n        node.val = value\n        c.remove(node)\n        c.addToFront(node)\n        return\n    }\n    if len(c.cache) == c.capacity {\n        delete(c.cache, c.tail.key)\n        c.remove(c.tail)\n    }\n    newNode := &Node{key: key, val: value}\n    c.cache[key] = newNode\n    c.addToFront(newNode)\n}\n```",
			"**深入解析：**\n\n**1. 数据结构：**\n- 哈希表：O(1)查找\n- 双向链表：O(1)删除和插入\n- 链表头部：最近使用\n- 链表尾部：最久未使用\n\n**2. 核心操作：**\n- Get：查找并移到头部\n- Put：插入头部，满时删除尾部\n- Remove：从链表中移除\n- AddToFront：添加到头部\n\n**3. 复杂度分析：**\n- Get：O(1)\n- Put：O(1)\n- 空间：O(capacity)\n\n**4. 扩展：LFU缓存**\n- 最少使用频率淘汰\n- 需要维护频率计数\n- 同频率按LRU淘汰",
			[]string{"算法", "缓存", "LRU"}, "进阶", "算法"},
		{"实现二叉树的层序遍历。", nil,
			"```go\nfunc levelOrder(root *TreeNode) [][]int {\n    var result [][]int\n    if root == nil {\n        return result\n    }\n    queue := []*TreeNode{root}\n    for len(queue) > 0 {\n        levelSize := len(queue)\n        var currentLevel []int\n        for i := 0; i < levelSize; i++ {\n            node := queue[0]\n            queue = queue[1:]\n            currentLevel = append(currentLevel, node.Val)\n            if node.Left != nil {\n                queue = append(queue, node.Left)\n            }\n            if node.Right != nil {\n                queue = append(queue, node.Right)\n            }\n        }\n        result = append(result, currentLevel)\n    }\n    return result\n}\n```",
			"**深入解析：**\n\n**1. 算法思路：**\n- 使用队列进行广度优先遍历\n- 按层处理节点\n- 记录每层节点数\n- 逐层收集结果\n\n**2. 复杂度分析：**\n- 时间：O(n)，每个节点访问一次\n- 空间：O(n)，最坏情况队列存储所有节点\n\n**3. 变体问题：**\n- 锯齿形层序遍历\n- 层序遍历从底向上\n- 每层最大值\n- 二叉树的右视图\n\n**4. 递归实现：**\n```go\nfunc levelOrderRecursive(root *TreeNode) [][]int {\n    var result [][]int\n    dfs(root, 0, &result)\n    return result\n}\n```",
			[]string{"算法", "二叉树", "层序遍历"}, "初级", "算法"},
		{"实现二分查找算法。", nil,
			"```go\nfunc binarySearch(nums []int, target int) int {\n    left, right := 0, len(nums)-1\n    for left <= right {\n        mid := left + (right-left)/2\n        if nums[mid] == target {\n            return mid\n        } else if nums[mid] < target {\n            left = mid + 1\n        } else {\n            right = mid - 1\n        }\n    }\n    return -1\n}\n```",
			"**深入解析：**\n\n**1. 算法思想：**\n- 分治策略\n- 有序数组前提\n- 每次排除一半元素\n\n**2. 复杂度分析：**\n- 时间：O(log n)\n- 空间：O(1)\n\n**3. 边界处理：**\n- 避免整数溢出：mid = left + (right-left)/2\n- 循环条件：left <= right\n\n**4. 变体问题：**\n- 查找第一个等于target的元素\n- 查找最后一个等于target的元素\n- 查找第一个大于等于target的元素",
			[]string{"算法", "二分查找"}, "入门", "算法"},
		{"实现合并两个有序链表。", nil,
			"```go\nfunc mergeTwoLists(l1, l2 *ListNode) *ListNode {\n    dummy := &ListNode{}\n    curr := dummy\n    for l1 != nil && l2 != nil {\n        if l1.Val < l2.Val {\n            curr.Next = l1\n            l1 = l1.Next\n        } else {\n            curr.Next = l2\n            l2 = l2.Next\n        }\n        curr = curr.Next\n    }\n    if l1 != nil {\n        curr.Next = l1\n    } else {\n        curr.Next = l2\n    }\n    return dummy.Next\n}\n```",
			"**深入解析：**\n\n**1. 算法思路：**\n- 虚拟头节点简化边界处理\n- 双指针遍历两个链表\n- 比较节点值，选择较小者\n\n**2. 复杂度分析：**\n- 时间：O(n+m)\n- 空间：O(1)\n\n**3. 递归解法：**\n```go\nfunc mergeTwoLists(l1, l2 *ListNode) *ListNode {\n    if l1 == nil { return l2 }\n    if l2 == nil { return l1 }\n    if l1.Val < l2.Val {\n        l1.Next = mergeTwoLists(l1.Next, l2)\n        return l1\n    }\n    l2.Next = mergeTwoLists(l1, l2.Next)\n    return l2\n}\n```",
			[]string{"算法", "链表", "合并"}, "初级", "算法"},
	}

	shuffleSlice := func(slice interface{}) {
		switch s := slice.(type) {
		case []questionItem:
			for i := len(s) - 1; i > 0; i-- {
				j := rand.Intn(i + 1)
				s[i], s[j] = s[j], s[i]
			}
		}
	}

	if containsType(selectedTypes, "mcq") {
		mcqFiltered := filterQuestionsByDifficulty(filterQuestionsByKeywords(mcqQuestions, techKeywords), difficultyLevel)
		shuffleSlice(mcqFiltered)
		for i := 0; i < 5 && i < len(mcqFiltered); i++ {
			mcq := mcqFiltered[i]
			questions = append(questions, map[string]interface{}{
				"type":       "mcq",
				"text":       mcq.question,
				"options":    mcq.options,
				"answer":     mcq.answer,
				"analysis":   mcq.analysis,
				"score":      getScoreByDifficulty(mcq.difficulty),
				"keywords":   mcq.keywords,
				"difficulty": mcq.difficulty,
				"category":   mcq.category,
			})
		}
	}

	if containsType(selectedTypes, "fill") {
		fillFiltered := filterQuestionsByDifficulty(filterQuestionsByKeywords(fillQuestions, techKeywords), difficultyLevel)
		shuffleSlice(fillFiltered)
		for i := 0; i < 5 && i < len(fillFiltered); i++ {
			fill := fillFiltered[i]
			questions = append(questions, map[string]interface{}{
				"type":       "fill",
				"text":       fill.question,
				"answer":     fill.answer,
				"analysis":   fill.analysis,
				"score":      getScoreByDifficulty(fill.difficulty),
				"keywords":   fill.keywords,
				"difficulty": fill.difficulty,
				"category":   fill.category,
			})
		}
	}

	if containsType(selectedTypes, "sa") {
		saFiltered := filterQuestionsByDifficulty(filterQuestionsByKeywords(saQuestions, techKeywords), difficultyLevel)
		shuffleSlice(saFiltered)
		for i := 0; i < 5 && i < len(saFiltered); i++ {
			sa := saFiltered[i]
			questions = append(questions, map[string]interface{}{
				"type":       "sa",
				"text":       sa.question,
				"answer":     sa.answer,
				"analysis":   sa.analysis,
				"score":      getScoreByDifficulty(sa.difficulty),
				"keywords":   sa.keywords,
				"difficulty": sa.difficulty,
				"category":   sa.category,
			})
		}
	}

	if containsType(selectedTypes, "algo") {
		algoFiltered := filterQuestionsByDifficulty(filterQuestionsByKeywords(algoQuestions, techKeywords), difficultyLevel)
		shuffleSlice(algoFiltered)
		for i := 0; i < 5 && i < len(algoFiltered); i++ {
			algo := algoFiltered[i]
			questions = append(questions, map[string]interface{}{
				"type":       "algo",
				"text":       algo.question,
				"answer":     algo.answer,
				"analysis":   algo.analysis,
				"score":      getScoreByDifficulty(algo.difficulty),
				"keywords":   algo.keywords,
				"difficulty": algo.difficulty,
				"category":   algo.category,
			})
		}
	}

	return questions
}

func getScoreByDifficulty(difficulty string) int {
	switch difficulty {
	case "入门":
		return 5
	case "初级":
		return 10
	case "中级":
		return 15
	case "进阶":
		return 20
	case "高级":
		return 25
	default:
		return 10
	}
}

func parseTypes(typesStr string) []string {
	if typesStr == "" {
		return []string{"mcq", "fill", "sa", "algo"}
	}
	return strings.Split(typesStr, ",")
}

func containsType(types []string, t string) bool {
	for _, tp := range types {
		if tp == t {
			return true
		}
	}
	return false
}

type questionItem struct {
	question   string
	options    []string
	answer     string
	analysis   string
	keywords   []string
	difficulty string
	category   string
}

func extractPosition(resumeText string, keywords []string) string {
	positionKeywords := map[string][]string{
		"高级工程师": {"高级", "资深", "architect", "架构师", "技术负责人", "tech lead", "lead"},
		"中级工程师": {"中级", "工程师", "developer", "software engineer", "全栈"},
		"初级工程师": {"初级", "助理", "实习生", "junior", "graduate", "entry"},
	}

	resumeLower := strings.ToLower(resumeText)

	for position, keywords := range positionKeywords {
		for _, kw := range keywords {
			if strings.Contains(resumeLower, strings.ToLower(kw)) {
				return position
			}
		}
	}

	for _, kw := range keywords {
		if strings.Contains(strings.ToLower(kw), "架构") || strings.Contains(strings.ToLower(kw), "架构师") {
			return "高级工程师"
		}
	}

	return "中级工程师"
}

func getDifficultyByPosition(position string) string {
	switch position {
	case "高级工程师":
		return "高级"
	case "中级工程师":
		return "中级"
	case "初级工程师":
		return "初级"
	default:
		return "中级"
	}
}

func filterQuestionsByDifficulty(questions []questionItem, minDifficulty string) []questionItem {
	difficultyOrder := map[string]int{
		"入门": 0,
		"初级": 1,
		"中级": 2,
		"进阶": 3,
		"高级": 4,
	}

	minLevel := difficultyOrder[minDifficulty]
	var filtered []questionItem

	for _, q := range questions {
		if difficultyOrder[q.difficulty] >= minLevel {
			filtered = append(filtered, q)
		}
	}

	if len(filtered) == 0 {
		return questions
	}

	return filtered
}

// keywordAliases 关键词别名映射表，扩展用户输入的关键词以提高匹配命中率
// 例如：用户输入 "React" 时，同时匹配 "前端"、"JavaScript" 等相关关键词
var keywordAliases = map[string][]string{
	"go":         {"go", "golang", "goroutine", "channel", "defer", "make", "const", "var", "interface", "gomaxprocs", "panic", "recover", "new"},
	"golang":     {"go", "golang", "goroutine", "channel", "defer", "make", "interface"},
	"java":       {"java", "jvm", "spring", "maven", "gradle", "jdk", "jre"},
	"python":     {"python", "django", "flask", "pandas", "numpy"},
	"javascript": {"javascript", "js", "es6", "promise", "async", "await"},
	"typescript": {"typescript", "ts", "javascript", "js"},
	"react":      {"react", "jsx", "tsx", "hooks", "redux", "前端", "javascript"},
	"vue":        {"vue", "vuex", "vuejs", "前端", "javascript"},
	"mysql":      {"mysql", "sql", "数据库", "innodb", "事务", "索引", "acid"},
	"redis":      {"redis", "缓存", "rdb", "aof", "sorted set", "ttl"},
	"docker":     {"docker", "容器", "镜像", "dockerfile"},
	"kubernetes": {"kubernetes", "k8s", "pod", "replicaset", "container"},
	"k8s":        {"kubernetes", "k8s", "pod", "replicaset"},
	"微服务":        {"微服务", "架构", "rest", "api", "服务发现", "分布式"},
	"分布式":        {"分布式", "cap", "微服务", "一致性", "raft", "paxos"},
	"网络":         {"网络", "tcp", "http", "https", "tcp/ip", "osi"},
	"http":       {"http", "https", "rest", "api", "状态码"},
	"https":      {"https", "http", "ssl", "tls"},
	"算法":         {"算法", "链表", "二叉树", "排序", "查找", "二分查找", "快速排序", "lru"},
	"html":       {"html", "html5", "前端", "表单"},
	"html5":      {"html5", "html", "前端"},
	"css":        {"css", "flexbox", "rem", "选择器", "前端"},
	"git":        {"git", "版本控制", "分支"},
	"api":        {"api", "rest", "restful", "接口"},
	"rest":       {"rest", "restful", "api", "http"},
	"tcp":        {"tcp", "网络", "osi", "三次握手"},
}

// expandKeywords 扩展关键词列表，加入别名
func expandKeywords(keywords []string) []string {
	seen := make(map[string]bool)
	var expanded []string
	for _, kw := range keywords {
		kwLower := strings.ToLower(strings.TrimSpace(kw))
		if kwLower == "" {
			continue
		}
		if !seen[kwLower] {
			seen[kwLower] = true
			expanded = append(expanded, kwLower)
		}
		if aliases, ok := keywordAliases[kwLower]; ok {
			for _, alias := range aliases {
				if !seen[alias] {
					seen[alias] = true
					expanded = append(expanded, alias)
				}
			}
		}
	}
	return expanded
}

func filterQuestionsByKeywords(questions []questionItem, keywords []string) []questionItem {
	if len(keywords) == 0 {
		return questions
	}

	expandedKeywords := expandKeywords(keywords)
	if len(expandedKeywords) == 0 {
		return questions
	}

	var filtered []questionItem
	for _, q := range questions {
		matched := false
		for _, qkw := range q.keywords {
			qkwLower := strings.ToLower(qkw)
			for _, kw := range expandedKeywords {
				if qkwLower == kw || strings.Contains(qkwLower, kw) || strings.Contains(kw, qkwLower) {
					filtered = append(filtered, q)
					matched = true
					break
				}
			}
			if matched {
				break
			}
		}
	}

	// 严格过滤：未匹配时返回空切片，由调用方处理（GenerateQuestions 会返回"未找到与关键词匹配的题目"）
	return filtered
}

func (t *KeywordExtractTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
	return &schema.ToolInfo{
		Name: "extract_keywords",
		Desc: "从简历文本中提取关键词，包括技术栈、技能、行业术语等。输入简历文本，返回结构化的关键词列表。",
		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
			"text": {
				Desc:     "简历文本内容",
				Required: true,
				Type:     schema.String,
			},
			"category": {
				Desc: "提取类别：all（全部）、tech（技术栈）、skill（技能）、industry（行业术语）、soft（软技能）",
				Type: schema.String,
				Enum: []string{"all", "tech", "skill", "industry", "soft"},
			},
		}),
	}, nil
}

func (t *KeywordExtractTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
	var args struct {
		Text     string `json:"text"`
		Category string `json:"category"`
	}

	if err := json.Unmarshal([]byte(argumentsInJSON), &args); err != nil {
		return "", fmt.Errorf("failed to unmarshal arguments: %w", err)
	}

	if args.Text == "" {
		return "", fmt.Errorf("text is required")
	}

	if args.Category == "" {
		args.Category = "all"
	}

	techStack := extractTechKeywords(args.Text)
	skills := extractSkillKeywords(args.Text)
	industryTerms := extractIndustryKeywords(args.Text)
	softSkills := extractSoftSkillKeywords(args.Text)

	result := fmt.Sprintf(`{"tech_stack": %s, "skills": %s, "industry_terms": %s, "soft_skills": %s}`,
		toJSONArray(techStack),
		toJSONArray(skills),
		toJSONArray(industryTerms),
		toJSONArray(softSkills),
	)

	return result, nil
}

func toJSONArray(items []string) string {
	if len(items) == 0 {
		return "[]"
	}
	result := "["
	for i, item := range items {
		if i > 0 {
			result += ","
		}
		result += fmt.Sprintf(`"%s"`, escapeJSON(item))
	}
	result += "]"
	return result
}

func extractTechKeywords(text string) []string {
	techPatterns := []string{"Go", "Golang", "Java", "Python", "JavaScript", "TypeScript", "React", "Vue", "MySQL", "PostgreSQL", "Redis", "MongoDB", "Kafka", "Docker", "Kubernetes", "微服务", "分布式"}
	return extractKeywords(text, techPatterns)
}

func extractSkillKeywords(text string) []string {
	skillPatterns := []string{"开发", "设计", "架构", "优化", "重构", "测试", "部署", "运维", "监控", "调优"}
	return extractKeywords(text, skillPatterns)
}

func extractIndustryKeywords(text string) []string {
	industryPatterns := []string{"互联网", "金融", "电商", "医疗", "教育", "云计算", "大数据", "人工智能", "物联网"}
	return extractKeywords(text, industryPatterns)
}

func extractSoftSkillKeywords(text string) []string {
	softPatterns := []string{"沟通", "团队协作", "项目管理", "问题解决", "创新", "学习能力", "抗压能力", "责任心"}
	return extractKeywords(text, softPatterns)
}

func extractKeywords(text string, patterns []string) []string {
	var result []string
	for _, pattern := range patterns {
		if strings.Contains(text, pattern) {
			result = append(result, pattern)
		}
	}
	return result
}