package services

import (
	"qteam/app/constants/common"
	"qteam/app/constants/errorcode"
	"qteam/app/http/entities/front"
	"qteam/app/models/ordersmodel"
	"qteam/app/models/productsmodel"
	"qteam/app/models/usersmodel"
	"qteam/app/utils"
	redis_util "qteam/app/utils/redis"
	"qteam/config"
	"strconv"
	"time"
	"xorm.io/builder"
)

func CreateOrderService(userId int, productId int) (code int, data front.InsertOrderResponse) {
	var err error
	{ // redis保证用户当前抽奖结束才能开始下次抽奖
		key := utils.GetRealKey("lottery_code:" + strconv.Itoa(userId) + strconv.Itoa(productId))
		ok, err := redis_util.AcquireLock(key, time.Second*10)
		if ok {
			defer redis_util.Del(key)
		} else {
			if err != nil {
				utils.Log(nil, "CreateOrderService", err.Error())
			}
			code = errorcode.OrderLottery
			return code, data
		}
	}
	session := ordersmodel.GetInstance().GetDb().NewSession()
	defer func() {
		if err != nil {
			_ = session.Rollback()
			return
		}
		_ = session.Close()
	}()
	var product productsmodel.Products
	has, err := productsmodel.GetInstance().GetDb().Where("id =?", productId).Get(&product)
	if err != nil {
		return errorcode.SystemError, data
	}
	if !has {
		return errorcode.OrderProductNotExist, data
	}
	var user usersmodel.Users
	_, err = usersmodel.GetInstance().GetDb().Where("id =?", userId).Get(&user)
	if err != nil {
		return errorcode.SystemError, data
	}
	order := ordersmodel.Orders{
		OrderNo:     utils.GenerateOrderNumber(),
		UserId:      userId,
		ProductId:   productId,
		ProductName: product.Name,
		UserName:    user.Name,
		Price:       product.Price,
		Mobile:      user.Phone,
		VoucherId:   product.ThirdProductId,
		State:       common.STATUSABLED,
		CreateTime:  time.Now(),
	}
	if err = session.Begin(); err != nil {
		return errorcode.SystemError, data
	}
	if _, err := session.Insert(order); err != nil {
		utils.Log(nil, "CreateOrderService", err.Error())
		return errorcode.SystemError, data
	} else {
		_ = session.Commit()
	}
	data.OrderNo = order.OrderNo
	data.NotifyUrl = config.GetConf().YouChu.NotifyUrl
	return errorcode.Success, data
}

func OrderQueryService(userId int, OrderRequest *front.OrderListRequest) (code int, data []ordersmodel.Orders, count int64) {
	repo := ordersmodel.GetInstance().GetDb()
	count, err := repo.Where("user_id = ?", userId).
		Desc("id").Limit(OrderRequest.PageSize, (OrderRequest.Page-1)*OrderRequest.PageSize).FindAndCount(&data)
	code = handErr(err)
	return
}

func OrderDetailService(order *ordersmodel.Orders) (has bool, err error) {
	repo := ordersmodel.GetInstance().GetDb()
	conn := builder.NewCond()
	if order.Id != 0 {
		conn = conn.And(builder.Eq{"id": order.Id})
	}
	if order.OrderNo != "" {
		conn = conn.And(builder.Eq{"order_no": order.OrderNo})
	}
	return repo.Where(conn).Get(order)
}

func OrdersUpdateService(req front.OrdersUpdateRequest) (err error) {
	repo := ordersmodel.GetInstance().GetDb()
	var order ordersmodel.Orders
	if req.Id != 0 {
		order.Id = req.Id
	}
	if req.Status != 0 {
		order.State = req.Status
	}
	if req.VoucherLink != "" {
		order.VoucherLink = req.VoucherLink
	}
	_, err = repo.Where("Id = ?", req.Id).Update(&order)
	return
}

func OrderRefundService(userId int, orderId int) (code int) {
	{ // redis保证用户当前抽奖结束才能开始下次抽奖
		key := utils.GetRealKey("lottery_code:" + strconv.Itoa(userId) + strconv.Itoa(orderId))
		ok, err := redis_util.AcquireLock(key, time.Second*10)
		if ok {
			defer redis_util.Del(key)
		} else {
			if err != nil {
				utils.Log(nil, "CreateOrderService", err.Error())
			}
			return errorcode.SystemError
		}
	}
	order := ordersmodel.Orders{Id: orderId, UserId: userId}
	has, err := OrderDetailService(&order)
	if err != nil || !has {
		return errorcode.NotFound
	}
	if order.State >= common.ORDER_STATUS_PAY {
		return errorcode.OrderNOTAuthREFUND
	}
	code, response := YouChuOrderRefund(order)
	if code != errorcode.Success {
		return code
	} else {
		if response.RefundOrderSta != "03" {
			return errorcode.OrderRefundFail
		} else {
			order.State = common.ORDER_STATUS_ReFUNDING
			order.RefundOrderNo = response.RefundOrderNo
			order.RefundOrderSta = response.RefundOrderSta
			order.RefundTime = time.Now()
			_, err := ordersmodel.GetInstance().GetDb().Update(order)
			if err != nil {
				return errorcode.OrderRefundUpdateFail
			}
			return errorcode.Success
		}
	}
}