package handlers

import (
	"encoding/json"
	"net/http"
	"strconv"

	"ezops/internal/models"

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

// AlertHandler 告警处理器
type AlertHandler struct {
	db *gorm.DB
}

// NewAlertHandler 创建告警处理器
func NewAlertHandler(db *gorm.DB) *AlertHandler {
	return &AlertHandler{db: db}
}

// ListAlerts 获取告警事件列表
// @Summary 获取告警事件列表
// @Description 获取所有告警事件列表
// @Tags 告警
// @Produce json
// @Security Bearer
// @Param page query int false "页码"
// @Param page_size query int false "每页数量"
// @Param status query string false "状态过滤"
// @Param severity query string false "级别过滤"
// @Success 200 {object} models.Response{data=models.ListResponse}
// @Router /alerts [get]
func (h *AlertHandler) ListAlerts(c *gin.Context) {
	var query models.PageQuery
	c.ShouldBindQuery(&query)

	db := h.db.Model(&models.AlertEvent{}).Preload("Rule")

	// 状态过滤
	if status := c.Query("status"); status != "" {
		db = db.Where("status = ?", status)
	}

	// 级别过滤
	if severity := c.Query("severity"); severity != "" {
		db = db.Where("severity = ?", severity)
	}

	var total int64
	db.Count(&total)

	var alerts []models.AlertEvent
	db.Order("created_at DESC").
		Offset(query.GetOffset()).
		Limit(query.GetLimit()).
		Find(&alerts)

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "success",
		Data: models.ListResponse{
			List:  alerts,
			Total: total,
		},
	})
}

// ListRules 获取告警规则列表
// @Summary 获取告警规则列表
// @Description 获取所有告警规则列表
// @Tags 告警
// @Produce json
// @Security Bearer
// @Param page query int false "页码"
// @Param page_size query int false "每页数量"
// @Success 200 {object} models.Response{data=models.ListResponse}
// @Router /alerts/rules [get]
func (h *AlertHandler) ListRules(c *gin.Context) {
	var query models.PageQuery
	c.ShouldBindQuery(&query)

	var total int64
	h.db.Model(&models.AlertRule{}).Count(&total)

	var rules []models.AlertRule
	h.db.Offset(query.GetOffset()).Limit(query.GetLimit()).Find(&rules)

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "success",
		Data: models.ListResponse{
			List:  rules,
			Total: total,
		},
	})
}

// CreateRule 创建告警规则
// @Summary 创建告警规则
// @Description 创建新告警规则
// @Tags 告警
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body models.CreateAlertRuleRequest true "创建请求"
// @Success 200 {object} models.Response{data=models.AlertRule}
// @Router /alerts/rules [post]
func (h *AlertHandler) CreateRule(c *gin.Context) {
	var req models.CreateAlertRuleRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, models.Response{
			Code:    400,
			Message: "请求参数错误: " + err.Error(),
		})
		return
	}

	rule := models.AlertRule{
		Name:           req.Name,
		Description:    req.Description,
		Type:           req.Type,
		Source:         req.Source,
		Expression:     req.Expression,
		Severity:       req.Severity,
		Duration:       req.Duration,
		Labels:         req.Labels,
		Annotations:    req.Annotations,
		NotifyChannels: toJSON(req.NotifyChannels),
		Enabled:        true,
	}

	if err := h.db.Create(&rule).Error; err != nil {
		c.JSON(http.StatusInternalServerError, models.Response{
			Code:    500,
			Message: "创建失败",
		})
		return
	}

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "创建成功",
		Data:    rule,
	})
}

// UpdateRule 更新告警规则
// @Summary 更新告警规则
// @Description 更新指定告警规则
// @Tags 告警
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "规则ID"
// @Param request body models.UpdateAlertRuleRequest true "更新请求"
// @Success 200 {object} models.Response{data=models.AlertRule}
// @Router /alerts/rules/{id} [put]
func (h *AlertHandler) UpdateRule(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	var req models.UpdateAlertRuleRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, models.Response{
			Code:    400,
			Message: "请求参数错误: " + err.Error(),
		})
		return
	}

	var rule models.AlertRule
	if err := h.db.First(&rule, id).Error; err != nil {
		c.JSON(http.StatusNotFound, models.Response{
			Code:    404,
			Message: "规则不存在",
		})
		return
	}

	updates := map[string]interface{}{}
	if req.Name != "" {
		updates["name"] = req.Name
	}
	if req.Description != "" {
		updates["description"] = req.Description
	}
	if req.Expression != "" {
		updates["expression"] = req.Expression
	}
	if req.Severity != "" {
		updates["severity"] = req.Severity
	}
	if req.Duration > 0 {
		updates["duration"] = req.Duration
	}
	if req.Labels != "" {
		updates["labels"] = req.Labels
	}
	if req.Annotations != "" {
		updates["annotations"] = req.Annotations
	}
	if len(req.NotifyChannels) > 0 {
		updates["notify_channels"] = toJSON(req.NotifyChannels)
	}
	if req.Enabled != nil {
		updates["enabled"] = *req.Enabled
	}

	if err := h.db.Model(&rule).Updates(updates).Error; err != nil {
		c.JSON(http.StatusInternalServerError, models.Response{
			Code:    500,
			Message: "更新失败",
		})
		return
	}

	h.db.First(&rule, id)

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "更新成功",
		Data:    rule,
	})
}

// DeleteRule 删除告警规则
// @Summary 删除告警规则
// @Description 删除指定告警规则
// @Tags 告警
// @Produce json
// @Security Bearer
// @Param id path int true "规则ID"
// @Success 200 {object} models.Response
// @Router /alerts/rules/{id} [delete]
func (h *AlertHandler) DeleteRule(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	if err := h.db.Delete(&models.AlertRule{}, id).Error; err != nil {
		c.JSON(http.StatusInternalServerError, models.Response{
			Code:    500,
			Message: "删除失败",
		})
		return
	}

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "删除成功",
	})
}

// ToggleRule 切换告警规则状态
// @Summary 切换告警规则状态
// @Description 启用或禁用告警规则
// @Tags 告警
// @Produce json
// @Security Bearer
// @Param id path int true "规则ID"
// @Success 200 {object} models.Response{data=models.AlertRule}
// @Router /alerts/rules/{id}/toggle [post]
func (h *AlertHandler) ToggleRule(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	var rule models.AlertRule
	if err := h.db.First(&rule, id).Error; err != nil {
		c.JSON(http.StatusNotFound, models.Response{
			Code:    404,
			Message: "规则不存在",
		})
		return
	}

	rule.Enabled = !rule.Enabled
	if err := h.db.Save(&rule).Error; err != nil {
		c.JSON(http.StatusInternalServerError, models.Response{
			Code:    500,
			Message: "操作失败",
		})
		return
	}

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "操作成功",
		Data:    rule,
	})
}

// AcknowledgeAlert 确认告警
// @Summary 确认告警
// @Description 确认告警事件
// @Tags 告警
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "告警ID"
// @Param request body models.AcknowledgeAlertRequest true "确认请求"
// @Success 200 {object} models.Response{data=models.AlertEvent}
// @Router /alerts/{id}/ack [post]
func (h *AlertHandler) AcknowledgeAlert(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	var req models.AcknowledgeAlertRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, models.Response{
			Code:    400,
			Message: "请求参数错误",
		})
		return
	}

	var alert models.AlertEvent
	if err := h.db.First(&alert, id).Error; err != nil {
		c.JSON(http.StatusNotFound, models.Response{
			Code:    404,
			Message: "告警不存在",
		})
		return
	}

	alert.Acknowledged = true
	// alert.AcknowledgedBy = middleware.GetUserID(c)
	// now := time.Now()
	// alert.AcknowledgedAt = &now

	if err := h.db.Save(&alert).Error; err != nil {
		c.JSON(http.StatusInternalServerError, models.Response{
			Code:    500,
			Message: "确认失败",
		})
		return
	}

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "确认成功",
		Data:    alert,
	})
}

// ListNotifyChannels 获取通知渠道列表
// @Summary 获取通知渠道列表
// @Description 获取所有通知渠道列表
// @Tags 告警
// @Produce json
// @Security Bearer
// @Success 200 {object} models.Response{data=models.ListResponse}
// @Router /alerts/notify-channels [get]
func (h *AlertHandler) ListNotifyChannels(c *gin.Context) {
	var channels []models.NotifyChannel
	h.db.Order("created_at DESC").Find(&channels)

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "success",
		Data: models.ListResponse{
			List:  channels,
			Total: int64(len(channels)),
		},
	})
}

// CreateNotifyChannel 创建通知渠道
// @Summary 创建通知渠道
// @Description 创建新通知渠道
// @Tags 告警
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body models.CreateNotifyChannelRequest true "创建请求"
// @Success 200 {object} models.Response{data=models.NotifyChannel}
// @Router /alerts/notify-channels [post]
func (h *AlertHandler) CreateNotifyChannel(c *gin.Context) {
	var req models.CreateNotifyChannelRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, models.Response{
			Code:    400,
			Message: "请求参数错误: " + err.Error(),
		})
		return
	}

	channel := models.NotifyChannel{
		Name:   req.Name,
		Type:   req.Type,
		Config: req.Config,
		Enabled: true,
	}

	if err := h.db.Create(&channel).Error; err != nil {
		c.JSON(http.StatusInternalServerError, models.Response{
			Code:    500,
			Message: "创建失败",
		})
		return
	}

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "创建成功",
		Data:    channel,
	})
}

// UpdateNotifyChannel 更新通知渠道
// @Summary 更新通知渠道
// @Description 更新指定通知渠道
// @Tags 告警
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "渠道ID"
// @Param request body models.UpdateNotifyChannelRequest true "更新请求"
// @Success 200 {object} models.Response{data=models.NotifyChannel}
// @Router /alerts/notify-channels/{id} [put]
func (h *AlertHandler) UpdateNotifyChannel(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	var req models.UpdateNotifyChannelRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, models.Response{
			Code:    400,
			Message: "请求参数错误: " + err.Error(),
		})
		return
	}

	var channel models.NotifyChannel
	if err := h.db.First(&channel, id).Error; err != nil {
		c.JSON(http.StatusNotFound, models.Response{
			Code:    404,
			Message: "通知渠道不存在",
		})
		return
	}

	updates := map[string]interface{}{}
	if req.Name != "" {
		updates["name"] = req.Name
	}
	if req.Type != "" {
		updates["type"] = req.Type
	}
	if req.Config != "" {
		updates["config"] = req.Config
	}
	if req.Enabled != nil {
		updates["enabled"] = *req.Enabled
	}

	if err := h.db.Model(&channel).Updates(updates).Error; err != nil {
		c.JSON(http.StatusInternalServerError, models.Response{
			Code:    500,
			Message: "更新失败",
		})
		return
	}

	h.db.First(&channel, id)
	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "更新成功",
		Data:    channel,
	})
}

// DeleteNotifyChannel 删除通知渠道
// @Summary 删除通知渠道
// @Description 删除指定通知渠道
// @Tags 告警
// @Produce json
// @Security Bearer
// @Param id path int true "渠道ID"
// @Success 200 {object} models.Response
// @Router /alerts/notify-channels/{id} [delete]
func (h *AlertHandler) DeleteNotifyChannel(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	if err := h.db.Delete(&models.NotifyChannel{}, id).Error; err != nil {
		c.JSON(http.StatusInternalServerError, models.Response{
			Code:    500,
			Message: "删除失败",
		})
		return
	}

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: "删除成功",
	})
}

// TestNotifyChannel 测试通知渠道
// @Summary 测试通知渠道连通性
// @Description 模拟测试通知渠道（返回测试状态）
// @Tags 告警
// @Produce json
// @Security Bearer
// @Param id path int true "渠道ID"
// @Success 200 {object} models.Response
// @Router /alerts/notify-channels/{id}/test [post]
func (h *AlertHandler) TestNotifyChannel(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))

	var channel models.NotifyChannel
	if err := h.db.First(&channel, id).Error; err != nil {
		c.JSON(http.StatusNotFound, models.Response{
			Code:    404,
			Message: "通知渠道不存在",
		})
		return
	}

	// 模拟测试：校验配置非空即视为成功
	status := "success"
	message := "测试通知已发送"
	if channel.Config == "" {
		status = "warning"
		message = "渠道未配置参数，请先完善配置"
	}

	h.db.Model(&channel).Update("test_status", status)

	c.JSON(http.StatusOK, models.Response{
		Code:    200,
		Message: message,
		Data: gin.H{
			"status":  status,
			"channel": channel.Name,
			"type":    channel.Type,
		},
	})
}

// toJSON serializes a value to JSON string. Returns empty string on error.
func toJSON(v interface{}) string {
	b, err := json.Marshal(v)
	if err != nil {
		return ""
	}
	return string(b)
}