package gs

import (
	"server/call"
	"server/common"
	"server/db"
	"server/modules/web/app"
	"server/modules/web/providers/base"
	"server/util"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
)

func GS(e *gin.RouterGroup) {
	e.POST("/Seamless/GetBalance", GetBalance)
	e.POST("/Seamless/PlaceBet", PlaceBet)
	e.POST("/Seamless/GameResult", GameResult)
	e.POST("/Seamless/Rollback", Rollback)
	e.POST("/Seamless/CancelBet", CancelBet)
	e.POST("/Seamless/Bonus", Bonus)
	e.POST("/Seamless/Jackpot", Jackpot)
	e.POST("/Seamless/MobileLogin", MobileLogin)
	e.POST("/Seamless/BuyIn", BuyIn)
	e.POST("/Seamless/BuyOut", BuyOut)
	e.POST("/Seamless/PushBet", PushBet)
}

func VerifySign(operatorCode, reqTime, name, sign string) bool {
	agent := GetAgentByCode(operatorCode)
	if agent == nil {
		return false
	}
	return util.CalculateMD5(agent.OperatorCode+reqTime+name+agent.SecretKey) == sign
}

func GetGameID(providerID int, gameCode string) int {
	if providerID == common.ProviderEvolutionGaming || providerID == common.ProviderAllBet || providerID == common.ProviderBigGaming || providerID == common.ProviderSAGaming {
		return 1
	}
	game := call.GetConfigGameListByCode(providerID, gameCode)
	if game != nil {
		return game.GameID
	}
	return 0
}

func GetBalance(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &GetBalanceReq{}
	resp := &CommonResp2{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("GetBalance:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "getbalance", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		log.Error("err:%v", err)
		resp.ErrorCode = CodeAPIError
		return
	}

	currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
	if err != nil {
		log.Error("err:%v", err)
		resp.ErrorCode = CodeInnerError
		return
	}

	resp.Balance = call.GetUserCurrencyFloat(uid, common.CurrencyType(currency), 4)
}

func PlaceBet(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &CommonReq{}
	resp := &CommonResp{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("PlaceBet:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "placebet", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	now := time.Now().Unix()
	for _, v := range req.Transactions {
		// if v.TransactionAmount == 0 {
		// 	resp.Balance = call.GetUserCurrencyFloat(uid, ct, 4)
		// 	if resp.BeforeBalance == 0 {
		// 		resp.BeforeBalance = resp.Balance
		// 	}
		// 	continue
		// }

		ct := CurrencyIDMap[v.CurrencyID]
		if !ct.IsValid() {
			currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
			if err != nil {
				log.Error("err:%v", err)
				continue
			}
			ct = common.CurrencyType(currency)
		}
		providerID := ProviderIDMap[v.ProductID]
		provider := call.GetConfigGameProvider(providerID)
		if provider == nil {
			resp.ErrorCode = CodeInnerError
			return
		}
		betReq := &base.BetReq{
			UID:          uid,
			CurrencyType: ct,
			BetAmount:    -int64(v.TransactionAmount * common.DecimalDigits),
			TurnOver:     int64(v.ValidBetAmount * common.DecimalDigits),
			SessionType:  base.SessionTypeBet,
			GameID:       GetGameID(providerID, v.GameID),
			GameName:     v.GameID,
			Provider:     provider,
			BetID:        v.TransactionID,
			SessionID:    v.GameRoundID,
			Time:         now,
		}
		betResp := base.SessionBet(betReq)
		if betResp.Code != base.CodeOk {
			resp.ErrorCode = CodeAPIError
			if betResp.Code == base.CodeAccepted {
				resp.ErrorCode = CodeAPIDuplicateTransaction
			} else if betResp.Code == base.CodeNotEnoughAmount {
				resp.ErrorCode = CodeAPIMemberInsufficientBalance
			}
			return
		}
		resp.Balance = util.Decimal(float64(betResp.Balance)/common.DecimalDigits, 4)
		if resp.BeforeBalance == 0 {
			resp.BeforeBalance = util.Decimal(float64(betResp.Balance+betReq.BetAmount)/common.DecimalDigits, 4)
		}
	}
}

func GameResult(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &CommonReq{}
	resp := &CommonResp{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("GameResult:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "gameresult", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	provider := call.GetConfigGameProvider(ProviderIDMap[int(req.ProductID)])
	if provider == nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	now := time.Now().Unix()

	for _, v := range req.Transactions {
		ct := CurrencyIDMap[v.CurrencyID]
		if !ct.IsValid() {
			currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
			if err != nil {
				log.Error("err:%v", err)
				continue
			}
			ct = common.CurrencyType(currency)
		}
		settleReq := &base.SettleReq{
			UID:          uid,
			CurrencyType: ct,
			SettleAmount: int64(v.TransactionAmount * common.DecimalDigits),
			BetAmount:    int64(v.BetAmount * common.DecimalDigits),
			TurnOver:     int64(v.ValidBetAmount * common.DecimalDigits),
			GameID:       GetGameID(provider.ProviderID, v.GameID),
			GameName:     v.GameID,
			Provider:     provider,
			BetID:        v.TransactionID,
			SessionID:    v.GameRoundID,
			Time:         now,
		}
		settleResp := base.Settle(settleReq)
		if settleResp.Code != base.CodeOk {
			resp.ErrorCode = CodeAPIError
			if settleResp.Code == base.CodeAccepted {
				resp.ErrorCode = CodeAPIDuplicateTransaction
			} else if settleResp.Code == base.CodeBetNotExist {
				resp.ErrorCode = CodeAPIBetNotExist
			}
			return
		}
		resp.Balance = util.Decimal(float64(settleResp.Balance)/common.DecimalDigits, 4)
		if resp.BeforeBalance == 0 {
			resp.BeforeBalance = util.Decimal(float64(settleResp.Balance-settleReq.SettleAmount)/common.DecimalDigits, 4)
		}
	}
}

func Rollback(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &CommonReq{}
	resp := &CommonResp{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("Rollback:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "rollback", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}
	provider := call.GetConfigGameProvider(ProviderIDMap[int(req.ProductID)])
	if provider == nil {
		resp.ErrorCode = CodeAPIError
		return
	}
	for _, v := range req.Transactions {
		ct := CurrencyIDMap[v.CurrencyID]
		if !ct.IsValid() {
			currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
			if err != nil {
				log.Error("err:%v", err)
				continue
			}
			ct = common.CurrencyType(currency)
		}
		adjustResp := base.Adjustment(&base.AdjustmentReq{
			UID:          uid,
			CurrencyType: ct,
			Amount:       int64(v.TransactionAmount * common.DecimalDigits),
			GameID:       GetGameID(provider.ProviderID, v.GameID),
			GameName:     v.GameID,
			Provider:     provider,
			BetID:        v.TransactionID,
			Time:         time.Now().Unix(),
			SessionID:    v.GameRoundID,
			Type:         base.SessionTypeAdjustment,
		})
		if adjustResp.Code != base.CodeOk {
			resp.ErrorCode = CodeAPIError
			if adjustResp.Code == base.CodeAccepted {
				resp.ErrorCode = CodeAPIDuplicateTransaction
			}
			return
		}
		resp.Balance = util.Decimal(float64(adjustResp.Balance)/common.DecimalDigits, 4)
		if resp.BeforeBalance == 0 {
			resp.BeforeBalance = util.Decimal(float64(adjustResp.BeforeBalance)/common.DecimalDigits, 4)
		}
	}
}

func CancelBet(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &CommonReq{}
	resp := &CommonResp{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("CancelBet:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "cancelbet", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}
	provider := call.GetConfigGameProvider(ProviderIDMap[int(req.ProductID)])
	if provider == nil {
		resp.ErrorCode = CodeAPIError
		return
	}
	for _, v := range req.Transactions {
		ct := CurrencyIDMap[v.CurrencyID]
		if !ct.IsValid() {
			currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
			if err != nil {
				log.Error("err:%v", err)
				continue
			}
			ct = common.CurrencyType(currency)
		}
		adjustResp := base.Adjustment(&base.AdjustmentReq{
			UID:          uid,
			CurrencyType: ct,
			// TurnOver:     int64(v.ValidBetAmount * common.DecimalDigits),
			// SessionType:  base.SessionTypeBet,
			Amount:    int64(v.TransactionAmount * common.DecimalDigits),
			GameID:    GetGameID(provider.ProviderID, v.GameID),
			GameName:  v.GameID,
			Provider:  provider,
			BetID:     v.TransactionID,
			SessionID: v.GameRoundID,
			Time:      time.Now().Unix(),
			Type:      base.SessionTypeAdjustment,
		})
		if adjustResp.Code != base.CodeOk {
			resp.ErrorCode = CodeAPIError
			if adjustResp.Code == base.CodeAccepted {
				resp.ErrorCode = CodeAPIDuplicateTransaction
			}
			return
		}
		resp.Balance = util.Decimal(float64(adjustResp.Balance)/common.DecimalDigits, 4)
		if resp.BeforeBalance == 0 {
			resp.BeforeBalance = util.Decimal(float64(adjustResp.BeforeBalance)/common.DecimalDigits, 4)
		}
	}
}

func Bonus(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &CommonReq{}
	resp := &CommonResp{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("Bonus:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "bonus", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	provider := call.GetConfigGameProvider(ProviderIDMap[int(req.ProductID)])
	if provider == nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	now := time.Now().Unix()
	for _, v := range req.Transactions {
		ct := CurrencyIDMap[v.CurrencyID]
		if !ct.IsValid() {
			currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
			if err != nil {
				log.Error("err:%v", err)
				continue
			}
			ct = common.CurrencyType(currency)
		}
		giftResp := base.Adjustment(&base.AdjustmentReq{
			UID:          uid,
			CurrencyType: common.CurrencyType(ct),
			Amount:       int64(v.TransactionAmount * common.DecimalDigits),
			GameID:       GetGameID(provider.ProviderID, v.GameID),
			GameName:     v.GameID,
			Provider:     provider,
			BetID:        v.TransactionID,
			SessionID:    v.GameRoundID,
			Time:         now,
			Type:         base.SessionTypeBonus,
		})
		if giftResp.Code != base.CodeOk {
			resp.ErrorCode = CodeAPIError
			if giftResp.Code == base.CodeAccepted {
				resp.ErrorCode = CodeAPIDuplicateTransaction
			}
			return
		}
		resp.Balance = util.Decimal(float64(giftResp.Balance)/common.DecimalDigits, 4)
		if resp.BeforeBalance == 0 {
			resp.BeforeBalance = util.Decimal(float64(giftResp.BeforeBalance)/common.DecimalDigits, 4)
		}
	}
}

func Jackpot(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &CommonReq{}
	resp := &CommonResp{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("Jackpot:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "jackpot", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	provider := call.GetConfigGameProvider(ProviderIDMap[int(req.ProductID)])
	if provider == nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	now := time.Now().Unix()
	for _, v := range req.Transactions {
		ct := CurrencyIDMap[v.CurrencyID]
		if !ct.IsValid() {
			currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
			if err != nil {
				log.Error("err:%v", err)
				continue
			}
			ct = common.CurrencyType(currency)
		}
		giftResp := base.Adjustment(&base.AdjustmentReq{
			UID:          uid,
			CurrencyType: common.CurrencyType(ct),
			Amount:       int64(v.TransactionAmount * common.DecimalDigits),
			GameID:       GetGameID(provider.ProviderID, v.GameID),
			GameName:     v.GameID,
			Provider:     provider,
			BetID:        v.TransactionID,
			SessionID:    v.GameRoundID,
			Time:         now,
			Type:         base.SessionTypeJackpot,
		})
		if giftResp.Code != base.CodeOk {
			resp.ErrorCode = CodeAPIError
			if giftResp.Code == base.CodeAccepted {
				resp.ErrorCode = CodeAPIDuplicateTransaction
			}
			return
		}
		resp.Balance = util.Decimal(float64(giftResp.Balance)/common.DecimalDigits, 4)
		if resp.BeforeBalance == 0 {
			resp.BeforeBalance = util.Decimal(float64(giftResp.BeforeBalance)/common.DecimalDigits, 4)
		}
	}
}

func MobileLogin(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &GetBalanceReq{}
	resp := &CommonResp2{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("MobileLogin:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "mobilelogin", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
	if err != nil {
		log.Error("err:%v", err)
		resp.ErrorCode = CodeInnerError
		return
	}

	resp.Balance = call.GetUserCurrencyFloat(uid, common.CurrencyType(currency), 4)
}

func BuyIn(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &BuyInReq{}
	resp := &CommonResp{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("BuyIn:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "buyin", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	ct := CurrencyIDMap[req.Transaction.CurrencyID]
	if !ct.IsValid() {
		currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
		if err != nil {
			log.Error("err:%v", err)
			resp.ErrorCode = CodeInnerError
			return
		}
		ct = common.CurrencyType(currency)
	}
	provider := call.GetConfigGameProvider(ProviderIDMap[int(req.ProductID)])
	if provider == nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	now := time.Now().Unix()
	giftResp := base.Adjustment(&base.AdjustmentReq{
		UID:          uid,
		CurrencyType: common.CurrencyType(ct),
		Amount:       int64(req.Transaction.TransactionAmount * common.DecimalDigits),
		GameID:       GetGameID(provider.ProviderID, req.Transaction.GameID),
		GameName:     req.Transaction.GameID,
		Provider:     provider,
		BetID:        req.Transaction.TransactionID,
		SessionID:    req.Transaction.GameRoundID,
		Time:         now,
		Type:         base.SessionTypeBuyIn,
	})
	if giftResp.Code != base.CodeOk {
		resp.ErrorCode = CodeAPIError
		if giftResp.Code == base.CodeAccepted {
			resp.ErrorCode = CodeAPIDuplicateTransaction
		} else if giftResp.Code == base.CodeNotEnoughAmount {
			resp.ErrorCode = CodeAPIMemberInsufficientBalance
		}
		return
	}
	resp.Balance = util.Decimal(float64(giftResp.Balance)/common.DecimalDigits, 4)
	resp.BeforeBalance = util.Decimal(float64(giftResp.BeforeBalance)/common.DecimalDigits, 4)
}

func BuyOut(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &BuyOutReq{}
	resp := &CommonResp{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("BuyOut:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "buyout", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	ct := CurrencyIDMap[req.Transaction.CurrencyID]
	if !ct.IsValid() {
		currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
		if err != nil {
			log.Error("err:%v", err)
			resp.ErrorCode = CodeInnerError
			return
		}
		ct = common.CurrencyType(currency)
	}
	provider := call.GetConfigGameProvider(ProviderIDMap[int(req.ProductID)])
	if provider == nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	now := time.Now().Unix()
	giftResp := base.Adjustment(&base.AdjustmentReq{
		UID:          uid,
		CurrencyType: common.CurrencyType(ct),
		Amount:       int64(req.Transaction.TransactionAmount * common.DecimalDigits),
		GameID:       GetGameID(provider.ProviderID, req.Transaction.GameID),
		GameName:     req.Transaction.GameID,
		Provider:     provider,
		BetID:        req.Transaction.TransactionID,
		SessionID:    req.Transaction.GameRoundID,
		Time:         now,
		Type:         base.SessionTypeBuyOut,
	})
	if giftResp.Code != base.CodeOk {
		resp.ErrorCode = CodeAPIError
		if giftResp.Code == base.CodeAccepted {
			resp.ErrorCode = CodeAPIDuplicateTransaction
		}
		return
	}
	resp.Balance = util.Decimal(float64(giftResp.Balance)/common.DecimalDigits, 4)
	resp.BeforeBalance = util.Decimal(float64(giftResp.BeforeBalance)/common.DecimalDigits, 4)
}

func PushBet(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.ResponseB()
	}()
	req := &CommonReq{}
	resp := &CommonResp2{}
	a.RetData = resp
	if !a.SB(req) {
		resp.ErrorCode = CodeAPIError
		return
	}
	log.Debug("PushBet:%+v", req)

	if !VerifySign(req.OperatorCode, req.RequestTime, "pushbet", req.Sign) {
		resp.ErrorCode = CodeAPIInvalidSign
		return
	}

	uid, err := strconv.Atoi(req.MemberName)
	if err != nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	provider := call.GetConfigGameProvider(ProviderIDMap[int(req.ProductID)])
	if provider == nil {
		resp.ErrorCode = CodeAPIError
		return
	}

	now := time.Now().Unix()
	for _, v := range req.Transactions {
		ct := CurrencyIDMap[v.CurrencyID]
		if !ct.IsValid() {
			currency, err := db.Redis().GetInt(common.GetRedisKeyGameCurrency(uid))
			if err != nil {
				log.Error("err:%v", err)
				continue
			}
			ct = common.CurrencyType(currency)
		}
		if v.TransactionID != "" {
			pushReq := &base.PushDetailReq{
				UID:          uid,
				CurrencyType: ct,
				SettleAmount: int64(v.PayoutAmount * common.DecimalDigits),
				BetAmount:    int64(v.BetAmount * common.DecimalDigits),
				TurnOver:     int64(v.ValidBetAmount * common.DecimalDigits),
				GameID:       GetGameID(provider.ProviderID, v.GameID),
				GameName:     v.GameID,
				Provider:     provider,
				BetID:        v.TransactionID,
				SessionID:    v.GameRoundID,
				Time:         now,
			}
			pushDetailResp := base.PushDetail(pushReq)
			resp.Balance = util.Decimal(float64(pushDetailResp.Balance)/common.DecimalDigits, 4)
		} else {
			resp.Balance = call.GetUserCurrencyFloat(uid, ct, 4)
		}
	}
}