// Package golink 连接
package golink

import (
	"context"
	"sync"
	"time"

	"go_dreamfactory/pb"
	"go_dreamfactory/stress/helper"
	"go_dreamfactory/stress/model"
	"go_dreamfactory/stress/robot"
)

const (
	firstTime    = 1 * time.Second // 连接以后首次请求数据的时间
	intervalTime = 1 * time.Second // 发送数据的时间间隔
)

var (
	// 请求完成以后是否保持连接
	keepAlive bool
)

func init() {
	keepAlive = true
}

// WebSocket webSocket go link
func WebSocket(ctx context.Context, chanID uint64, ch chan<- *model.RequestResults, totalNumber uint64,
	wg *sync.WaitGroup, request *model.Request, r *robot.Robot) {
	defer func() {
		wg.Done()
	}()
	defer func() {
		r.CloseHandler()
	}()

	var (
		i uint64
	)
	// 暂停60秒
	t := time.NewTimer(firstTime)
	for {
		select {
		case <-t.C:
			t.Reset(intervalTime)
			// 请求
			webSocketRequest(chanID, ch, i, request, r)
			// 结束条件
			i = i + 1
			if i >= totalNumber {
				goto end
			}
		}
	}
end:
	t.Stop()

	if keepAlive {
		// 保持连接
		chWaitFor := make(chan int, 0)
		<-chWaitFor
	}
	return
}

// webSocketRequest 请求
func webSocketRequest(chanID uint64, ch chan<- *model.RequestResults, i uint64, request *model.Request,
	r *robot.Robot) {
	var (
		startTime = time.Now()
		isSucceed = false
		errCode   = model.HTTPOk
		byteLen   int64 // 协议传输字节数
	)
	// 需要发送的数据
	head := &pb.UserMessage{MainType: "user", SubType: "login"}
	req := &pb.UserLoginReq{
		Account: "user001",
		Sid:     "dfmxf",
	}
	r.SendToClient(head, req)
	for {

		if b, len := r.MessageRsp("user", "login"); b {
			byteLen += len
			isSucceed = true
			//errCode, isSucceed = request.GetVerifyWebSocket()(request, "webSocket.pb", r.GetMessagedata())
			break
		}
	}

	requestTime := uint64(helper.DiffNano(startTime))
	requestResults := &model.RequestResults{
		ID:            "",
		ChanID:        chanID,
		Time:          requestTime,
		IsSucceed:     isSucceed,
		ErrCode:       errCode,
		ReceivedBytes: byteLen,
	}
	requestResults.SetID(chanID, i)
	ch <- requestResults
}