package controller

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"hepa-calc-api/api/dao"
	"hepa-calc-api/api/model"
	"hepa-calc-api/api/responses"
	"hepa-calc-api/config"
	"hepa-calc-api/extend/app"
	"hepa-calc-api/global"
	"hepa-calc-api/utils"
	"net/http"
	"time"
)

type Pay struct{}

// GetPayOrder 获取订单支付数据
func (r *Pay) GetPayOrder(c *gin.Context) {
	req := app.PayOrderRequest{}
	if err := c.ShouldBindJSON(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 获取header签名
	requestSign := c.Request.Header.Get("sign")
	if requestSign == "" {
		responses.FailWithMessage("缺少签名", c)
		return
	}

	// 验证签名
	err := app.VerifySignature(req, requestSign)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	var payStatus int             // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
	var orderStatus int           // 订单状态（1:待支付 2:已完成 3:已取消）
	var paymentAmountTotal int    // 实际付款金额
	var userId int64              // 用户id
	var orderNo string            // 订单编号
	var goodName string           // 商品名称
	var createdAt model.LocalTime // 订单创建时间
	var notifyUrl string          // 回调通知地址

	// 获取订单数据-单项
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["order_no"] = req.OrderId
	orderSingle, _ := orderSingleDao.GetOrderSingle(maps)
	if orderSingle != nil {
		payStatus = orderSingle.PayStatus
		orderStatus = orderSingle.OrderStatus
		paymentAmountTotal = int(orderSingle.PaymentAmountTotal * 100)
		userId = orderSingle.UserId
		orderNo = orderSingle.OrderNo
		createdAt = orderSingle.CreatedAt
		notifyUrl = config.C.Wechat.NotifyDomain + config.C.Wechat.SinglePayNotifyUrl

		// 获取单项数据
		questionDao := dao.QuestionDao{}
		question, err := questionDao.GetQuestionById(orderSingle.QuestionId)
		if err != nil {
			responses.FailWithMessage(err.Error(), c)
			return
		}

		goodName = question.QuestionTitle
	}

	// 获取订单数据-会员
	orderMemberDao := dao.OrderMemberDao{}
	maps = make(map[string]interface{})
	maps["order_no"] = req.OrderId
	orderMember, _ := orderMemberDao.GetOrderMember(maps)
	if orderMember != nil {
		payStatus = orderMember.PayStatus
		orderStatus = orderMember.OrderStatus
		paymentAmountTotal = int(orderMember.PaymentAmountTotal * 100)
		userId = orderMember.UserId
		orderNo = orderMember.OrderNo
		createdAt = orderMember.CreatedAt
		notifyUrl = config.C.Wechat.NotifyDomain + config.C.Wechat.MemberPayNotifyUrl

		// 获取对应数据
		systemMemberDao := dao.SystemMemberDao{}
		systemMember, err := systemMemberDao.GetSystemMemberById(orderMember.SystemMemberId)
		if err != nil {
			responses.FailWithMessage(err.Error(), c)
			return
		}

		memberDays := fmt.Sprintf("%d", systemMember.MemberDays)
		goodName = "肝病算一算" + memberDays + "会员"
	}

	if orderSingle == nil && orderMember == nil {
		c.JSON(http.StatusOK, gin.H{"code": 90002, "message": "订单不存在", "data": nil})
		return
	}

	// 检测订单支付状态
	if payStatus == 2 {
		c.JSON(http.StatusOK, gin.H{"code": 90000, "message": "订单已支付，请勿重新支付", "data": nil})
		return
	}

	if payStatus == 3 {
		c.JSON(http.StatusOK, gin.H{"code": 90003, "message": "订单支付中", "data": nil})
		return
	}

	if payStatus != 1 {
		c.JSON(http.StatusOK, gin.H{"code": 90004, "message": "订单支付失败", "data": nil})
		return
	}

	// 检测订单取消状态
	if orderStatus == 3 {
		c.JSON(http.StatusOK, gin.H{"code": 90001, "message": "订单已关闭", "data": nil})
		return
	}

	if orderStatus == 2 {
		c.JSON(http.StatusOK, gin.H{"code": 90004, "message": "订单支付失败", "data": nil})
		return
	}

	// 验证订单过期支付时间
	now := time.Now()
	validTime := time.Time(createdAt).Add(30 * time.Minute)
	if validTime.Before(now) {
		c.JSON(http.StatusOK, gin.H{"code": 90001, "message": "订单已关闭", "data": nil})
		return
	}

	// 获取用户数据
	userDao := dao.UserDao{}
	user, err := userDao.GetUserById(userId)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	appId := config.C.Wechat.AppId
	if config.C.Env == "dev" {
		appId = config.C.Wechat.TestPayAppId
	}

	// 处理返回数据
	g := app.PayOrderDataResponse{
		AppId:       appId,
		Total:       paymentAmountTotal,
		Description: "肝病算一算",
		OpenId:      user.OpenId,
		OutTradeNo:  orderNo,
		Attach:      "",
		NotifyUrl:   notifyUrl,
		GoodName:    goodName,
	}

	responses.OkWithData(g, c)
	return
}