package cb_message

import (
	"encoding/json"
	"io"
	"strconv"
	"time"

	"be.ems/src/framework/i18n"
	"be.ems/src/framework/middleware"
	"be.ems/src/framework/utils/ctx"
	"be.ems/src/framework/vo/result"
	"github.com/gin-gonic/gin"
)

// @Description Register Routes for mf calling
func Register(r *gin.RouterGroup) {

	cbGroup := r.Group("/:neId")
	{
		var m *CBMessage
		cbGroup.GET("/message/list",
			middleware.PreAuthorize(nil),
			m.List,
		)
		cbGroup.GET("/message/:id",
			middleware.PreAuthorize(nil),
			m.GetById,
		)
		cbGroup.POST("/message",
			middleware.PreAuthorize(nil),
			m.Insert,
		)
		cbGroup.PUT("/message/:id/:status",
			middleware.PreAuthorize(nil),
			m.UpdateStatus,
		)
		cbGroup.PUT("/message/:id",
			middleware.PreAuthorize(nil),
			m.Update,
		)
		cbGroup.DELETE("/message/:id",
			middleware.PreAuthorize(nil),
			m.Delete,
		)
	}
}

func (m *CBMessage) List(c *gin.Context) {
	language := ctx.AcceptLanguage(c)
	neId := c.Param("neId")
	if neId == "" {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}
	var query CBMessageQuery
	if err := c.ShouldBindQuery(&query); err != nil {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}
	query.NeType = "CBC"
	query.NeId = neId

	service := NewCBMessageService()
	data, total, err := service.SelectCBMessage(query)
	if err != nil {
		c.JSON(500, result.ErrMsg(err.Error()))
		return
	}

	// 转换数据格式，确保 MessageJson 正确序列化
	processedData := make([]map[string]interface{}, len(data))
	for i, msg := range data {
		var messageJson interface{}
		if len(msg.MessageJson) > 0 {
			// 尝试解析为 JSON 对象
			if err := json.Unmarshal(msg.MessageJson, &messageJson); err != nil {
				// 如果解析失败，就作为字符串
				messageJson = string(msg.MessageJson)
			}
		}

		processedData[i] = map[string]interface{}{
			"id":          msg.Id,
			"neType":      msg.NeType,
			"neId":        msg.NeId,
			"messageJson": messageJson, // 这里是解析后的 JSON 对象
			"status":      msg.Status.Enum(),
			"detail":      msg.Detail,
			"createdAt":   msg.CreatedAt,
			"updatedAt":   msg.UpdatedAt,
		}
	}
	c.JSON(200, result.Ok(gin.H{
		"total": total,
		"data":  processedData,
	}))
}

// Update 更新CB消息
func (m *CBMessage) Insert(c *gin.Context) {
	language := ctx.AcceptLanguage(c)
	// 绑定请求体
	var msg CBMessage
	msg.NeType = "CBC"
	msg.NeId = c.Param("neId")
	msg.Status = CBEventStatusInactive // 默认状态为 INACTIVE
	if msg.NeId == "" {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}
	msg.CreatedAt = time.Now().Local().UnixMicro()
	msg.UpdatedAt = nil // 新增时更新时间为nil

	// 直接读取body为json.RawMessage
	body, err := io.ReadAll(c.Request.Body)
	if err != nil {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}
	msg.MessageJson = json.RawMessage(body)

	service := NewCBMessageService()
	if err := service.InsertCBMessage(msg); err != nil {
		c.JSON(500, result.ErrMsg(err.Error()))
		return
	}

	c.JSON(200, result.Ok(nil))
}

// Update 更新CB消息
func (m *CBMessage) Update(c *gin.Context) {
	language := ctx.AcceptLanguage(c)

	// 获取路径参数
	messageId := c.Param("id")
	if messageId == "" {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}

	id, err := strconv.ParseInt(messageId, 10, 64)
	if err != nil {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}
	// 直接读取body为json.RawMessage
	body, err := io.ReadAll(c.Request.Body)
	if err != nil {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}
	messageJson := json.RawMessage(body)

	service := NewCBMessageService()
	if err := service.UpdateCBMessage(id, messageJson); err != nil {
		c.JSON(500, result.ErrMsg(err.Error()))
		return
	}

	c.JSON(200, result.Ok(nil))
}

// UpdateStatus 更新CB消息状态
// 这里的 neId 参数是为了兼容性，实际更新状态时不需要使用它
// 但为了保持与原有接口一致，仍然保留该参数
// 如果需要根据 neId 进行特定的逻辑处理，可以在服务层实现
// 但在当前实现中，neId 仅用于验证请求的有效性
// 实际的状态更新逻辑不依赖于 neId
// 该接口用于更新 CB 消息的状态，状态值通过查询参数传递
// 例如：PUT /:neId/message/status?status=ACTIVE
func (m *CBMessage) UpdateStatus(c *gin.Context) {
	language := ctx.AcceptLanguage(c)

	neId := c.Param("neId")
	status := c.Param("status")
	if neId == "" || status == "" {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}

	messageId := c.Param("id")
	if messageId != "" {
		id, err := strconv.ParseInt(messageId, 10, 64)
		if err != nil {
			c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
			return
		}
		// 如果提供了 messageId，则更新特定消息的状态
		service := NewCBMessageService()
		if err := service.UpdateCBMessageStatus(id, status); err != nil {
			c.JSON(500, result.ErrMsg(err.Error()))
			return
		}
		c.JSON(200, result.Ok(nil))
		return
	}
	// 如果没有提供 messageId，则更新所有消息的状态
	service := NewCBMessageService()
	if err := service.UpdateCBMessageStatusByNeId(neId, status); err != nil {
		c.JSON(500, result.ErrMsg(err.Error()))
		return
	}
	c.JSON(200, result.Ok(nil))
}

// Delete 删除CB消息
func (m *CBMessage) Delete(c *gin.Context) {
	language := ctx.AcceptLanguage(c)

	// 获取路径参数
	messageId := c.Param("id")
	if messageId == "" {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}

	id, err := strconv.ParseInt(messageId, 10, 64)
	if err != nil {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}

	service := NewCBMessageService()
	if err := service.DeleteCBMessage(id); err != nil {
		c.JSON(500, result.ErrMsg(err.Error()))
		return
	}

	c.JSON(200, result.Ok(nil))
}

// GetById 根据ID获取CB消息
func (m *CBMessage) GetById(c *gin.Context) {
	language := ctx.AcceptLanguage(c)

	// 获取路径参数
	idStr := c.Param("id")
	if idStr == "" {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}

	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
		return
	}

	service := NewCBMessageService()
	data, err := service.SelectCBMessageById(id)
	if err != nil {
		c.JSON(500, result.ErrMsg(err.Error()))
		return
	}

	if data == nil {
		c.JSON(404, result.CodeMsg(404, i18n.TKey(language, "app.common.err404")))
		return
	}
	// 转换数据格式，确保 MessageJson 正确序列化
	var messageJson interface{}
	if len(data.MessageJson) > 0 {
		// 尝试解析为 JSON 对象
		if err := json.Unmarshal(data.MessageJson, &messageJson); err != nil {
			// 如果解析失败，就作为字符串
			messageJson = string(data.MessageJson)
		}
	}

	processedData := map[string]interface{}{
		"id":          data.Id,
		"neType":      data.NeType,
		"neId":        data.NeId,
		"messageJson": messageJson, // 这里是解析后的 JSON 对象
		"status":      data.Status.Enum(),
		"detail":      data.Detail,
		"createdAt":   data.CreatedAt,
		"updatedAt":   data.UpdatedAt,
	}

	c.JSON(200, result.Ok(gin.H{
		"data": processedData,
	}))
}