package print_server

import (
	"encoding/json"
	"git.rosy.net.cn/baseapi/platformapi/tonglianpayapi"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-print/dao"
	"git.rosy.net.cn/jx-print/globals"
	"git.rosy.net.cn/jx-print/model"
	"git.rosy.net.cn/jx-print/putils"
	"git.rosy.net.cn/jx-print/services/api"
	"github.com/jmoiron/sqlx"
	"time"
)

var (
	findOrderPayPriceMap = map[string]func(db *sqlx.DB, typeID string) (int64, error){
		model.OrderTypeFlow: func(db *sqlx.DB, typeID string) (payPrice int64, err error) {
			var flowCfg []*model.FlowConfig
			if config, err2 := dao.GetConfig(db, model.ConfigTypeSys, model.OrderTypeFlow); err2 == nil && config != nil {
				if err = json.Unmarshal([]byte(config.Value), &flowCfg); err == nil && len(flowCfg) > 0 {
					for _, v := range flowCfg {
						if v.ID == utils.Str2Int(typeID) {
							payPrice = v.Price
							break
						}
					}
				}
			} else {
				err = err2
			}
			return payPrice, err
		},
		model.OrderTypeCardValid: func(db *sqlx.DB, typeID string) (payPrice int64, err error) {
			var (
				avgPrice int64
				count    = utils.Str2Int(typeID) //充卡有效期代表几个月
			)
			if config, err2 := dao.GetConfig(db, model.ConfigTypeSys, model.OrderTypeCardValid); err2 == nil && config != nil {
				avgPrice = utils.Str2Int64(config.Value)
			} else {
				err = err2
			}
			return avgPrice * int64(count), err
		},
	}

	payFunc = map[string]func(db *sqlx.DB, order *model.PayOrder, vendorPayType string) (err error){
		model.PayTypeTL: func(db *sqlx.DB, order *model.PayOrder, vendorPayType string) (err error) {
			param := &tonglianpayapi.CreateUnitorderOrderParam{
				Trxamt:    int(order.PayPrice),
				NotifyUrl: "http://print.jxc4.com/callback/tlPayCallback",
				Reqsn:     order.OrderID,
				PayType:   vendorPayType,
			}
			//if vendorPayType != tonglianpayapi.PayTypeWxCode {
			//	return fmt.Errorf("暂不支持的支付类型！vendorPayType :%s", vendorPayType)
			//}
			result, err := api.TLpayAPI.CreateUnitorderOrder(param)
			if err == nil {
				order.PrepayID = result.PayInfo
				order.TransactionID = result.TrxID
				err = dao.Update(db, order, "transaction_id", "prepay_id")
			}
			return err
		},
	}

	payFinishedFunc = map[string]func(db *sqlx.DB, order *model.PayOrder) (err error){
		//冲流量，支付完了之后要充进去
		model.OrderTypeFlow: func(db *sqlx.DB, order *model.PayOrder) (err error) {
			var (
				flowCfg    []*model.FlowConfig
				iccID      = order.ThingID
				flow       float64
				unit       string
				now        = time.Now()
				monthBegin = utils.Str2Time(now.Format("2006-01") + "-01 00:00:00")
				monthEnd   = utils.Str2Time(monthBegin.AddDate(0, 1, 0).AddDate(0, 0, -1).Format("2006-01-02") + " 23:59:59")
			)
			if config, err2 := dao.GetConfig(db, model.ConfigTypeSys, model.OrderTypeFlow); err2 == nil && config != nil {
				if err = json.Unmarshal([]byte(config.Value), &flowCfg); err == nil && len(flowCfg) > 0 {
					for _, v := range flowCfg {
						if v.ID == utils.Str2Int(order.TypeID) {
							flow, unit = v.Flow, v.Unit
							break
						}
					}
				}
			}
			err = FlowIncome(db, iccID, flow, unit, model.FlowIncomeTypeUser, order.OrderID)
			//冲进去之后重新计算流量超标
			sumIncome, _ := dao.GetSimFlowIncomeSum(db, iccID, monthBegin, monthEnd)
			sumExpend, _ := dao.GetSimFlowExpendSum(db, iccID, monthBegin, monthEnd)
			if sumIncome != nil && sumExpend != nil {
				if printer, err := dao.GetPrinter(db, "", iccID); err == nil && printer != nil {
					flowFlag := 0
					if sumIncome.Flow-sumExpend.Flow <= 0 {
						flowFlag = 1
					}
					printer.FlowFlag = flowFlag
					err = dao.Update(db, printer, "flow_flag")
				}
			}
			return err
		},
		model.OrderTypeCardValid: func(db *sqlx.DB, order *model.PayOrder) (err error) {
			_, err = api.TibiotAPI.Submit(order.ThingID, utils.Str2Int(order.TypeID))
			return err
		},
	}
)

func CreateOrder(tokenInfo *model.TokenInfo, orderType, origin, thingID, typeID string) (orderID string, err error) {
	var (
		db       = globals.GetDB()
		now      = time.Now()
		payPrice int64
	)
	if payPrice, err = findOrderPayPriceMap[orderType](db, typeID); err != nil {
		return "", err
	}
	globals.SugarLogger.Debugf("CreateOrder payPrice: %v", payPrice)
	orderID = utils.Int64ToStr(putils.GenOrderNo())
	payOrder := &model.PayOrder{
		CreatedAt: &now,
		OrderID:   orderID,
		PayPrice:  payPrice,
		UserID:    tokenInfo.User.UserID,
		OrderType: orderType,
		Origin:    origin,
		ThingID:   thingID,
		TypeID:    typeID,
	}
	err = dao.Insert(db, payOrder)
	return orderID, err
}

func Pay(tokenInfo *model.TokenInfo, orderID, payType, vendorPayType string) (order *model.PayOrder, err error) {
	var (
		db = globals.GetDB()
	)
	if order, err = dao.GetOrder(db, orderID); err != nil {
		return order, err
	}
	err = payFunc[payType](db, order, vendorPayType)
	return order, err
}

func PayTLCallback(call *tonglianpayapi.CallBackResult) (err error) {
	var (
		db      = globals.GetDB()
		orderID = call.CusorderID
	)
	if order, err := dao.GetOrder(db, orderID); err == nil {
		if order.Status != model.OrderStatusWaitPay {
			globals.SugarLogger.Debugf("already pay msg:%s, err:%v", utils.Format4Output(call, true), err)
			return err
		}
		loc, _ := time.LoadLocation("Local")
		t1, _ := time.ParseInLocation("20060102150405", call.PayTime, loc)
		order.PayFinishedAt = &t1
		data, _ := json.Marshal(call)
		dataStr := string(data)
		order.OriginalData = &dataStr
		if call.TrxStatus == tonglianpayapi.TrxStatusSuccess {
			order.Status = model.OrderStatusPaid
		} else {
			order.Status = model.OrderStatusPayFail
		}
		dao.Update(db, order, "status", "pay_finished_at", "original_data")
		if call.TrxStatus == tonglianpayapi.TrxStatusSuccess {
			err = OnPayFinished(order)
		}
	} else {
		globals.SugarLogger.Debugf("onTLpayFinished msg:%s, err:%v", utils.Format4Output(call, true), err)
	}
	return err
}

func OnPayFinished(order *model.PayOrder) (err error) {
	var (
		db = globals.GetDB()
	)
	err = payFinishedFunc[order.OrderType](db, order)
	if err != nil {
		order.Comment = err.Error()
		dao.Update(db, order, "Comment")
	}
	return err
}