package server

import (
	"encoding/hex"
	"io"
	v1 "sandc/api/eonline/v1"
	"strings"

	nethttp "net/http"

	"github.com/go-kratos/kratos/v2/errors"
	"github.com/go-kratos/kratos/v2/transport/http"
	"github.com/google/wire"
	"github.com/xxtea/xxtea-go/xxtea"
)

// EncryptKey is the key for encryption
const DecryptKey = "tk423&(gBUjX#$s0628"

// ProviderSet is server providers.
var ProviderSet = wire.NewSet(NewHTTPServer, NewGRPCServer, NewRegistrar, NewDiscovery, NewAsynqServer)

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

// DefaultErrorEncoder encodes the error to the HTTP response
func DefaultErrorEncoder(w nethttp.ResponseWriter, r *nethttp.Request, err error) {
	se := errors.FromError(err)
	codec, _ := http.CodecForRequest(r, "Accept")
	reply := ResData{
		Code: int(se.Code),
		Msg:  se.Message,
		Data: nil,
	}

	// if strings.Contains(se.Message, "email not support") {
	// 	reply.Code = 1
	// }

	// if strings.Contains(se.Message, "no payout chance") {
	// 	reply.Code = 1
	// }

	body, err := codec.Marshal(reply)
	if err != nil {
		//给出自定义code
		w.WriteHeader(nethttp.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", strings.Join([]string{"application", codec.Name()}, "/"))
	w.WriteHeader(200)

	//加密
	if r.Header.Get("encrypt") == "true" {
		s := xxtea.Encrypt(body, []byte(DecryptKey))
		body = []byte(hex.EncodeToString(s))
	}

	_, _ = w.Write(body)
}

// DefaultResponseEncoder encodes the object to the HTTP response.
func DefaultResponseEncoder(w nethttp.ResponseWriter, r *nethttp.Request, v interface{}) error {
	codec, _ := http.CodecForRequest(r, "Accept")

	//断言接口类型
	if _, ok := v.(*v1.PayoutCallbackReply); ok {
		w.Write([]byte("success"))
		return nil
	}
	dv := v
	data, err := codec.Marshal(dv)
	if err != nil {
		return err
	}

	reply := struct {
		Code int    `json:"code"`
		Msg  string `json:"msg"`
	}{
		Code: 0,
		Msg:  "sucess",
	}

	replyData, err := codec.Marshal(reply)
	if err != nil {
		return err
	}
	//fmt.Println(string(data))
	var newData = make([]byte, 0, len(replyData)+len(data)+8)
	newData = append(newData, replyData[:len(replyData)-1]...)
	newData = append(newData, []byte(`,"data":`)...)
	newData = append(newData, data...)
	newData = append(newData, '}')

	w.Header().Set("Content-Type", "application/json")

	if r.Header.Get("encrypt") == "true" {
		s := xxtea.Encrypt(newData, []byte(DecryptKey))
		newData = []byte(hex.EncodeToString(s))
	}

	_, err = w.Write(newData)
	if err != nil {
		return err
	}
	return nil
}

func DefaultRequestDecoder(r *http.Request, v interface{}) error {
	codec, ok := http.CodecForRequest(r, "Content-Type")
	if !ok {
		return errors.BadRequest("CODEC", r.Header.Get("Content-Type"))
	}
	data, err := io.ReadAll(r.Body)
	if err != nil {
		return errors.BadRequest("CODEC", err.Error())
	}
	_ = r.Body.Close()
	if r.Header.Get("encrypt") == "true" {
		if r.Header.Get("params") != "" {
			p, _ := hex.DecodeString(r.Header.Get("params"))
			data = xxtea.Decrypt(p, []byte(DecryptKey))
		} else {
			data = []byte("{}")
		}
	}

	if err = codec.Unmarshal(data, v); err != nil {
		return errors.BadRequest("CODEC", err.Error())
	}
	return nil
}