package handlers

import (
	"net/http"
	"strconv"

	"goalfymax-admin/internal/storage"
	"goalfymax-admin/pkg/utils"

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

type MCPProvider struct {
	ID            uuid.UUID `json:"id" gorm:"type:uuid;primaryKey"`
	Provider      string    `json:"provider"`
	BaseURL       string    `json:"base_url"`
	Auth          *string   `json:"auth"`
	Account       *string   `json:"account"`
	PriceType     string    `json:"price_type"`
	Price         float64   `json:"price"`
	FloatingRatio float64   `json:"floating_ratio"`
	IsUsed        bool      `json:"is_used"`
	Status        string    `json:"status"`
	Description   *string   `json:"description"`
	CreatedAt     string    `json:"created_at"`
	UpdatedAt     string    `json:"updated_at"`
}

type MCPProviderHandler struct {
	response *utils.Response
}

func NewMCPProviderHandler() *MCPProviderHandler {
	return &MCPProviderHandler{response: utils.NewResponse()}
}

func (h *MCPProviderHandler) List(c *gin.Context) {
	db := storage.GetPG()
	if db == nil {
		c.JSON(http.StatusInternalServerError, gin.H{"message": "PostgreSQL未初始化"})
		return
	}

	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	size, _ := strconv.Atoi(c.DefaultQuery("size", "10"))
	if page <= 0 {
		page = 1
	}
	if size <= 0 {
		size = 10
	}
	offset := (page - 1) * size

	q := db.Table("mcp_providers")
	if v := c.Query("provider"); v != "" {
		q = q.Where("provider ILIKE ?", "%"+v+"%")
	}
	if v := c.Query("status"); v != "" {
		q = q.Where("status = ?", v)
	}
	if v := c.Query("is_used"); v != "" {
		if v == "true" {
			q = q.Where("is_used = ?", true)
		} else if v == "false" {
			q = q.Where("is_used = ?", false)
		}
	}

	var total int64
	if err := q.Count(&total).Error; err != nil {
		h.response.InternalServerError(c, err.Error())
		return
	}
	var list []MCPProvider
	if err := q.Order("created_at DESC").Offset(offset).Limit(size).Find(&list).Error; err != nil {
		h.response.InternalServerError(c, err.Error())
		return
	}
	h.response.Page(c, list, total, page, size)
}

func (h *MCPProviderHandler) GetByID(c *gin.Context) {
	db := storage.GetPG()
	id, err := uuid.Parse(c.Param("id"))
	if err != nil {
		h.response.BadRequest(c, "无效ID")
		return
	}
	var m MCPProvider
	if err := db.Table("mcp_providers").Where("id = ?", id).First(&m).Error; err != nil {
		h.response.NotFound(c, "记录不存在")
		return
	}
	h.response.Success(c, m)
}

func (h *MCPProviderHandler) Create(c *gin.Context) {
	db := storage.GetPG()
	var req map[string]any
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.BadRequest(c, err.Error())
		return
	}
	if err := db.Table("mcp_providers").Create(req).Error; err != nil {
		h.response.InternalServerError(c, err.Error())
		return
	}
	h.response.Success(c, "创建成功")
}

func (h *MCPProviderHandler) Update(c *gin.Context) {
	db := storage.GetPG()
	id, err := uuid.Parse(c.Param("id"))
	if err != nil {
		h.response.BadRequest(c, "无效ID")
		return
	}
	var req map[string]any
	if err := c.ShouldBindJSON(&req); err != nil {
		h.response.BadRequest(c, err.Error())
		return
	}
	delete(req, "id")
	if err := db.Table("mcp_providers").Where("id = ?", id).Updates(req).Error; err != nil {
		h.response.InternalServerError(c, err.Error())
		return
	}
	h.response.Success(c, "更新成功")
}

func (h *MCPProviderHandler) Delete(c *gin.Context) {
	db := storage.GetPG()
	id, err := uuid.Parse(c.Param("id"))
	if err != nil {
		h.response.BadRequest(c, "无效ID")
		return
	}
	if err := db.Table("mcp_providers").Where("id = ?", id).Delete(nil).Error; err != nil {
		h.response.InternalServerError(c, err.Error())
		return
	}
	h.response.Success(c, "删除成功")
}

func (h *MCPProviderHandler) UpdateStatus(c *gin.Context) {
	db := storage.GetPG()
	id, err := uuid.Parse(c.Param("id"))
	if err != nil {
		h.response.BadRequest(c, "无效ID")
		return
	}
	var body struct {
		Status string `json:"status" binding:"required"`
	}
	if err := c.ShouldBindJSON(&body); err != nil {
		h.response.BadRequest(c, err.Error())
		return
	}
	if err := db.Table("mcp_providers").Where("id = ?", id).Update("status", body.Status).Error; err != nil {
		h.response.InternalServerError(c, err.Error())
		return
	}
	h.response.Success(c, "状态更新成功")
}

func (h *MCPProviderHandler) UpdateIsUsed(c *gin.Context) {
	db := storage.GetPG()
	id, err := uuid.Parse(c.Param("id"))
	if err != nil {
		h.response.BadRequest(c, "无效ID")
		return
	}
	var body struct {
		IsUsed bool `json:"is_used" binding:"required"`
	}
	if err := c.ShouldBindJSON(&body); err != nil {
		h.response.BadRequest(c, err.Error())
		return
	}
	if err := db.Table("mcp_providers").Where("id = ?", id).Update("is_used", body.IsUsed).Error; err != nil {
		h.response.InternalServerError(c, err.Error())
		return
	}
	h.response.Success(c, "使用状态更新成功")
}