package base

import (
	"encoding/json"
	"io"
	"net/http"
	"net/url"
	"reflect"
	"server/call"
	"server/common"
	"server/db"
	"server/modules/pay/values"

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

func (b *Base) PayCallback(c *gin.Context) {
	str, err := b.Callback(c)
	defer func() {
		c.String(http.StatusOK, b.CallbackResp.Msg)
	}()
	if err != nil {
		log.Error("err:%v", err)
		b.CallbackResp.Msg = "callback fail"
		return
	}
	b.C = c
	if !b.CheckSign(str) {
		log.Error("check sign fail")
		b.CallbackResp.Msg = "callback fail"
		return
	}
	orderID := b.CallbackResp.OrderID
	or := &common.RechargeOrder{OrderID: orderID}
	db.Mysql().Get(or)
	if or.ID == 0 {
		log.Error("order:%v not exist", orderID)
		return
	}
	if or.Status == common.StatusROrderPay {
		log.Error("order:%v exec done", orderID)
		return
	}
	success := b.CallbackResp.Success
	if err := call.RechargeCallback(or, success, "", ""); err != nil {
		b.CallbackResp.Msg = "callback fail"
		return
	}
	if success {
		values.PayCallback(b.Channel)
	}
}

func (b *Base) WithdrawCallback(c *gin.Context) {
	str, err := b.Callback(c)
	defer func() {
		c.String(http.StatusOK, b.CallbackResp.Msg)
	}()
	if err != nil {
		log.Error("err:%v", err)
		b.CallbackResp.Msg = "callback fail"
		return
	}
	b.C = c
	if !b.CheckSign(str) {
		log.Error("check sign fail")
		b.CallbackResp.Msg = "callback fail"
		return
	}
	orderID := b.CallbackResp.OrderID
	or := &common.WithdrawOrder{OrderID: orderID}
	db.Mysql().Get(or)
	if or.ID == 0 {
		log.Error("order:%v not exist", orderID)
		return
	}
	if or.PayChannel != int(b.Channel) {
		log.Error("order:%v,pay channel:%v,this channel:%v", orderID, or.PayChannel, b.Channel)
		return
	}
	if or.APIPayID == "" {
		or.APIPayID = b.CallbackResp.APIOrderID
	}
	success := b.CallbackResp.Success
	or.FailReason = b.CallbackResp.FailMessage
	if success {
		or.Status = common.StatusROrderFinish
	} else {
		or.Status = common.StatusROrderFail
	}
	if err := call.WithdrawCallback(or); err != nil {
		b.CallbackResp.Msg = "callback fail"
		return
	}
	if !success {
		values.WithdrawAmount(values.PayWay(or.PayChannel), false, or.Amount*100)
	}
}

func (b *Base) Callback(c *gin.Context) (str string, err error) {
	if b.HttpType == HttpTypeJson {
		str, err = b.CallbackJson(c)
	} else if b.HttpType == HttpTypeForm {
		str, err = b.CallbackForm(c)
	} else if b.HttpType == HttpTypeGet {
		str, err = b.CallbackGet(c)
	}
	return
}

func (b *Base) CallbackJson(c *gin.Context) (str string, err error) {
	var tmp []byte
	tmp, err = io.ReadAll(c.Request.Body)
	defer func() {
		c.Request.Body.Close()
	}()
	if err != nil {
		log.Error("err:%v", err)
		return
	}
	str = string(tmp)
	log.Debug("Callback body:%v", str)
	if b.SubCallbackDecode != nil {
		return b.SubCallbackDecode(tmp)
	}
	err = json.Unmarshal(tmp, b.CallbackReq)
	if err != nil {
		log.Error("err:%v", err)
		return
	}
	return
}

func (b *Base) CallbackForm(c *gin.Context) (str string, err error) {
	if err = c.ShouldBind(b.CallbackReq); err != nil {
		return "", err
	}
	// req := b.CallbackReq
	// typ := reflect.TypeOf(req).Elem()
	// val := reflect.ValueOf(req).Elem()
	// for i := 0; i < typ.NumField(); i++ {
	// 	if val.Field(i).Kind() == reflect.Int64 {
	// 		tmp, _ := strconv.ParseInt(c.Query(typ.Field(i).Tag.Get("json")), 10, 64)
	// 		val.Field(i).SetInt(tmp)
	// 	} else {
	// 		val.Field(i).SetString(c.Query(typ.Field(i).Tag.Get("json")))
	// 	}
	// }
	str = values.GetSignStrForm(c, b.SignPassStr...)
	return
}

func (b *Base) CallbackGet(c *gin.Context) (str string, err error) {
	raw, err := url.ParseQuery(c.Request.URL.RawQuery)
	if err != nil {
		log.Error("err:%v", err)
	}
	b.GetResp = raw
	req := b.CallbackReq
	typ := reflect.TypeOf(req).Elem()
	val := reflect.ValueOf(req).Elem()
	for i := 0; i < typ.NumField(); i++ {
		if val.Field(i).Kind() != reflect.String {
			continue
		}
		val.Field(i).SetString(b.GetResp.Get(typ.Field(i).Tag.Get("json")))
	}
	str = GetSignStrGet(b.GetResp, "sign")
	return
}