package rchgutil

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"time"

	"91porn-server/app/appg"
	"91porn-server/common/httputil"
	"91porn-server/common/log"
)

type PayTypeParam struct {
	Moneys      []int64 `json:"moneys"`
	DevType     string  `json:"devType"`
	ProductType int     `json:"productType"` //产品类型 0站群 1棋牌
	UserLevel   int     `json:"userLevel"`   //限定用户层级 (0默认无等级 1充值成功过的1等级)
	PlatformID  string  `json:"platformID"`  //平台
}

type RchgType struct {
	Money      int64 `json:"money"`      //金额 单位 分
	Alipay     bool  `json:"alipay"`     //是否支持支付宝
	Wechat     bool  `json:"wechat"`     //是否支持微信
	Union      bool  `json:"union"`      //是否支持银联
	DaiChong   bool  `json:"daichong"`   //是否支持代充
	USDT       bool  `json:"usdt"`       //是否支持代充
	QuickUnion bool  `json:"quickUnion"` //是否支持快速银联
}

type StdMsg struct {
	Code int         `json:"code"`
	Msg  string      `json:"msg"`
	Data interface{} `json:"data"`
	Tip  string      `json:"tip"`
}

// GetPayType 从支付中心获取充值金额对应的充值方式
func GetPayType(ctx context.Context, moneys []int64, devType string, productType, userLevel int) ([]RchgType, error) {
	var errlog string
	p := PayTypeParam{
		moneys,
		devType,
		productType,
		userLevel,
		"91PORN",
	}
	res := StdMsg{}
	code, err := httputil.DefaultClientPostJsonWithResp(&res, p.GetURL(), nil, p.GetBody())
	if err != nil {
		errlog = fmt.Sprintf("bill GetPayType requset fail \nerror:%+v\n\ndata:%+v;", err, p)
		log.ErrorX(ctx, "get pay type in bill center failed", log.Any("param", p), log.Any("url", p.GetURL()),
			log.E(err))
		return nil, errors.New(errlog)
	}
	if code != http.StatusOK {
		errlog = fmt.Sprintf("bill GetPayType response status exception;\nstatus %+v;", code)
		log.ErrorX(ctx, errlog, log.Any("code", code))
		return nil, errors.New(errlog)
	}
	if res.Code != 200 {
		errlog = fmt.Sprintf("bill GetPayType be rejected;\n err:%+v:", res)
		log.ErrorX(ctx, errlog, log.Any("res", res))
		return nil, errors.New(errlog)
	}
	bytes, err := json.Marshal(res.Data)
	if err != nil {
		errlog = fmt.Sprintf("bill payUrl urlDecode fail \nerror:%+v;", err)
		log.Error(errlog)
		return nil, errors.New(errlog)
	}
	var payTypes []RchgType
	if err = json.Unmarshal(bytes, &payTypes); err != nil {
		errlog = fmt.Sprintf("bill payUrl urlDecode fail \nerror:%+v;", err)
		log.ErrorX(ctx, errlog, log.E(err))
		return nil, errors.New(errlog)
	}
	log.InfoX(ctx, "bill GetPayType data", log.Any("res", res))
	return payTypes, nil
}

// GetBody 获取请求body
func (this *PayTypeParam) GetBody() []byte {
	data, err := json.Marshal(this)
	if err != nil {
		log.Info(fmt.Sprintf("bill GetBody json.Marshal is fail error:%+v/data:%+v", err, this))
		return nil
	}
	return data
}

// GetURL 获取请求地址
func (*PayTypeParam) GetURL() string {
	return appg.Conf.URL.TransactionUrl + "/api/recharge/payType"
}

var (
	PayErrPostFailure  = errors.New("recharge http post failure")
	PayErrResponseCode = errors.New("recharge http code isn't 200")
	PayErrBeRejected   = errors.New("recharge has been rejected")
)

// GetBody 获取请求body
func (this *Rchg) ToPayNew(ctx context.Context) (res RchgMsg, err error) {
	defer func() {
		log.InfoX(ctx, "bill ToPayNew request info end 2", log.Any("transNo", this.TransNo), log.Any("res", res))
		if err := recover(); err != nil {
			log.ErrorX(ctx, "bill ToPayNew recover", log.Any("Rchg", this), log.Any("panic", err))
		}
	}()
	this.fill()
	param, err := json.Marshal(this)
	if err != nil {
		log.ErrorX(ctx, "bill ToPayNew json.Marshal failed,", log.Any("transNo", this.TransNo), log.E(err))
		return
	}
	log.InfoX(ctx, "ToPayNew request info start", log.Any("transNo", this.TransNo), log.Any("param", string(param)))
	startS := time.Now().UnixNano()
	code, err := httputil.DefaultClientPostJsonWithResp(&res, this.GetURL(), nil, param)
	log.InfoX(ctx, "ToPayNew POST resp ", log.Any("code", code), log.Any("transNo", this.TransNo),
		log.Any("param", string(param)), log.Any("topay-bill-time cost", time.Now().UnixNano()-startS))
	if err != nil {
		log.ErrorX(ctx, "bill ToPayNew post failed", log.Any("transNo", this.TransNo), log.E(err))
		err = PayErrPostFailure
		return
	}
	if code != http.StatusOK {
		log.ErrorX(ctx, "bill ToPayNew bad http statusCode", log.Any("transNo", this.TransNo), log.Any("statusCode", code))
		err = PayErrResponseCode
		return
	}
	if res.Err != "" {
		log.ErrorX(ctx, "bill ToPayNew has been rejected", log.Any("transNo", this.TransNo), log.Any("res err", res.Err))
		err = PayErrBeRejected
		return
	}
	log.InfoX(ctx, "bill ToPayNew request info end", log.Any("transNo", this.TransNo), log.Any("res", res))
	return
}

// GetURL 获取请求地址
func (this *Rchg) fill() {
	this.PlatformID = "91PORN"
	if this.ProductType == 0 {
		this.TransNo = RChgIDAssemble(this.TransNo)
	}
	if this.ProductType == 1 {
		this.TransNo = RChgWLIDAssemble(this.TransNo)
	}
	this.NotifyUrl = appg.Conf.URL.LocalWebUrl + RCHG_NOTIFY_URL + "bill"
	this.PType = this.PayMethod
}

// GetURL 获取请求地址
func (*Rchg) GetURL() string {
	return appg.Conf.URL.TransactionUrl + "/api/recharge/recharge"
}

// GetBody 获取请求body
func (this *RchgBack) Notify() (RchgBack, error) {
	return *this, nil
}

// GetBody 获取请求body
func (this *RchgBack) Success() string {
	return "success"
}