package httptransport

import (
	"context"
	"crypto/tls"
	"net"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"time"
)

var DefaultConfig *Config_type

type Config_type struct {
	Timeout               time.Duration
	DialTimeout           time.Duration
	KeepAliveDetectTime   time.Duration
	ResponseHeaderTimeout time.Duration
	TLSHandshakeTimeout   time.Duration
	MaxIdleConns          int
	IdleConnTimeout       time.Duration
	DisableKeepAlives     bool
	MaxIdleConnsPerHost   int
	HttpProxy             *url.URL
	// TLSClient Config
	TLSClientC_InsecureSkipVerify bool
	// HTTP2 config
	HTTP2_ForceAttempt bool
}

func LoadDefaultConfig() {
	if DefaultConfig != nil {
		return
	}
	config := &Config_type{}

	// timeout
	timeout := os.Getenv("APP_HTTPPOOL_TIMEOUT")
	if timeout != "" {
		if v, err := strconv.Atoi(timeout); err == nil {
			config.Timeout = time.Duration(v) * time.Millisecond
		} else {
			panic(err.Error())
		}
	}
	// DialTimeout
	DialTimeout := os.Getenv("APP_HTTPPOOL_DIALTIMEOUT")
	if DialTimeout != "" {
		if v, err := strconv.Atoi(DialTimeout); err == nil {
			config.DialTimeout = time.Duration(v) * time.Millisecond
		} else {
			panic(err.Error())
		}
	}
	// KeepAliveDetectTime
	KeepAliveDetectTime := os.Getenv("APP_HTTPPOOL_KEEPALIVE_DETECTTIME")
	if KeepAliveDetectTime != "" {
		if v, err := strconv.Atoi(KeepAliveDetectTime); err == nil {
			config.KeepAliveDetectTime = time.Duration(v) * time.Millisecond
		} else {
			panic(err.Error())
		}
	}
	// ResponseHeaderTimeout
	ResponseHeaderTimeout := os.Getenv("APP_HTTPPOOL_RESPONSE_TIMEOUT")
	if ResponseHeaderTimeout != "" {
		if v, err := strconv.Atoi(ResponseHeaderTimeout); err == nil {
			config.ResponseHeaderTimeout = time.Duration(v) * time.Millisecond
		} else {
			panic(err.Error())
		}
	} else {
		config.ResponseHeaderTimeout = time.Duration(10000) * time.Millisecond
	}
	// TLSHandshakeTimeout
	TLSHandshakeTimeout := os.Getenv("APP_HTTPPOOL_TLSHANDSHAKETIMEOUT")
	if TLSHandshakeTimeout != "" {
		if v, err := strconv.Atoi(TLSHandshakeTimeout); err == nil {
			config.TLSHandshakeTimeout = time.Duration(v) * time.Millisecond
		} else {
			panic(err.Error())
		}
	}
	// MaxIdleConns
	MaxIdleConns := os.Getenv("APP_HTTPPOOL_MAXIDLECONNS")
	if MaxIdleConns != "" {
		if v, err := strconv.Atoi(MaxIdleConns); err == nil {
			config.MaxIdleConns = v
		} else {
			panic(err.Error())
		}
	}

	// IdleConnTimeout
	IdleConnTimeout := os.Getenv("APP_HTTPPOOL_IDLECONNTIMEOUT")
	if IdleConnTimeout != "" {
		if v, err := strconv.Atoi(IdleConnTimeout); err == nil {
			config.IdleConnTimeout = time.Duration(v) * time.Millisecond
		} else {
			panic(err.Error())
		}
	}
	// DisableKeepAlives
	DisableKeepAlives := os.Getenv("APP_HTTPPOOL_DISABLEKEEPALIVES")
	if DisableKeepAlives != "" {
		if v, err := strconv.ParseBool(DisableKeepAlives); err == nil {
			config.DisableKeepAlives = v
		} else {
			panic(err.Error())
		}
	}
	// MaxIdleConnsPerHost
	MaxIdleConnsPerHost := os.Getenv("APP_HTTPPOOL_MAXIDLECONNSPERHOST")
	if MaxIdleConnsPerHost != "" {
		if v, err := strconv.Atoi(MaxIdleConnsPerHost); err == nil {
			config.MaxIdleConnsPerHost = v
		} else {
			panic(err.Error())
		}
	}
	// HttpProxy
	HttpProxy := os.Getenv("AXIOS_HTTP_PROXY")
	if HttpProxy != "" {
		proxyUrl, err := url.Parse(HttpProxy)
		if err == nil {
			config.HttpProxy = proxyUrl
		} else {
			panic(err.Error())
		}
	}
	// TLSClientConfig
	if envV := os.Getenv("APP_HTTPPOOL_TLSCLIENTC_INSECURESKIPVERIFY"); envV != "" {
		if v, err := strconv.ParseBool(envV); err == nil {
			config.TLSClientC_InsecureSkipVerify = v
		} else {
			panic(err.Error())
		}
	}
	// HTTP2 Config
	config.HTTP2_ForceAttempt = true
	if envV := os.Getenv("APP_HTTPPOOL_HTTP2_FORCEATTEMPT"); envV != "" {
		if v, err := strconv.ParseBool(envV); err == nil {
			config.HTTP2_ForceAttempt = v
		} else {
			panic(err.Error())
		}
	}

	DefaultConfig = config
}

func defaultTransportDialContext(dialer *net.Dialer) func(context.Context, string, string) (net.Conn, error) {
	return dialer.DialContext
}

func CreateHttpClient() *http.Client {
	if DefaultConfig == nil {
		LoadDefaultConfig()
	}
	proxy := http.ProxyFromEnvironment
	if DefaultConfig.HttpProxy != nil {
		proxy = http.ProxyURL(DefaultConfig.HttpProxy)
	}
	transport := &http.Transport{
		Proxy: proxy,
		TLSClientConfig: &tls.Config{
			// InsecureSkipVerify控制客户端是否验证服务器的证书链和主机名。如果InsecureSkipVerify为true，crypto/tls接受服务器提供的任何证书以及该证书中的任何主机名。在此模式下，TLS容易受到中间人攻击，除非使用自定义验证。这仅应用于测试或与VerifyConnection或VerifyPeerCertificate结合使用。
			InsecureSkipVerify: DefaultConfig.TLSClientC_InsecureSkipVerify, // 默认 false
		},
		DialContext: defaultTransportDialContext(&net.Dialer{
			Timeout:   DefaultConfig.DialTimeout,         // 连接建立超时时间
			KeepAlive: DefaultConfig.KeepAliveDetectTime, // keep alive 探活时间
		}),
		// 响应头读取超时时间 它用于设置从发送HTTP请求开始到收到服务器响应头的超时时间
		ResponseHeaderTimeout: DefaultConfig.ResponseHeaderTimeout,
		// ExpectContinueTimeout: time.Duration(utils.GCfg.ProxyExpectContinueTimeout) * time.Millisecond, // 期望继续的超时时间（对于某些请求可能不适用） 指定了客户端在发送了带有“Expect: 100-Continue”请求头之后，等待服务器响应“100 Continue”这一确认消息的最大时间。如果在这个时间内没有收到服务器的确认，客户端将不再等待，直接发送请求体。这个设置主要是为了避免客户端因为不确定服务器是否准备好而长时间等待的情况，提高请求的效率。

		// ForceAttemptHTTP2控制当提供了非零Dial, DialTLS或DialContext函数或TLSClientConfig时是否启用HTTP/2。默认情况下，使用这些字段保守地禁用HTTP/2。要使用自定义拨号器或TLS配置并仍然尝试HTTP/2升级，请将此设置为true。
		ForceAttemptHTTP2: DefaultConfig.HTTP2_ForceAttempt, // 默认 false
		// TLSHandshakeTimeout指定等待TLS握手的最大时间。0表示没有超时。
		TLSHandshakeTimeout: DefaultConfig.TLSHandshakeTimeout,
		// 设置整个Transport的最大空闲连接数。增大此值可以减少新建连接的开销，但过高会占用更多资源。一般推荐设置为预期并发请求数的几倍
		MaxIdleConns: DefaultConfig.MaxIdleConns,
		// IdleConnTimeout: 设置空闲连接的超时时间，超时后连接将被关闭并从连接池中移除
		IdleConnTimeout: DefaultConfig.IdleConnTimeout,
		//
		DisableKeepAlives: DefaultConfig.DisableKeepAlives,
		// 每个主机的最大空闲连接数。在高并发请求同一主机时，增加此值可以减少建立新连接的频率，提高效率。根据目标服务器的能力和并发需求进行调整
		MaxIdleConnsPerHost: DefaultConfig.MaxIdleConnsPerHost,
	}
	return &http.Client{
		Transport: transport,
		Timeout:   DefaultConfig.Timeout,
	}
}