package controller

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"hepa-calc-api/api/dao"
	"hepa-calc-api/api/dto"
	"hepa-calc-api/api/requests"
	"hepa-calc-api/api/responses"
	"hepa-calc-api/api/service"
	"hepa-calc-api/global"
	"hepa-calc-api/utils"
	"strconv"
	"time"
)

type OrderSingle struct{}

// GetOrderSinglePage 获取单项订单列表-分页
func (b *OrderSingle) GetOrderSinglePage(c *gin.Context) {
	orderSingleRequest := requests.OrderSingleRequest{}
	req := orderSingleRequest.GetOrderSinglePage
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	if req.Page == 0 {
		req.Page = 1
	}

	if req.PageSize == 0 {
		req.PageSize = 20
	}

	userId := c.GetInt64("UserId")
	req.UserId = userId

	// 获取数据
	orderSingleDao := dao.OrderSingleDao{}
	orderSingles, total, err := orderSingleDao.GetOrderSinglePageSearch(req, req.Page, req.PageSize)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	// 检测用户会员
	userService := service.UserService{}
	isMember := userService.CheckUserMember(user)
	if isMember == true {
		for _, v := range orderSingles {
			if v.ValidDate != nil {
				validDate := time.Time(*v.ValidDate)
				memberExpireDate := time.Time(*user.MemberExpireDate)
				diffTime := memberExpireDate.Sub(validDate)
				if diffTime > 0 {
					v.ValidDate = user.MemberExpireDate
				}
			}
		}
	}

	// 处理返回值
	g := dto.GetOrderSingleListDto(orderSingles)

	result := make(map[string]interface{})
	result["page"] = req.Page
	result["page_size"] = req.PageSize
	result["total"] = total
	result["data"] = g
	responses.OkWithData(result, c)
}

// AddOrderSingle 创建单项订单
func (b *OrderSingle) AddOrderSingle(c *gin.Context) {
	orderSingleRequest := requests.OrderSingleRequest{}
	req := orderSingleRequest.AddOrderSingle
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	userId := c.GetInt64("UserId")

	// 将 id 转换为 int64 类型
	questionId, err := strconv.ParseInt(req.QuestionId, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 用户优惠卷id
	var userCouponId *int64
	if req.UserCouponId != "" {
		id, err := strconv.ParseInt(req.UserCouponId, 10, 64)
		if err != nil {
			responses.Fail(c)
			return
		}

		userCouponId = &id
	}

	if req.OrderPrice == nil {
		responses.FailWithMessage("订单金额错误", c)
		return
	}

	if *req.OrderPrice < 0 {
		responses.FailWithMessage("价格错误", c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
			utils.LogJsonErr("订单创建失败", r)
			responses.FailWithMessage("订单创建失败", c)
			return
		}
	}()

	// 创建单项订单
	orderSingleService := service.OrderSingleService{}
	orderSingle, err := orderSingleService.AddOrderSingle(tx, userId, questionId, userCouponId, req.PayChannel, req.OrderPrice)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage(err.Error(), c)
		return
	}

	tx.Commit()

	// 处理返回值
	g := &dto.AddOrderSingleDto{}
	g.OrderId = fmt.Sprintf("%d", orderSingle.OrderId)
	g.OrderNo = orderSingle.OrderNo
	responses.OkWithData(g, c)
}

// PutCancelOrderSingle 取消单项订单
func (b *OrderSingle) PutCancelOrderSingle(c *gin.Context) {
	userId := c.GetInt64("UserId")

	id := c.Param("order_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	orderId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取订单数据
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["order_id"] = orderId
	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
	if err != nil {
		responses.FailWithMessage("订单异常", c)
		return
	}

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

	// 取消单项订单
	orderSingleService := service.OrderSingleService{}
	res, err := orderSingleService.CancelOrderSingle(tx, orderSingle, 1)
	if err != nil && res == false {
		tx.Rollback()
		responses.FailWithMessage("取消订单失败", c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// GetOrderSinglePay 获取单项订单支付数据
func (b *OrderSingle) GetOrderSinglePay(c *gin.Context) {
	orderSingleRequest := requests.OrderSingleRequest{}
	req := orderSingleRequest.GetOrderSinglePay
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	userId := c.GetInt64("UserId")

	id := c.Param("order_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	orderId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取订单数据
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["order_id"] = orderId
	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
	if err != nil {
		responses.FailWithMessage("订单异常", c)
		return
	}

	// 检测订单状态（1:待支付 2:已完成 3:已取消）
	if orderSingle.OrderStatus != 1 {
		responses.FailWithMessage("订单状态异常", c)
		return
	}

	// 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
	if orderSingle.PayStatus != 1 {
		responses.FailWithMessage("订单支付状态异常", c)
		return
	}

	// 验证订单过期支付时间
	now := time.Now()
	validTime := time.Time(orderSingle.CreatedAt).Add(30 * time.Minute)
	if validTime.Before(now) {
		responses.FailWithMessage("订单已过期", c)
		return
	}

	// 处理返回值
	g := dto.GetOrderSinglePayDto(orderSingle)

	// 获取预支付交易会话标识
	if req.ClientType == 1 {
		orderSingleService := service.OrderSingleService{}
		prepay, err := orderSingleService.GetJsapiPrepay(orderSingle)
		if err != nil {
			//responses.FailWithMessage("发起支付失败1", c)
			responses.FailWithMessage(err.Error(), c)
			return
		}

		g.PrepayJsapi = prepay
	} else {
		orderSingleService := service.OrderSingleService{}
		prepay, err := orderSingleService.GetAppPrepay(orderSingle)
		if err != nil {
			responses.FailWithMessage(err.Error(), c)
			return
		}

		g.PrepayApp = prepay
	}

	responses.OkWithData(g, c)
}

// DeleteOrderSingle 删除单项订单支付数据
func (b *OrderSingle) DeleteOrderSingle(c *gin.Context) {
	userId := c.GetInt64("UserId")

	id := c.Param("order_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	orderId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取订单数据
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["order_id"] = orderId
	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
	if err != nil {
		responses.FailWithMessage("订单异常", c)
		return
	}

	// 检测订单状态
	if orderSingle.OrderStatus != 2 {
		responses.FailWithMessage("订单不允许删除", c)
		return
	}

	// 检测订单删除状态
	if orderSingle.IsDelete == 1 {
		responses.Ok(c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
			utils.LogJsonErr("操作失败", r)
			responses.FailWithMessage("操作失败", c)
			return
		}
	}()

	orderSingleData := make(map[string]interface{})
	orderSingleData["is_delete"] = 1
	orderSingleData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
	err = orderSingleDao.EditOrderSingleById(tx, orderId, orderSingleData)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage("删除失败", c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// GetOrderSinglePayStatus 查询订单支付状态-单项
func (b *OrderSingle) GetOrderSinglePayStatus(c *gin.Context) {
	userId := c.GetInt64("UserId")

	id := c.Param("order_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	orderId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取订单数据
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["order_id"] = orderId
	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
	if err != nil {
		responses.FailWithMessage("订单异常", c)
		return
	}

	// 处理返回值
	g := dto.GetOrderSinglePayStatus(orderSingle)

	responses.OkWithData(g, c)
}

// PutOrderSingleAnswer 上传单项答案
func (b *OrderSingle) PutOrderSingleAnswer(c *gin.Context) {
	orderSingleRequest := requests.OrderSingleRequest{}
	req := orderSingleRequest.PutOrderSingleAnswer
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

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

	userId := c.GetInt64("UserId")

	id := c.Param("order_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	orderId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取订单数据
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["order_id"] = orderId
	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
	if err != nil {
		responses.FailWithMessage("订单异常", c)
		return
	}

	// 检测订单状态
	if orderSingle.OrderStatus == 3 {
		responses.FailWithMessage("订单异常", c)
		return
	}

	// 检测订单退款状态
	if orderSingle.RefundStatus != 0 {
		responses.FailWithMessage("订单存在退款", c)
		return
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
			utils.LogJsonErr("操作失败", r)
			responses.FailWithMessage("操作失败", c)
			return
		}
	}()

	orderSingleData := make(map[string]interface{})
	orderSingleData["answer"] = req.Answer
	err = orderSingleDao.EditOrderSingleById(tx, orderSingle.OrderId, orderSingleData)
	if err != nil {
		responses.FailWithMessage("操作失败", c)
		return
	}

	tx.Commit()
	responses.Ok(c)
}

// GetOrderSingleAnswer 获取单项答案
func (b *OrderSingle) GetOrderSingleAnswer(c *gin.Context) {
	userId := c.GetInt64("UserId")

	id := c.Param("order_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	orderId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取订单数据
	orderSingleDao := dao.OrderSingleDao{}
	maps := make(map[string]interface{})
	maps["user_id"] = userId
	maps["order_id"] = orderId
	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
	if err != nil {
		responses.FailWithMessage("订单异常", c)
		return
	}

	// 检测订单状态
	if orderSingle.OrderStatus != 2 {
		responses.FailWithMessage("订单未完成", c)
		return
	}

	// 检测订单支付状态
	if orderSingle.PayStatus != 2 {
		responses.FailWithMessage("订单未完成支付", c)
		return
	}

	// 检测订单退款状态
	if orderSingle.RefundStatus != 0 {
		responses.FailWithMessage("订单存在退款", c)
		return
	}

	responses.OkWithData(orderSingle.Answer, c)
}