package httpclient

import (
	"context"

	"git.5iot.com/iotlcm-public/iotlcm-upstream-proxy/internal/pub/xjpubservice"

	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/gclient"
	"github.com/gogf/gf/v2/net/gsvc"
)

type sHttpClient struct {
	client *gclient.Client
}

func NewHttpClient() *sHttpClient {
	client := g.Client()
	return &sHttpClient{
		client: client,
	}
}

func init() {
	xjpubservice.RegisterHttpClient(NewHttpClient())
}

func (s *sHttpClient) PostObj(ctx context.Context, serviceName string, path string, req interface{}, res interface{}) (err error) {
	reqJson, err := gjson.Marshal(req)
	if err != nil {
		return err
	}
	resJson, err := s.Post(ctx, serviceName, path, reqJson)
	if err != nil {
		return err
	}
	err = gjson.Unmarshal(resJson, res)
	if err != nil {
		g.Log().Errorf(ctx, "sHttpClient.PostObj gjson.Unmarshal error: %v, resJson: %s", err, string(resJson))
		return err
	}
	g.Log().Debugf(ctx, "sHttpClient.PostObj res: %+v, resJson: %s", res, string(resJson))
	return nil
}

func (s *sHttpClient) Post(ctx context.Context, serviceName string, path string, req []byte) (res []byte, err error) {
	// s.client.SetHeader("Span-Id", "0.0.1")
	// s.client.SetHeader("Trace-Id", gctx.CtxId(ctx))

	url := "http://" + serviceName + path
	s.client.SetDiscovery(gsvc.GetRegistry())
	// g.Log().Debugf(ctx, "sHttpClient.Post url: %s, req: %+v", url, string(req))
	response, err := s.client.Post(ctx, url, req)
	if err != nil {
		g.Log().Errorf(ctx, "sHttpClient.Post Post error: %v,  url: %s, req: %+v", err, url, string(req))
		return nil, err
	}
	defer response.Close()
	res = response.ReadAll()
	g.Log().Debugf(ctx, "sHttpClient.Post url: %s, req: %+v, res: %+v", url, string(req), string(res))
	return res, nil
}

func (s *sHttpClient) AllServerPost(ctx context.Context, serviceName string, path string, req []byte) (resMap map[string][]byte, err error) {
	// s.client.SetHeader("Span-Id", "0.0.1")
	// s.client.SetHeader("Trace-Id", gctx.CtxId(ctx))
	s.client.SetDiscovery(gsvc.GetRegistry())

	servers, err := gsvc.Search(ctx, gsvc.SearchInput{
		Name: serviceName,
	})
	if len(servers) == 0 {
		g.Log().Errorf(ctx, "sHttpClient.AllServerPost gsvc.Search(ctx, serviceName) error: %v, serviceName: %s", err, serviceName)
		return nil, err
	}
	// g.Log().Debugf(ctx, "sHttpClient.AllServerPost servers: %+v", servers)
	endpoints := make([]string, 0)
	for _, server := range servers {
		endpoint := server.GetEndpoints()
		if len(endpoint) == 0 {
			g.Log().Errorf(ctx, "sHttpClient.AllServerPost server.GetEndpoints() error: %v, serviceName: %s", err, serviceName)
			continue
		}
		endpoints = append(endpoints, endpoint[0].String())
	}
	resMap = make(map[string][]byte)
	for _, e := range endpoints {
		url := "http://" + e + path
		res, err := s.Post(ctx, e, path, req)
		// g.Log().Debugf(ctx, "sHttpClient.AllServerPost Post url: %s, req: %+v res: %+v err: %+v", url, string(req), string(res), err)
		if err != nil {
			resMap[e] = nil
			g.Log().Errorf(ctx, "sHttpClient.AllServerPost Post error: %v, url: %s, req: %+v", err, url, string(req))
			continue
		}
		resMap[e] = res
	}
	return resMap, nil
}