package pkg

import (
	"bytes"
	"context"
	"fmt"
	"gitee.com/ltotal/traces/sky"
	"github.com/SkyAPM/go2sky"
	"io"
	"mime/multipart"
	"net/http"
	"net/url"
	agentV3 "skywalking.apache.org/repo/goapi/collect/language/agent/v3"
	"strconv"
	"strings"
	"time"
)

const (
	defaultTimeout = 10
)

type HttpPkg struct {
	header      map[string]string
	timeout     int
	contentType string
}

var Http = &HttpPkg{}

func NewHttp() *HttpPkg {
	return &HttpPkg{
		header:      nil,
		timeout:     10,
		contentType: "urlencoded",
	}
}

func (p *HttpPkg) WithHeader(header map[string]string) *HttpPkg {
	p.header = header
	return p
}

func (p *HttpPkg) WithTimeout(timeout int) *HttpPkg {
	p.timeout = timeout
	return p
}

func (p *HttpPkg) WithContentType(contentType string) *HttpPkg {
	p.contentType = contentType
	return p
}

func (p *HttpPkg) Request(c context.Context, link string, params map[string]interface{}, method string) (result string, err error) {
	if p.timeout <= 0 {
		p.timeout = defaultTimeout
	}
	if method == http.MethodGet {
		queryParams := url.Values{}
		for key, value := range params {
			queryParams.Add(key, fmt.Sprintf("%v", value))
		}
		link += "?" + queryParams.Encode()
		result, err = p.Get(c, link, p.timeout, p.header)
	} else if method == http.MethodPost {
		var body io.Reader

		switch p.contentType {
		case "urlencoded":
			formData := url.Values{}
			for field, value := range params {
				formData.Set(field, fmt.Sprintf("%v", value))
			}
			body = strings.NewReader(formData.Encode())
			p.header["Content-Type"] = "application/x-www-form-urlencoded"

		case "form-data":
			var b bytes.Buffer
			writer := multipart.NewWriter(&b)
			for field, value := range params {
				if file, ok := value.(io.Reader); ok {
					part, createFormErr := writer.CreateFormFile(field, field)
					if createFormErr != nil {
						return "", createFormErr
					}
					_, createFormErr = io.Copy(part, file)
					if createFormErr != nil {
						return "", createFormErr
					}
				} else {
					_ = writer.WriteField(field, fmt.Sprintf("%v", value))
				}
			}
			err = writer.Close()
			if err != nil {
				return "", err
			}
			body = &b
			p.header["Content-Type"] = writer.FormDataContentType()

		case "raw":
			body = strings.NewReader(fmt.Sprintf("%v", params["raw"]))
			if _, ok := p.header["Content-Type"]; !ok {
				p.header["Content-Type"] = "application/json"
			}

		default:
			return "", fmt.Errorf("unsupported Content-Type: %s", p.contentType)
		}

		result, err = p.Post(c, link, body, p.timeout, p.header)
	}
	return result, err
}

func (p *HttpPkg) Get(c context.Context, link string, timeout int, header map[string]string) (string, error) {
	client := http.Client{Timeout: time.Second * time.Duration(timeout)}
	var req *http.Request
	req, err := http.NewRequest("GET", link, nil)
	if err != nil {
		return "", err
	}
	span, err := Tracer.CreateExitSpan(c, ExitSpanOptions{
		OperationName: req.URL.Scheme + "://" + req.URL.Host + req.URL.Path,
		Component:     sky.ComponentIDGINHttpServer,
		Peer:          req.URL.Host,
		Layer:         agentV3.SpanLayer_Http,
		Injector: func(key, value string) error {
			req.Header.Set(key, value)
			return nil
		},
	})
	if err == nil {
		defer span.End()
	}
	Tracer.SpanTag(span, go2sky.TagHTTPMethod, req.Method)
	Tracer.SpanTag(span, go2sky.TagURL, link)

	if header != nil && len(header) > 0 {
		for key, value := range header {
			req.Header.Add(key, value)
		}
	}

	resp, err := client.Do(req)
	if err != nil {
		Tracer.SpanErr(span, err.Error())
		return "", err
	} else {
		Tracer.SpanTag(span, go2sky.TagStatusCode, strconv.Itoa(resp.StatusCode))
	}
	body, _ := io.ReadAll(resp.Body)
	_ = resp.Body.Close()

	return string(body), nil
}

func (p *HttpPkg) Post(c context.Context, link string, requestBody io.Reader, timeout int, header map[string]string) (string, error) {
	client := http.Client{Timeout: time.Second * time.Duration(timeout)}
	var req *http.Request

	req, err := http.NewRequest("POST", link, requestBody)
	if err != nil {
		return "", err
	}
	span, err := Tracer.CreateExitSpan(c, ExitSpanOptions{
		OperationName: req.URL.Scheme + "://" + req.URL.Host + req.URL.Path,
		Component:     sky.ComponentIDGINHttpServer,
		Peer:          req.URL.Host,
		Layer:         agentV3.SpanLayer_Http,
		Injector: func(key, value string) error {
			req.Header.Set(key, value)
			return nil
		},
	})
	if err == nil {
		defer span.End()
	}
	Tracer.SpanTag(span, go2sky.TagHTTPMethod, req.Method)
	Tracer.SpanTag(span, go2sky.TagURL, link)

	if header != nil && len(header) > 0 {
		for key, value := range header {
			req.Header.Add(key, value)
		}
	}

	resp, err := client.Do(req)
	if err != nil {
		Tracer.SpanErr(span, err.Error())
		return "", err
	} else {
		Tracer.SpanTag(span, go2sky.TagStatusCode, strconv.Itoa(resp.StatusCode))
	}
	body, _ := io.ReadAll(resp.Body)
	_ = resp.Body.Close()

	return string(body), nil
}