package services

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"hongze/hongze_cygx/models/order"
	"hongze/hongze_cygx/utils"
	"time"
)

// CancelCygxOrder 关闭到期个人用户研选权限
func CancelCygxOrder(cont context.Context) (err error) {
	defer func() {
		if err != nil {
			fmt.Println(err)
			go utils.SendAlarmMsg(fmt.Sprint("自动取消十分钟之内没有付款的的订单 CancelCygxOrder ，err：", err.Error()), 2)
		}
	}()
	var condition string
	var pars []interface{}
	endTime := time.Now().Add(-10 * time.Minute)
	condition = ` AND order_status = 1   AND create_time < ?   `
	pars = append(pars, endTime)
	orderList, e := order.GetCygxOrderList(condition, pars, 0, 999)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetCygxOrderList, Err: " + e.Error())
		return
	}
	fmt.Println(len(orderList))
	if len(orderList) == 0 {
		return
	}
	//订单量不大，先这么写吧
	for _, v := range orderList {
		fmt.Println(v.OrderCode)
		e = order.CancelCygxOrder(v)
		if e != nil && e.Error() != utils.ErrNoRow() {
			err = errors.New("CancelCygxOrder, Err: " + e.Error())
			return
		}
	}
	return
}

// GetQueryOrderByOutTradeNoTask 定时任务主动获取订单支付状态
func GetQueryOrderByOutTradeNoTask(cont context.Context) (err error) {
	defer func() {
		if err != nil {
			fmt.Println(err)
			go utils.SendAlarmMsg(fmt.Sprint("自动取消十分钟之内没有付款的的订单 CancelCygxOrder ，err：", err.Error()), 2)
		}
	}()
	var condition string
	var pars []interface{}
	endTime := time.Now().Add(-10 * time.Minute)
	condition = ` AND order_status = 1   AND create_time >  ?   ` //获取十分钟之内待支付的订单
	pars = append(pars, endTime)
	orderList, e := order.GetCygxOrderList(condition, pars, 0, 999)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = errors.New("GetCygxOrderList, Err: " + e.Error())
		return
	}
	fmt.Println(len(orderList))
	if len(orderList) == 0 {
		return
	}
	//订单量不大，先这么写吧
	for _, v := range orderList {
		tradeState, statusCode, itemResp := GetQueryOrderByOutTradeNo(v.OrderCode)
		if tradeState == "SUCCESS" && statusCode == 200 {
			go HandleOrderHandle(itemResp)
		}
	}
	return
}

// 手动处理支付订单回调
func HandleOrderHandle(itemCallback *Transaction) {
	var err error
	defer func() {
		if err != nil {
			fmt.Println(err)
			go utils.SendAlarmMsg(fmt.Sprint("手动处理支付订单回调失败 HandleOrderHandle, err：", err.Error()), 2)
		}
	}()
	outTradeNo := itemCallback.OutTradeNo
	orderDetail, e := order.GetCygxOrderDetailByOrderCode(outTradeNo)
	if e != nil {
		err = errors.New("GetCygxOrderDetailByOrderCode, Err: " + e.Error())
		return
	}

	go AddCygxOrderPayment(itemCallback) // 记录支付交易信息

	if itemCallback.TradeState != "SUCCESS" { // 回调显示支付不成功，模版消息推送
		if e != nil {
			err = errors.New("支付失败,  OrderCode: " + outTradeNo)
			return
		}
	}
	//修改过状态的不再二次处理
	if orderDetail.OrderStatus == 2 {
		return
	}

	itemOrder := new(order.CygxOrder)
	itemOrder.OrderCode = itemCallback.OutTradeNo
	itemOrder.PayTime = itemCallback.SuccessTime
	itemOrder.PayMoney = float64(float64(itemCallback.Amount.PayerTotal) / 100) // 金额分转换处理
	itemOrder.OrderStatus = 2
	itemOrder.OutTradeCode = itemCallback.TransactionId

	//文章处理逻辑  	OrderType        int       `comment:"订单类型，1:畅读卡订单，2：单场付费订单"`
	if orderDetail.OrderType == 1 {
		itemUserCard := new(order.CygxOrderUserCard)
		itemUserCard.OrderCode = orderDetail.OrderCode
		itemUserCard.UserId = orderDetail.UserId
		itemUserCard.Mobile = orderDetail.Mobile
		itemUserCard.Email = orderDetail.Email
		itemUserCard.CompanyId = orderDetail.CompanyId
		itemUserCard.CompanyName = orderDetail.CompanyName
		itemUserCard.RealName = orderDetail.RealName
		itemUserCard.SellerName = orderDetail.SellerName
		itemUserCard.CreateTime = time.Now()
		itemUserCard.ModifyTime = time.Now()
		itemUserCard.RegisterPlatform = orderDetail.RegisterPlatform

		if orderDetail.GoodsId == 1 {
			itemUserCard.StartDate = itemOrder.PayTime
			itemUserCard.EndDate = itemOrder.PayTime.AddDate(0, 0, 1)
			itemUserCard.CardType = "日卡"
		} else {
			now := time.Now()
			itemUserCard.StartDate = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local)
			itemUserCard.EndDate = itemUserCard.StartDate.AddDate(0, 1, 0)
			itemUserCard.CardType = "月卡"
		}
		e = order.AddCygxOrderUserCard(itemUserCard, itemOrder)
		if e != nil {
			err = errors.New("AddCygxOrderUserCard, Err: " + e.Error())
			return
		}
	} else if orderDetail.OrderType == 2 {
		//如果是活动，把单场付费信息的活动写入 用户虚拟资产表
		itemOrderVirtualAsset := new(order.CygxOrderVirtualAsset)
		itemOrderVirtualAsset.OrderCode = orderDetail.OrderCode
		itemOrderVirtualAsset.UserId = orderDetail.UserId
		itemOrderVirtualAsset.Mobile = orderDetail.Mobile
		itemOrderVirtualAsset.Email = orderDetail.Email
		itemOrderVirtualAsset.CompanyId = orderDetail.CompanyId
		itemOrderVirtualAsset.CompanyName = orderDetail.CompanyName
		itemOrderVirtualAsset.RealName = orderDetail.RealName
		itemOrderVirtualAsset.SellerName = orderDetail.SellerName
		itemOrderVirtualAsset.Source = orderDetail.Source
		itemOrderVirtualAsset.SourceId = orderDetail.SourceId
		itemOrderVirtualAsset.CreateTime = time.Now()
		itemOrderVirtualAsset.ModifyTime = time.Now()
		e = order.AddCygxOrderVirtualAsset(itemOrderVirtualAsset, itemOrder)
		if e != nil {
			err = errors.New("AddCygxOrderVirtualAsset, Err: " + e.Error())
			return
		}
	}
	return
}

func AddCygxOrderPayment(itemCallback *Transaction) {
	var err error
	defer func() {
		if err != nil {
			fmt.Println(err)
			go utils.SendAlarmMsg(fmt.Sprint("处理订单回调信息失败 HandleOrderHandle, err：", err.Error()), 2)
		}
	}()
	itemPay := new(order.CygxOrderPayment)
	itemPay.OrderCode = itemCallback.OutTradeNo
	itemPay.OutTradeCode = itemCallback.TransactionId
	itemPay.PayBody = itemCallback.TradeStateDesc
	jsonData, _ := json.Marshal(itemCallback)
	itemPay.PayDetail = string(jsonData)
	itemPay.PayMoney = float64(float64(itemCallback.Amount.PayerTotal) / 100) // 金额分转换处理
	itemPay.PayStatus = itemCallback.TradeState
	itemPay.CreateTime = time.Now()
	itemPay.PaymentType = 1
	e := order.AddCygxOrderPayment(itemPay)
	if e != nil {
		err = errors.New("AddCygxOrderPayment, Err: " + e.Error())
		return
	}
	return
}