package seller

import (
	"Wine-Server/utils"
	"Wine-Server/utils/tables"
	"encoding/json"
	"errors"
	"github.com/gin-gonic/gin"
	"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
	"github.com/wechatpay-apiv3/wechatpay-go/core/downloader"
	"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
)

func updateWineIncome(trade *tradeRedis) (uint16, error) {
	wine := tables.WineTable{Id: trade.Wine}
	err := wine.Get()
	if err != nil {
		utils.Logger.Println("wine get error:", err)
		return 0, err
	}
	wine.Income += uint64(trade.Cash)
	wine.Order++
	err = wine.UpdateSelf()
	if err != nil {
		utils.Logger.Println("wine update error:", err)
		return 0, err
	}
	return uint16(50*float64(trade.Weight)/float64(wine.Density)/1000 + 0.5), nil
}

func updateDeviceIncome(trade *tradeRedis, volume uint16) (string, error) {
	table := tables.DeviceTable{Id: trade.Device}
	err := table.Get()
	if err != nil {
		utils.Logger.Println("device get error:", err)
		return "", err
	}
	table.Order++
	table.Income += uint64(trade.Cash)
	table.Wines[trade.Cell].Remain -= volume
	err = table.UpdateSelf()
	if err != nil {
		utils.Logger.Println("device update error:", err)
		return "", err
	}

	return table.Manager, nil
}

func updateManagerIncome(mid string, trade *tradeRedis) error {
	if mid == "" {
		utils.Logger.Println("blank manager id")
		return errors.New("blank manager id")
	}
	table := tables.ManagerTable{Id: mid}
	err := table.Get()
	if err != nil {
		utils.Logger.Println("manager get error:", err)
		return err
	}
	table.Order++
	table.Income += uint64(trade.Cash)
	err = table.UpdateSelf()
	if err != nil {
		utils.Logger.Println("manager update error:", err)
		return err
	}
	return nil
}

func wxPayHandler(ctx *gin.Context) {
	err := downloader.MgrInstance().RegisterDownloaderWithPrivateKey(
		utils.WxPayCli, utils.WxPrivateKey, utils.WxCertSeq, utils.WxMchId, utils.WxV3Key,
	)
	visitor := downloader.MgrInstance().GetCertificateVisitor(utils.WxMchId)
	handler, _ := notify.NewRSANotifyHandler(utils.WxV3Key, verifiers.NewSHA256WithRSAVerifier(visitor))
	var wxNotify notifyParam
	_, err = handler.ParseNotifyRequest(utils.WxPayCli, ctx.Request, &wxNotify)
	if wxNotify.TradeState != "SUCCESS" {
		utils.Logger.Printf("trade[%s] status[%s]\n", wxNotify.TradeNo, wxNotify.TradeState)
		ctx.JSON(utils.HttpOk, utils.Success(nil))
		return
	}
	dbKey := utils.Format("WxPay_%s", wxNotify.TradeNo)
	exist, err := utils.Redis.Exists(utils.WxPayCli, dbKey).Result()
	if exist != 1 {
		utils.Logger.Println("re-notified or expire of:", wxNotify.TradeNo)
		ctx.JSON(utils.HttpOk, utils.Success(nil))
		return
	}
	res, err := utils.Redis.Get(utils.WxPayCli, dbKey).Result()
	var dbTrade tradeRedis
	err = json.Unmarshal([]byte(res), &dbTrade)
	utils.Redis.Del(utils.WxPayCli, dbKey)

	volume, err := updateWineIncome(&dbTrade)
	manager, err := updateDeviceIncome(&dbTrade, volume)
	err = updateManagerIncome(manager, &dbTrade)
	wine := tables.WineTable{Id: dbTrade.Wine}
	_ = wine.Get()

	table := tables.TradeTable{
		Id: wxNotify.TransactionId, Trade: wxNotify.TradeNo, Device: dbTrade.Device, Payer: wxNotify.Payer.Openid,
		Wine: dbTrade.Wine, Price: wine.Price, Weight: dbTrade.Weight, Cash: dbTrade.Cash, Manager: manager,
	}
	err = table.Insert()
	if err != nil {
		ctx.JSON(utils.HttpError, utils.Fail("server error"))
		return
	}
	if device, din := utils.SellerDevices[dbTrade.Device]; din && device.Online {
		_ = device.Conn.WriteJSON(utils.WsEvent("qrcodeScanned", nil))
		utils.Sleep(1)
		_ = device.Conn.WriteJSON(utils.WsEvent("orderPayed", volume))
		ctx.JSON(utils.HttpOk, utils.Success(nil))
		return
	}
	ctx.JSON(utils.HttpError, utils.Fail("server error"))
}