package handlers

import (
	"ankao/internal/models"
	"math/rand"
	"net/http"
	"strconv"
	"sync"

	"github.com/gin-gonic/gin"
)

// 用于存储答题记录的简单内存存储
var (
	userAnswers = make(map[int]interface{})
	mu          sync.RWMutex
)

// GetQuestions 获取题目列表
func GetQuestions(c *gin.Context) {
	questionType := c.Query("type")
	category := c.Query("category")

	questions := GetTestQuestions()

	// 过滤题目
	var filtered []models.Question
	for _, q := range questions {
		if questionType != "" && string(q.Type) != questionType {
			continue
		}
		if category != "" && q.Category != category {
			continue
		}
		filtered = append(filtered, q)
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    filtered,
		"total":   len(filtered),
	})
}

// GetQuestionByID 获取单个题目
func GetQuestionByID(c *gin.Context) {
	idStr := c.Param("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "无效的题目ID",
		})
		return
	}

	questions := GetTestQuestions()
	for _, q := range questions {
		if q.ID == id {
			c.JSON(http.StatusOK, gin.H{
				"success": true,
				"data":    q,
			})
			return
		}
	}

	c.JSON(http.StatusNotFound, gin.H{
		"success": false,
		"message": "题目不存在",
	})
}

// GetRandomQuestion 获取随机题目
func GetRandomQuestion(c *gin.Context) {
	questions := GetTestQuestions()
	if len(questions) == 0 {
		c.JSON(http.StatusNotFound, gin.H{
			"success": false,
			"message": "暂无题目",
		})
		return
	}

	randomQuestion := questions[rand.Intn(len(questions))]
	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    randomQuestion,
	})
}

// SubmitAnswer 提交答案
func SubmitAnswer(c *gin.Context) {
	var submit models.SubmitAnswer
	if err := c.ShouldBindJSON(&submit); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{
			"success": false,
			"message": "请求参数错误",
		})
		return
	}

	// 查找题目
	questions := GetTestQuestions()
	var targetQuestion *models.Question
	for i := range questions {
		if questions[i].ID == submit.QuestionID {
			targetQuestion = &questions[i]
			break
		}
	}

	if targetQuestion == nil {
		c.JSON(http.StatusNotFound, gin.H{
			"success": false,
			"message": "题目不存在",
		})
		return
	}

	// 验证答案
	correct := checkAnswer(targetQuestion, submit.Answer)

	// 保存答题记录
	mu.Lock()
	userAnswers[submit.QuestionID] = submit.Answer
	mu.Unlock()

	result := models.AnswerResult{
		Correct:       correct,
		CorrectAnswer: targetQuestion.Answer,
		Explanation:   getExplanation(targetQuestion.ID),
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    result,
	})
}

// GetStatistics 获取统计数据
func GetStatistics(c *gin.Context) {
	mu.RLock()
	answeredCount := len(userAnswers)
	mu.RUnlock()

	questions := GetTestQuestions()
	totalCount := len(questions)

	// 计算正确答案数
	correctCount := 0
	mu.RLock()
	for qid, userAns := range userAnswers {
		for i := range questions {
			if questions[i].ID == qid {
				if checkAnswer(&questions[i], userAns) {
					correctCount++
				}
				break
			}
		}
	}
	mu.RUnlock()

	accuracy := 0.0
	if answeredCount > 0 {
		accuracy = float64(correctCount) / float64(answeredCount) * 100
	}

	stats := models.Statistics{
		TotalQuestions:    totalCount,
		AnsweredQuestions: answeredCount,
		CorrectAnswers:    correctCount,
		Accuracy:          accuracy,
	}

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"data":    stats,
	})
}

// ResetProgress 重置答题进度
func ResetProgress(c *gin.Context) {
	mu.Lock()
	userAnswers = make(map[int]interface{})
	mu.Unlock()

	c.JSON(http.StatusOK, gin.H{
		"success": true,
		"message": "答题进度已重置",
	})
}

// checkAnswer 检查答案是否正确
func checkAnswer(question *models.Question, userAnswer interface{}) bool {
	switch question.Type {
	case models.SingleChoice, models.TrueFalse:
		// 单选和判断题：字符串比较
		return userAnswer == question.Answer

	case models.MultipleChoice:
		// 多选题：数组比较
		userArr, ok1 := userAnswer.([]interface{})
		correctArr, ok2 := question.Answer.([]string)
		if !ok1 || !ok2 {
			return false
		}
		if len(userArr) != len(correctArr) {
			return false
		}
		// 转换为map进行比较
		userMap := make(map[string]bool)
		for _, v := range userArr {
			if str, ok := v.(string); ok {
				userMap[str] = true
			}
		}
		for _, v := range correctArr {
			if !userMap[v] {
				return false
			}
		}
		return true

	case models.FillBlank:
		// 填空题：字符串比较（忽略大小写和空格）
		userStr, ok := userAnswer.(string)
		if !ok {
			return false
		}
		correctStr, ok := question.Answer.(string)
		if !ok {
			return false
		}
		return userStr == correctStr
	}

	return false
}

// getExplanation 获取答案解析
func getExplanation(questionID int) string {
	explanations := map[int]string{
		1:  "根据国家保密局规定，涉密信息系统集成资质分为甲级、乙级、丙级三个等级。",
		2:  "涉密信息系统集成资质由国家保密局认证管理，负责资质的审批和监督。",
		3:  "涉密信息系统集成资质证书有效期为3年，有效期满需要重新申请认证。",
		4:  "涉密人员管理包括保密教育培训、保密协议签订、离岗离职审查和保密审查等内容。",
		5:  "涉密信息系统集成单位应当具有独立法人资格、固定办公场所、保密管理制度和保密管理人员。",
		6:  "涉密载体管理包括登记标识、使用保管、复制传递、维修销毁等全生命周期管理。",
		7:  "涉密信息系统集成资质单位只能承担本单位资质等级及以下的涉密信息系统集成业务，不得超越资质等级承揽项目。",
		8:  "保密要害部门部位人员关系到国家秘密安全，必须经过严格的保密审查才能上岗。",
		9:  "涉密人员离岗离职后需要经过脱密期管理，期间不得擅自出境，防止泄露国家秘密。",
		10: "涉密信息系统集成资质等级包括甲级、乙级、丙级三个等级，甲级最高，丙级最低。",
		11: "国家秘密密级分为绝密、机密、秘密三级，绝密级最高，秘密级最低。",
		12: "涉密人员上岗前必须经过保密教育培训，提高保密意识，并签订保密承诺书。",
		13: "涉密场所应当采取物理防护、技术防护等措施，防止国家秘密泄露。",
		14: "涉密信息系统应当按照国家保密标准要求进行分级保护，确保信息安全。",
		15: "根据《保密法》规定，涉密人员脱密期最长不超过3年。",
		16: "涉密计算机及移动存储介质应当按照所存储信息的最高密级粘贴密级标识。",
		17: "甲级资质单位可以承担绝密级、机密级和秘密级的涉密信息系统集成业务。",
		18: "涉密载体的复制应当经过审批并进行详细登记，防止失控泄密。",
		19: "涉密会议场所应当采取信号屏蔽、安全检查等保密防护措施。",
		20: "涉密业务不得分包给非资质单位，防止国家秘密泄露。",
	}
	return explanations[questionID]
}