package api

import (
	rawjson "encoding/json"
	"github.com/linmadan/egglib-go/utils/json"
	"time"

	"github.com/beego/beego/v2/client/httplib"
)

type MessageCode struct {
	Code int    `json:"code"`
	Msg  string `json:"msg"`
}

//Response 统一消息返回格式
type Response struct {
	MessageCode
	Data rawjson.RawMessage `json:"data"`
}

type BaseServiceGateway struct {
	ConnectTimeout   time.Duration
	ReadWriteTimeout time.Duration
	host             string
}

type Request struct {
	Url    string
	Method string
	Param  interface{}
}

func (gateway BaseServiceGateway) CreateRequest(url string, method string) *httplib.BeegoHTTPRequest {
	var request *httplib.BeegoHTTPRequest
	switch method {
	case "get", "GET":
		request = httplib.Get(url)
	case "post", "POST":
		request = httplib.Post(url)
	case "put", "PUT":
		request = httplib.Put(url)
	case "delete", "DELETE":
		request = httplib.Delete(url)
	case "head", "HEADER":
		request = httplib.Head(url)
	default:
		request = httplib.Get(url)
	}
	return request.SetTimeout(gateway.ConnectTimeout, gateway.ReadWriteTimeout)
}

func (gateway BaseServiceGateway) GetResponseData(result Response, data interface{}) error {
	err := json.Unmarshal(result.Data, data)
	if err != nil {
		return NewErrCodeMsg(JsonUnMarshError, err.Error())
	}
	return nil
}

func (gateway BaseServiceGateway) FastDoRequest(url, method string, param interface{}, data interface{}) error {
	err := gateway.DoRequest(Request{
		Url:    url,
		Method: method,
		Param:  param,
	}, &data)
	if err != nil {
		return err
	}
	return nil
}

func (gateway BaseServiceGateway) DoRequest(requestParam Request, val interface{}) error {
	r := gateway.CreateRequest(requestParam.Url, requestParam.Method)
	req, err := r.JSONBody(requestParam.Param)
	if err != nil {
		return err
	}
	byteResult, err := req.Bytes()
	if err != nil {
		return err
	}
	var result Response
	err = json.Unmarshal(byteResult, &result)
	if err != nil {
		return err
	}
	if result.Code != 0 && len(result.Msg) > 0 {
		return NewErrCodeMsg(result.Code, result.Msg)
	}
	return gateway.GetResponseData(result, val)
}

func (gateway BaseServiceGateway) Host() string {
	return gateway.host
}

func NewBaseServiceGateway(host string) BaseServiceGateway {
	return BaseServiceGateway{
		host: host,
	}
}