package consumer

import (
	"encoding/json"
	"github.com/rabbitmq/amqp091-go"
	"hepa-calc-api/api/dao"
	"hepa-calc-api/api/service"
	"hepa-calc-api/extend/weChat"
	"hepa-calc-api/global"
	"hepa-calc-api/utils"
	"strconv"
)

type cancelUnPayOrderData struct {
	OrderId    string `json:"order_id"`
	OrderNo    string `json:"order_no"`
	UserId     string `json:"user_id"`
	OrderType  int    `json:"order_type"`  // 订单类型（1：单项 2：会员）
	PayChannel int    `json:"pay_channel"` // 支付渠道（1:h5支付 2:app支付 3:会员支付）
}

// CancelUnPayOrder 取消未支付订单
func CancelUnPayOrder(msg amqp091.Delivery) {
	defer func() {
		if r := recover(); r != nil {
			utils.LogJsonErr("consumer.CancelUnPayOrder:", r)
			_ = msg.Reject(false)
		}
	}()

	// 记录日志
	utils.LogJsonInfo("consumer.CancelUnPayOrder:", string(msg.Body))
	if msg.Body == nil {
		_ = msg.Ack(false)
		return
	}

	// 解析JSON字符串到结构体
	var data cancelUnPayOrderData
	err := json.Unmarshal(msg.Body, &data)
	if err != nil {
		_ = msg.Ack(false)
		return
	}

	// 检测执行次数
	key := "CancelUnPayOrder" + data.OrderId
	res := checkHandleNumber(key)
	if res == false {
		utils.LogJsonErr("consumer.CancelUnPayOrder:", "超出最大执行次数或检测错误")
		_ = msg.Ack(false)
		return
	}

	orderId, err := strconv.ParseInt(data.OrderId, 10, 64)
	if err != nil {
		_ = msg.Ack(false)
		return
	}

	userId, err := strconv.ParseInt(data.UserId, 10, 64)
	if err != nil {
		_ = msg.Ack(false)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
			utils.LogJsonErr("consumer.CancelUnPayOrder:", r)
			_ = msg.Reject(false)
		}
	}()

	// 单项订单
	if data.OrderType == 1 {
		// 获取订单数据
		orderSingleDao := dao.OrderSingleDao{}
		maps := make(map[string]interface{})
		maps["user_id"] = userId
		maps["order_id"] = orderId
		orderSingle, err := orderSingleDao.GetOrderSingle(maps)
		if err != nil {
			tx.Rollback()
			utils.LogJsonErr("consumer.CancelUnPayOrder:", "订单异常")
			_ = msg.Reject(false)
			return
		}

		orderSingleService := service.OrderSingleService{}
		res, err := orderSingleService.CancelOrderSingle(tx, orderSingle, 3)
		if err != nil && res == false {
			tx.Rollback()
			utils.LogJsonErr("consumer.CancelUnPayOrder:", "取消失败")
			_ = msg.Reject(true)
			return
		}
	}

	// 会员订单
	if data.OrderType == 2 {
		// 获取订单数据
		orderMemberDao := dao.OrderMemberDao{}
		maps := make(map[string]interface{})
		maps["user_id"] = userId
		maps["order_id"] = orderId
		orderMember, err := orderMemberDao.GetOrderMember(maps)
		if err != nil {
			tx.Rollback()
			utils.LogJsonErr("consumer.CancelUnPayOrder:", "订单异常")
			_ = msg.Reject(false)
			return
		}

		orderMemberService := service.OrderMemberService{}
		res, err := orderMemberService.CancelOrderMember(tx, orderMember, 3)
		if err != nil && res == false {
			tx.Rollback()
			utils.LogJsonErr("consumer.CancelUnPayOrder:", "取消失败")
			_ = msg.Reject(true)
			return
		}
	}

	tx.Commit()

	// 关闭支付订单
	if data.PayChannel == 1 {
		// h5支付
		err = weChat.CloseJsapiOrder(data.OrderNo)
		if err != nil {
			utils.LogJsonErr("consumer.CancelUnPayOrder:", err)
		}
	}

	if data.PayChannel == 2 {
		// app支付
		err = weChat.CloseAppOrder(data.OrderNo)
		if err != nil {
			utils.LogJsonErr("consumer.CancelUnPayOrder:", err)
		}
	}

	_ = msg.Ack(false)
}