// Request 請求數據
type Request struct {
	URL       string            // URL
	Form      string            // http/webSocket/tcp
	Method    string            // 方法 GET/POST/PUT
	Headers   map[string]string // Headers
	Body      string            // body
	Verify    string            // 驗證的方法
	Timeout   time.Duration     // 請求超時時間
	Debug     bool              // 是否開啟Debug模式
	MaxCon    int               // 每個連接的請求數
	HTTP2     bool              // 是否使用http2.0
	Keepalive bool              // 是否開啟長連接
	Code      int               // 驗證的狀態(tài)碼
	Redirect  bool              // 是否重定向
}

// NewRequest 生成請求結構體
// url 壓測的url
// verify 驗證方法 在server/verify中 http 支持:statusCode、json webSocket支持:json
// timeout 請求超時時間
// debug 是否開啟debug
// path curl文件路徑 http接口壓測，自定義參數設置
func NewRequest(url string, verify string, code int, timeout time.Duration, debug bool, path string,
	reqHeaders []string, reqBody string, maxCon int, http2, keepalive, redirect bool) (request *Request, err error) {
	var (
		method  = "GET"
		headers = make(map[string]string)
		body    string
	)
	if path != "" {
		var curl *CURL
		curl, err = ParseTheFile(path)
		if err != nil {
			return nil, err
		}
		if url == "" {
			url = curl.GetURL()
		}
		method = curl.GetMethod()
		headers = curl.GetHeaders()
		body = curl.GetBody()
	} else {
		if reqBody != "" {
			method = "POST"
			body = reqBody
		}
		for _, v := range reqHeaders {
			getHeaderValue(v, headers)
		}
		if _, ok := headers["Content-Type"]; !ok {
			headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8"
		}
	}
	var form string
	form, url = getForm(url)
	if form == "" {
		err = fmt.Errorf("url:%s 不合法,必須是完整http、webSocket連接", url)
		return
	}
	var ok bool
	switch form {
	case FormTypeHTTP:
		// verify
		if verify == "" {
			verify = "statusCode"
		}
		key := fmt.Sprintf("%s.%s", form, verify)
		_, ok = verifyMapHTTP[key]
		if !ok {
			err = errors.New("驗證器不存在:" + key)
			return
		}
	case FormTypeWebSocket:
		// verify
		if verify == "" {
			verify = "json"
		}
		key := fmt.Sprintf("%s.%s", form, verify)
		_, ok = verifyMapWebSocket[key]
		if !ok {
			err = errors.New("驗證器不存在:" + key)
			return
		}
	}
	if timeout == 0 {
		timeout = 30 * time.Second
	}
	request = &Request{
		URL:       url,
		Form:      form,
		Method:    strings.ToUpper(method),
		Headers:   headers,
		Body:      body,
		Verify:    verify,
		Timeout:   timeout,
		Debug:     debug,
		MaxCon:    maxCon,
		HTTP2:     http2,
		Keepalive: keepalive,
		Code:      code,
		Redirect:  redirect,
	}
	return
}

// RequestResults 請求結果
type RequestResults struct {
	ID            string // 消息ID
	ChanID        uint64 // 消息ID
	Time          uint64 // 請求時間 納秒
	IsSucceed     bool   // 是否請求成功
	ErrCode       int    // 錯誤碼
	ReceivedBytes int64
}

var (
    mutex sync.RWMutex
    // clients 客戶端
    // key 客戶端id - value 客戶端
    clients = make(map[uint64]*http.Client)
)

// createLangHTTPClient 初始化長連接客戶端參數
// 創(chuàng)建了一個配置了長連接的 HTTP 客戶端傳輸對象
func createLangHTTPClient(request *model.Request) *http.Client {
    tr := &http.Transport{
        // 使用 net.Dialer 來建立 TCP 連接
        // Timeout 設置為 30 秒，表示如果連接在 30 秒內沒有建立成功，則超時
        // KeepAlive 設置為 30 秒，表示連接建立后，如果 30 秒內沒有數據傳輸，則發(fā)送一個 keep-alive 探測包以保持連接
        DialContext: (&net.Dialer{
            Timeout:   30 * time.Second,
            KeepAlive: 30 * time.Second,
        }).DialContext,
        MaxIdleConns:        0,                // 最大連接數,默認0無窮大
        MaxIdleConnsPerHost: request.MaxCon,   // 對每個host的最大連接數量(MaxIdleConnsPerHost<=MaxIdleConns)
        IdleConnTimeout:     90 * time.Second, // 多長時間未使用自動關閉連接
        // InsecureSkipVerify 設置為 true，表示不驗證服務器的 SSL 證書
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }
    if request.HTTP2 {
        // 使用真實證書 驗證證書 模擬真實請求
        tr = &http.Transport{
            DialContext: (&net.Dialer{
                Timeout:   30 * time.Second,
                KeepAlive: 30 * time.Second,
            }).DialContext,
            MaxIdleConns:        0,                // 最大連接數,默認0無窮大
            MaxIdleConnsPerHost: request.MaxCon,   // 對每個host的最大連接數量(MaxIdleConnsPerHost<=MaxIdleConns)
            IdleConnTimeout:     90 * time.Second, // 多長時間未使用自動關閉連接
            // 配置 TLS 客戶端設置，InsecureSkipVerify 設置為 false，表示驗證服務器的 SSL 證書
            TLSClientConfig: &tls.Config{InsecureSkipVerify: false},
        }
        // 將 tr 配置為支持 HTTP/2 協議
        _ = http2.ConfigureTransport(tr)
    }

    client := &http.Client{
        Transport: tr,
    }

    // 禁止 HTTP 客戶端自動重定向，而是讓客戶端在遇到重定向時停止并返回最后一個響應
    if !request.Redirect {
        client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
            return http.ErrUseLastResponse
        }
    }

???????    return client
}

// GrpcSocket grpc
type GrpcSocket struct {
    conn    *grpc.ClientConn
    address string
}

// WebSocket webSocket
type WebSocket struct {
    conn       *websocket.Conn
    URLLink    string
    URL        *url.URL
    IsSsl      bool
    HTTPHeader map[string]string
}

// grpcRequest 請求
func grpcRequest(chanID uint64, ch chan<- *model.RequestResults, i uint64, request *model.Request,
    ws *client.GrpcSocket) {
    var (
        startTime = time.Now()
        isSucceed = false
        errCode   = model.HTTPOk
    )
    // 獲取連接
    conn := ws.GetConn()
    if conn == nil {
        errCode = model.RequestErr
    } else {
        c := pb.NewApiServerClient(conn)
        var (
            ctx = context.Background()
            req = &pb.Request{
                UserName: request.Body,
            }
        )
        // 發(fā)送請求，獲得響應
        rsp, err := c.HelloWorld(ctx, req)
        if err != nil {
            errCode = model.RequestErr
        } else {
            // 200 為成功
            if rsp.Code != 200 {
                errCode = model.RequestErr
            } else {
                isSucceed = true
            }
        }
    }
    requestTime := uint64(helper.DiffNano(startTime))
    requestResults := &model.RequestResults{
        Time:      requestTime,
        IsSucceed: isSucceed,
        ErrCode:   errCode,
    }
    requestResults.SetID(chanID, i)
    ch <- requestResults
}

// HTTP 請求
func HTTP(ctx context.Context, chanID uint64, ch chan<- *model.RequestResults, totalNumber uint64, wg *sync.WaitGroup,
	request *model.Request) {
	defer func() {
		wg.Done()
	}()
	for i := uint64(0); i < totalNumber; i++ {
		if ctx.Err() != nil {
			break
		}

		list := getRequestList(request)
		isSucceed, errCode, requestTime, contentLength := sendList(chanID, list)
		requestResults := &model.RequestResults{
			Time:          requestTime,
			IsSucceed:     isSucceed,
			ErrCode:       errCode,
			ReceivedBytes: contentLength,
		}
		requestResults.SetID(chanID, i)
		ch <- requestResults
	}

	return
}

// calculateData 計算數據
func calculateData(concurrent, processingTime, requestTime, maxTime, minTime, successNum, failureNum uint64,
	chanIDLen int, errCode *sync.Map, receivedBytes int64) {
	if processingTime == 0 {
		processingTime = 1
	}
	var (
		qps              float64
		averageTime      float64
		maxTimeFloat     float64
		minTimeFloat     float64
		requestTimeFloat float64
	)
	// 平均 QPS 成功數*總協程數/總耗時 (每秒)
	if processingTime != 0 {
		qps = float64(successNum*concurrent) * (1e9 / float64(processingTime))
	}
	// 平均時長 總耗時/總請求數/并發(fā)數 納秒=>毫秒
	if successNum != 0 && concurrent != 0 {
		averageTime = float64(processingTime) / float64(successNum*1e6)
	}
	// 納秒=>毫秒
	maxTimeFloat = float64(maxTime) / 1e6
	minTimeFloat = float64(minTime) / 1e6
	requestTimeFloat = float64(requestTime) / 1e9
	// 打印的時長都為毫秒
	table(successNum, failureNum, errCode, qps, averageTime, maxTimeFloat, minTimeFloat, requestTimeFloat, chanIDLen,
		receivedBytes)
}