package handler

import (
	"encoding/json"
	"fmt"
	"resume-platform/internal/model"
	"resume-platform/internal/service/knowledge"

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

type KnowledgeHandler struct {
	knowledgeBaseService *knowledge.KnowledgeBaseService
	ragService           *knowledge.RAGService
}

func NewKnowledgeHandler(knowledgeBaseService *knowledge.KnowledgeBaseService, ragService *knowledge.RAGService) *KnowledgeHandler {
	return &KnowledgeHandler{knowledgeBaseService: knowledgeBaseService, ragService: ragService}
}

func (h *KnowledgeHandler) Search(c *gin.Context) {
	query := c.Query("q")
	topK := 5
	if k := c.Query("k"); k != "" {
		fmt.Sscanf(k, "%d", &topK)
	}
	userID := c.GetHeader("X-User-ID")

	if query == "" {
		BadRequest(c, "Query parameter is required")
		return
	}

	results, err := h.knowledgeBaseService.Retrieve(c.Request.Context(), query, topK, userID)
	if err != nil {
		Error(c, err.Error())
		return
	}

	OK(c, results)
}

func (h *KnowledgeHandler) GetStats(c *gin.Context) {
	userID := c.GetHeader("X-User-ID")

	stats, err := h.knowledgeBaseService.GetStats(c.Request.Context(), userID)
	if err != nil {
		Error(c, err.Error())
		return
	}

	OK(c, stats)
}

func (h *KnowledgeHandler) AddDocument(c *gin.Context) {
	var req struct {
		DocumentID string `json:"document_id"`
		Content    string `json:"content"`
		UserID     string `json:"user_id"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		BadRequest(c, "Invalid request body")
		return
	}

	if req.DocumentID == "" || req.Content == "" {
		BadRequest(c, "document_id and content are required")
		return
	}

	err := h.knowledgeBaseService.AddDocument(c.Request.Context(), req.DocumentID, req.Content, req.UserID)
	if err != nil {
		Error(c, err.Error())
		return
	}

	OK(c, gin.H{"message": "Document added to knowledge base successfully"})
}

func (h *KnowledgeHandler) AddResume(c *gin.Context) {
	var req struct {
		ResumeID string                 `json:"resume_id"`
		Resume   map[string]interface{} `json:"resume"`
		UserID   string                 `json:"user_id"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		BadRequest(c, "Invalid request body")
		return
	}

	if req.ResumeID == "" {
		BadRequest(c, "resume_id is required")
		return
	}

	resumeJSON, _ := json.Marshal(req.Resume)
	var resume model.Resume
	if err := json.Unmarshal(resumeJSON, &resume); err != nil {
		BadRequest(c, "Invalid resume format")
		return
	}

	resume.ID = req.ResumeID
	resume.UserID = req.UserID

	err := h.knowledgeBaseService.AddResume(c.Request.Context(), req.ResumeID, &resume)
	if err != nil {
		Error(c, err.Error())
		return
	}

	OK(c, gin.H{"message": "Resume added to knowledge base successfully"})
}

func (h *KnowledgeHandler) AddText(c *gin.Context) {
	var req struct {
		Text       string `json:"text"`
		SourceType string `json:"source_type"`
		SourceID   string `json:"source_id"`
		SourceName string `json:"source_name"`
		UserID     string `json:"user_id"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		BadRequest(c, "Invalid request body")
		return
	}

	if req.Text == "" || req.SourceType == "" {
		BadRequest(c, "text and source_type are required")
		return
	}

	err := h.knowledgeBaseService.AddText(c.Request.Context(), req.Text, req.SourceType, req.SourceID, req.SourceName, req.UserID)
	if err != nil {
		Error(c, err.Error())
		return
	}

	OK(c, gin.H{"message": "Text added to knowledge base successfully"})
}

func (h *KnowledgeHandler) Chat(c *gin.Context) {
	var req struct {
		Query  string `json:"query"`
		UserID string `json:"user_id"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		BadRequest(c, "Invalid request body")
		return
	}

	if req.Query == "" {
		BadRequest(c, "query is required")
		return
	}

	result, err := h.ragService.Generate(c.Request.Context(), req.Query, req.UserID)
	if err != nil {
		Error(c, err.Error())
		return
	}

	OK(c, gin.H{"answer": result})
}