package fetcher

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"time"
)

// Get get请求
func Get(url string, timeout time.Duration) ([]byte, int, error) {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, 0, fmt.Errorf("[get] new request err: %v", err)
	}

	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(req)
	if err != nil {
		return nil, 0, fmt.Errorf("[get] client do err: %v", err)
	}
	defer resp.Body.Close()

	status := resp.StatusCode
	res, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, status, fmt.Errorf("read response err: %v", err)
	}

	return res, status, nil
}

// GetString 请求
func GetString(url string, parameter map[string]string, timeout time.Duration) ([]byte, int, error) {
	byteParameter := new(bytes.Buffer)
	w := multipart.NewWriter(byteParameter)
	for k, v := range parameter {
		w.WriteField(k, v)
	}
	w.Close()

	request, err := http.NewRequest("GET", url, byteParameter)
	if err != nil {
		return nil, 0, fmt.Errorf("[getstring] new request err: %v", err)
	}
	request.Header.Set("Content-Type", w.FormDataContentType())

	client := &http.Client{Timeout: time.Second * timeout}
	response, err := client.Do(request)
	if err != nil {
		return nil, 0, err
	}
	defer func(Body io.ReadCloser) {
		_ = Body.Close()
	}(response.Body)

	status := response.StatusCode
	resp, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, status, err
	}

	return resp, status, nil
}

// GetJson application/json get 请求
func GetJson(url string, parameter []byte, timeout time.Duration) ([]byte, int, error) {
	byteParameter := bytes.NewBuffer(parameter)
	req, err := http.NewRequest("GET", url, byteParameter)
	if err != nil {
		return nil, 0, fmt.Errorf("[getjson] new request err: %v", err)
	}

	client := &http.Client{Timeout: timeout}
	resp, err := client.Do(req)
	if err != nil {
		return nil, 0, fmt.Errorf("[getjson] client do err: %v", err)
	}
	defer resp.Body.Close()

	status := resp.StatusCode
	res, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, status, fmt.Errorf("read response err: %v", err)
	}

	return res, status, nil
}

// GetJsonWithToken Get json with token 请求
func GetJsonWithToken(url string, token string, timeout time.Duration) ([]byte, int, error) {
	request, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, 0, err
	}
	request.Header.Set("Content-type", "application/json")
	request.Header.Set("Access-Token", token)

	client := &http.Client{Timeout: timeout}
	response, err := client.Do(request)
	if err != nil {
		return nil, 0, errors.New("请求网络错误")
	}
	defer response.Body.Close()

	status := response.StatusCode
	resp, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, status, err
	}

	return resp, status, nil
}

// PostJson application/json post 请求
func PostJson(url string, parameter []byte, timeout time.Duration) ([]byte, int, error) {
	byteParameter := bytes.NewBuffer(parameter)
	request, err := http.NewRequest("POST", url, byteParameter)
	if err != nil {
		return nil, 0, fmt.Errorf("[postjson] new request err: %v", err)
	}
	request.Header.Set("Content-type", "application/json")

	client := &http.Client{Timeout: timeout}
	response, err := client.Do(request)
	if err != nil {
		return nil, 0, fmt.Errorf("[postjson] client do err: %v", err)
	}
	defer response.Body.Close()

	status := response.StatusCode
	all, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, status, fmt.Errorf("read response err: %v", err)
	}

	return all, status, nil
}

// PostString application/x-www-form-urlencoded 请求
func PostString(url string, parameter []byte, timeout time.Duration) ([]byte, int, error) {
	byteParameter := bytes.NewBuffer(parameter)
	request, err := http.NewRequest("POST", url, byteParameter)
	if err != nil {
		return nil, 0, fmt.Errorf("[poststring] new request err: %v", err)
	}
	request.Header.Set("Content-type", "application/x-www-form-urlencoded")

	client := &http.Client{Timeout: timeout}
	response, err := client.Do(request)
	if err != nil {
		return nil, 0, fmt.Errorf("[poststring] client do err: %v", err)
	}
	defer response.Body.Close()

	status := response.StatusCode
	all, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, status, fmt.Errorf("read response err: %v", err)
	}

	return all, status, nil
}

// PostJsonWithToken Post json with token 请求
func PostJsonWithToken(url string, parameter []byte, token string, timeout time.Duration) ([]byte, int, error) {
	bufParameter := bytes.NewBuffer(parameter)
	request, err := http.NewRequest("POST", url, bufParameter)
	if err != nil {
		return nil, 0, err
	}
	request.Header.Set("Content-type", "application/json")
	request.Header.Set("Access-Token", token)

	client := &http.Client{Timeout: timeout}
	response, err := client.Do(request)
	if err != nil {
		return nil, 0, fmt.Errorf("请求网络错误: %v", err)
	}
	defer func(Body io.ReadCloser) {
		_ = Body.Close()
	}(response.Body)

	stauts := response.StatusCode
	resp, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, stauts, errors.New("网络请求结果读取失败")
	}

	return resp, stauts, nil
}

// PostJsonWithBearerToken Post json with bearer token 请求
func PostJsonWithBearerToken(url string, parameter []byte, token string, timeout time.Duration) ([]byte, int, error) {
	bufParameter := bytes.NewBuffer(parameter)
	request, err := http.NewRequest("POST", url, bufParameter)
	if err != nil {
		return nil, 0, err
	}
	request.Header.Set("Content-type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("bearer %s", token))

	client := &http.Client{Timeout: timeout}
	response, err := client.Do(request)
	if err != nil {
		return nil, 0, fmt.Errorf("请求网络错误: %v", err)
	}
	defer func(Body io.ReadCloser) {
		_ = Body.Close()
	}(response.Body)

	status := response.StatusCode
	resp, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, status, errors.New("网络请求结果读取失败")
	}

	return resp, status, nil
}

// func determiningEncoding(r *bufio.Reader) encoding.Encoding {
// 	b, err := r.Peek(1024)
// 	if err != nil && err != io.EOF {
// 		log.Printf("Fetcher error: %v", err)
// 		return unicode.UTF8
// 	}

// 	e, _, _ := charset.DetermineEncoding(b, "")
// 	return e
// }