package go_lib

import (
	"bytes"
	"encoding/json"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"
)

type HttpResponse struct {
	StatusCode int
	Headers    map[string][]string
	Body       string
	Error      error
}

func HttpGet(urlStr string, headers ...map[string]string) *HttpResponse {
	req, err := http.NewRequest("GET", urlStr, nil)
	if err != nil {
		return &HttpResponse{Error: err}
	}
	
	if len(headers) > 0 {
		for key, value := range headers[0] {
			req.Header.Set(key, value)
		}
	}
	
	return executeRequest(req)
}

func HttpPost(urlStr string, data interface{}, headers ...map[string]string) *HttpResponse {
	var body io.Reader
	var contentType string
	
	switch v := data.(type) {
	case string:
		body = strings.NewReader(v)
		contentType = "application/x-www-form-urlencoded"
	case map[string]interface{}:
		jsonData, err := json.Marshal(v)
		if err != nil {
			return &HttpResponse{Error: err}
		}
		body = bytes.NewReader(jsonData)
		contentType = "application/json"
	case map[string]string:
		formData := ""
		for k, v := range v {
			if formData != "" {
				formData += "&"
			}
			formData += url.QueryEscape(k) + "=" + url.QueryEscape(v)
		}
		body = strings.NewReader(formData)
		contentType = "application/x-www-form-urlencoded"
	case []byte:
		body = bytes.NewReader(v)
		contentType = "application/octet-stream"
	default:
		jsonData, err := json.Marshal(v)
		if err != nil {
			return &HttpResponse{Error: err}
		}
		body = bytes.NewReader(jsonData)
		contentType = "application/json"
	}
	
	req, err := http.NewRequest("POST", urlStr, body)
	if err != nil {
		return &HttpResponse{Error: err}
	}
	
	req.Header.Set("Content-Type", contentType)
	
	if len(headers) > 0 {
		for key, value := range headers[0] {
			req.Header.Set(key, value)
		}
	}
	
	return executeRequest(req)
}

func HttpPut(urlStr string, data interface{}, headers ...map[string]string) *HttpResponse {
	var body io.Reader
	var contentType string
	
	switch v := data.(type) {
	case string:
		body = strings.NewReader(v)
		contentType = "application/x-www-form-urlencoded"
	case map[string]interface{}:
		jsonData, err := json.Marshal(v)
		if err != nil {
			return &HttpResponse{Error: err}
		}
		body = bytes.NewReader(jsonData)
		contentType = "application/json"
	case []byte:
		body = bytes.NewReader(v)
		contentType = "application/octet-stream"
	default:
		jsonData, err := json.Marshal(v)
		if err != nil {
			return &HttpResponse{Error: err}
		}
		body = bytes.NewReader(jsonData)
		contentType = "application/json"
	}
	
	req, err := http.NewRequest("PUT", urlStr, body)
	if err != nil {
		return &HttpResponse{Error: err}
	}
	
	req.Header.Set("Content-Type", contentType)
	
	if len(headers) > 0 {
		for key, value := range headers[0] {
			req.Header.Set(key, value)
		}
	}
	
	return executeRequest(req)
}

func HttpDelete(urlStr string, headers ...map[string]string) *HttpResponse {
	req, err := http.NewRequest("DELETE", urlStr, nil)
	if err != nil {
		return &HttpResponse{Error: err}
	}
	
	if len(headers) > 0 {
		for key, value := range headers[0] {
			req.Header.Set(key, value)
		}
	}
	
	return executeRequest(req)
}

func HttpRequest(method, urlStr string, data interface{}, headers ...map[string]string) *HttpResponse {
	var body io.Reader
	
	if data != nil {
		switch v := data.(type) {
		case string:
			body = strings.NewReader(v)
		case []byte:
			body = bytes.NewReader(v)
		default:
			jsonData, err := json.Marshal(v)
			if err != nil {
				return &HttpResponse{Error: err}
			}
			body = bytes.NewReader(jsonData)
		}
	}
	
	req, err := http.NewRequest(strings.ToUpper(method), urlStr, body)
	if err != nil {
		return &HttpResponse{Error: err}
	}
	
	if len(headers) > 0 {
		for key, value := range headers[0] {
			req.Header.Set(key, value)
		}
	}
	
	return executeRequest(req)
}

func executeRequest(req *http.Request) *HttpResponse {
	client := &http.Client{
		Timeout: 30 * time.Second,
	}
	
	resp, err := client.Do(req)
	if err != nil {
		return &HttpResponse{Error: err}
	}
	defer resp.Body.Close()
	
	bodyBytes, err := io.ReadAll(resp.Body)
	if err != nil {
		return &HttpResponse{Error: err}
	}
	
	return &HttpResponse{
		StatusCode: resp.StatusCode,
		Headers:    resp.Header,
		Body:       string(bodyBytes),
		Error:      nil,
	}
}

func UrlEncode(str string) string {
	return url.QueryEscape(str)
}

func UrlDecode(str string) (string, error) {
	return url.QueryUnescape(str)
}

func ParseUrl(rawUrl string) (*url.URL, error) {
	return url.Parse(rawUrl)
}

func BuildQuery(data map[string]interface{}) string {
	query := ""
	for key, value := range data {
		if query != "" {
			query += "&"
		}
		var strValue string
		switch v := value.(type) {
		case string:
			strValue = v
		case int:
			strValue = strconv.Itoa(v)
		case int64:
			strValue = strconv.FormatInt(v, 10)
		case float64:
			strValue = strconv.FormatFloat(v, 'f', -1, 64)
		case bool:
			strValue = strconv.FormatBool(v)
		default:
			jsonValue, _ := json.Marshal(v)
			strValue = string(jsonValue)
		}
		query += url.QueryEscape(key) + "=" + url.QueryEscape(strValue)
	}
	return query
}

func HttpBuildQuery(data map[string]string) string {
	query := ""
	for key, value := range data {
		if query != "" {
			query += "&"
		}
		query += url.QueryEscape(key) + "=" + url.QueryEscape(value)
	}
	return query
}

func GetHeaders() map[string]string {
	return map[string]string{
		"User-Agent":    "Mozilla/5.0 (compatible; Go HTTP Client)",
		"Accept":        "*/*",
		"Cache-Control": "no-cache",
	}
}

func FileGetContentsUrl(urlStr string, headers ...map[string]string) (string, error) {
	resp := HttpGet(urlStr, headers...)
	if resp.Error != nil {
		return "", resp.Error
	}
	return resp.Body, nil
}