package controller

import (
	"github.com/gin-gonic/gin"
	"hepa-calc-api/api/dao"
	"hepa-calc-api/api/responses"
	"hepa-calc-api/api/service"
	"hepa-calc-api/extend/weChat"
	"hepa-calc-api/global"
	"hepa-calc-api/utils"
	"net/http"
	"time"
)

// CallBack 回调
type CallBack struct{}

// WxPaySingle 微信支付回调-单项
func (r *CallBack) WxPaySingle(c *gin.Context) {
	notifyReq, transaction, err := weChat.PayParseNotify(c)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 记录日志
	utils.LogJsonErr("微信支付回调-单项", *notifyReq)
	utils.LogJsonErr("微信支付回调-单项", *transaction)

	if transaction == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少订单数据"})
		return
	}

	if transaction.OutTradeNo == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少外部订单号"})
		return
	}

	// 查询订单
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["order_no"] = transaction.OutTradeNo
	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
	if err != nil || orderSingle == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "无订单数据"})
		return
	}

	// 验证订单状态-订单状态（1:待支付 2:已完成 3:已取消）
	if orderSingle.OrderStatus != 1 {
		message := "订单状态:" + utils.OrderSingleStatusToString(orderSingle.OrderStatus) + " 无需处理"
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
		return
	}

	// 处理支付状态
	if transaction.TradeState == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少支付状态"})
		return
	}

	// 处理回调支付状态
	wxResult, err := weChat.HandlePayStatus(transaction)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 修改订单
	orderSingleData := make(map[string]interface{})
	orderSingleData["order_status"] = wxResult.OrderStatus
	orderSingleData["pay_status"] = wxResult.PayStatus
	if wxResult.PayTime != nil {
		orderSingleData["pay_time"] = *wxResult.PayTime
	}
	orderSingleData["escrow_trade_no"] = transaction.TransactionId

	// 处理单项有效时间
	if wxResult.PayStatus == 2 {
		systemSingleDao := dao.SystemSingleDao{}

		maps := make(map[string]interface{})
		systemSingle, err := systemSingleDao.GetSystemSingle(maps)
		if err != nil {
			tx.Rollback()
			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
			return
		}

		orderSingleData["valid_date"] = time.Now().Add(time.Duration(systemSingle.ValidDays) * 24 * time.Hour)
	}

	err = orderSingleDao.EditOrderSingleById(tx, orderSingle.OrderId, orderSingleData)
	if err != nil {
		tx.Rollback()
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	if wxResult.PayStatus == 2 {
		// 增加单项支付次数
		questionService := service.QuestionService{}
		res, err := questionService.AddQuestionPayCount(tx, orderSingle.QuestionId)
		if err != nil || res == false {
			tx.Rollback()
			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "内部错误"})
			return
		}

		// 增加用户单项支付次数
		userService := service.UserService{}
		res, err = userService.AddUserSinglePayCount(tx, orderSingle.UserId)
		if err != nil || res == false {
			tx.Rollback()
			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "内部错误"})
			return
		}

		// 取消同题目未支付订单
		maps = make(map[string]interface{})
		maps["user_id"] = orderSingle.UserId
		maps["question_id"] = orderSingle.QuestionId
		orderSingles, err := orderSingleDao.GetOrderSingleList(maps)
		if err != nil {
			tx.Rollback()
			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "内部错误"})
			return
		}

		orderSingleService := service.OrderSingleService{}
		for _, single := range orderSingles {
			if single.OrderId == orderSingle.OrderId {
				continue
			}

			// 取消单项订单
			res, err = orderSingleService.CancelOrderSingle(tx, single, 3)
			if err != nil && res == false {
				utils.LogJsonErr("微信支付回调-单项", "取消单项订单失败")
			}
		}
	}

	tx.Commit()
	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "OK"})
}

// WxPayMember 微信支付回调-会员
func (r *CallBack) WxPayMember(c *gin.Context) {
	notifyReq, transaction, err := weChat.PayParseNotify(c)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 记录日志
	utils.LogJsonErr("微信支付回调-会员", *notifyReq)
	utils.LogJsonErr("微信支付回调-会员", *transaction)

	if transaction == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少订单数据"})
		return
	}

	if transaction.OutTradeNo == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少外部订单号"})
		return
	}

	// 查询订单
	orderMemberDao := dao.OrderMemberDao{}
	maps := make(map[string]interface{})
	maps["order_no"] = transaction.OutTradeNo
	orderMember, err := orderMemberDao.GetOrderMember(maps)
	if err != nil || orderMember == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "无订单数据"})
		return
	}

	// 验证订单状态-订单状态（1:待支付 2:已完成 3:已取消）
	if orderMember.OrderStatus != 1 {
		message := "订单状态:" + utils.OrderSingleStatusToString(orderMember.OrderStatus) + " 无需处理"
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
		return
	}

	// 处理支付状态
	if transaction.TradeState == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少支付状态"})
		return
	}

	// 处理回调支付状态
	wxResult, err := weChat.HandlePayStatus(transaction)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 获取用户数据
	userDao := dao.UserDao{}
	user, err := userDao.GetUserById(orderMember.UserId)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "用户数据错误"})
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 修改订单
	orderSingleData := make(map[string]interface{})
	orderSingleData["order_status"] = wxResult.OrderStatus
	orderSingleData["pay_status"] = wxResult.PayStatus
	if wxResult.PayTime != nil {
		orderSingleData["pay_time"] = *wxResult.PayTime
	}
	orderSingleData["escrow_trade_no"] = transaction.TransactionId
	err = orderMemberDao.EditOrderMemberById(tx, orderMember.OrderId, orderSingleData)
	if err != nil {
		tx.Rollback()
		c.JSON(http.StatusInternalServerError, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 处理支付成功情况
	if wxResult.OrderStatus == 2 {
		// 处理会员订单支付成功
		orderMemberService := service.OrderMemberService{}
		err := orderMemberService.HandleOrderMemberPaySuccess(tx, orderMember, user)
		if err != nil {
			tx.Rollback()
			c.JSON(http.StatusInternalServerError, gin.H{"code": "ERROR", "message": err.Error()})
			return
		}
	}

	tx.Commit()
	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "OK"})
}

// WxPaySingleRefund 微信退款回调-单项
func (r *CallBack) WxPaySingleRefund(c *gin.Context) {
	notifyReq, refund, err := weChat.RefundParseNotify(c)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 记录日志
	utils.LogJsonErr("微信退款回调-单项", *notifyReq)
	utils.LogJsonErr("微信退款回调-单项", *refund)

	if refund == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少订单数据"})
		return
	}

	if refund.OutTradeNo == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少外部订单号"})
		return
	}

	// 查询订单
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["order_no"] = refund.OutTradeNo
	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
	if err != nil || orderSingle == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "无订单数据"})
		return
	}

	// 验证订单状态-订单状态（1:待支付 2:已完成 3:已取消）
	if orderSingle.OrderStatus == 1 {
		message := "订单状态:" + utils.OrderSingleStatusToString(orderSingle.OrderStatus) + " 无需处理"
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
		return
	}

	// 验证订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
	if orderSingle.RefundStatus == 3 {
		message := "订单状态:" + utils.OrderSingleRefundStatusToString(orderSingle.RefundStatus) + " 无需处理"
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
		return
	}

	// 验证订单支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
	if orderSingle.PayStatus != 2 && orderSingle.PayStatus != 8 {
		message := "订单状态:" + utils.OrderSinglePayStatusToString(orderSingle.RefundStatus) + " 无需处理"
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
		return
	}

	// 处理回调支付状态
	wxResult, err := weChat.HandlePayRefundStatus(refund)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 修改订单
	orderSingleData := make(map[string]interface{})
	orderSingleData["refund_status"] = wxResult.RefundStatus
	err = orderSingleDao.EditOrderSingleById(tx, orderSingle.OrderId, orderSingleData)
	if err != nil {
		tx.Rollback()
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 修改订单退款
	orderSingleRefundDao := dao.OrderSingleRefundDao{}

	orderSingleRefundData := make(map[string]interface{})
	orderSingleRefundData["refund_status"] = wxResult.RefundStatus
	if wxResult.SuccessTime != nil {
		orderSingleRefundData["success_time"] = *wxResult.SuccessTime
	}
	err = orderSingleRefundDao.EditOrderSingleRefundById(tx, orderSingle.OrderId, orderSingleRefundData)
	if err != nil {
		tx.Rollback()
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 处理退款成功情况
	if wxResult.RefundStatus == 3 {
		// 退还订单优惠卷
		orderSingleService := service.OrderSingleService{}
		err = orderSingleService.OrderCouponRefund(tx, orderSingle)
		if err != nil {
			tx.Rollback()
			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
			return
		}
	}

	tx.Commit()
	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "OK"})
}

// WxPayMemberRefund 微信退款回调-会员
func (r *CallBack) WxPayMemberRefund(c *gin.Context) {
	notifyReq, refund, err := weChat.RefundParseNotify(c)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 记录日志
	utils.LogJsonErr("微信退款回调-会员", *notifyReq)
	utils.LogJsonErr("微信退款回调-会员", *refund)

	if refund == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少订单数据"})
		return
	}

	if refund.OutTradeNo == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少外部订单号"})
		return
	}

	// 查询订单
	orderMemberDao := dao.OrderMemberDao{}
	maps := make(map[string]interface{})
	maps["order_no"] = refund.OutTradeNo
	orderMember, err := orderMemberDao.GetOrderMember(maps)
	if err != nil || orderMember == nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "无订单数据"})
		return
	}

	// 验证订单状态-订单状态（1:待支付 2:已完成 3:已取消）
	if orderMember.OrderStatus == 1 {
		message := "订单状态:" + utils.OrderSingleStatusToString(orderMember.OrderStatus) + " 无需处理"
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
		return
	}

	// 验证订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
	if orderMember.RefundStatus == 3 {
		message := "订单状态:" + utils.OrderSingleRefundStatusToString(orderMember.RefundStatus) + " 无需处理"
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
		return
	}

	// 验证订单支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
	if orderMember.PayStatus != 2 && orderMember.PayStatus != 8 {
		message := "订单状态:" + utils.OrderSinglePayStatusToString(orderMember.RefundStatus) + " 无需处理"
		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
		return
	}

	// 处理回调支付状态
	wxResult, err := weChat.HandlePayRefundStatus(refund)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	// 修改订单
	orderMemberData := make(map[string]interface{})
	orderMemberData["refund_status"] = wxResult.RefundStatus
	err = orderMemberDao.EditOrderMemberById(tx, orderMember.OrderId, orderMemberData)
	if err != nil {
		tx.Rollback()
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 修改订单退款
	orderMemberRefundDao := dao.OrderMemberRefundDao{}

	orderMemberRefundData := make(map[string]interface{})
	orderMemberRefundData["refund_status"] = wxResult.RefundStatus
	if wxResult.SuccessTime != nil {
		orderMemberRefundData["success_time"] = *wxResult.SuccessTime
	}
	err = orderMemberRefundDao.EditOrderMemberRefundById(tx, orderMember.OrderId, orderMemberRefundData)
	if err != nil {
		tx.Rollback()
		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
		return
	}

	// 处理退款成功情况
	if wxResult.RefundStatus == 3 {
		// 退还订单优惠卷
		orderMemberService := service.OrderMemberService{}
		err = orderMemberService.OrderCouponRefund(tx, orderMember)
		if err != nil {
			tx.Rollback()
			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
			return
		}
	}

	tx.Commit()
	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "OK"})
}