// Package golink 连接
package golink

import (
	"context"
	"sync"
	"time"

	"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 = false
}

// 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
		//time.Sleep(15 * time.Millisecond)
		//return
	}
	return
}

// webSocketRequest 请求
func webSocketRequest(chanID uint64, ch chan<- *model.RequestResults, i uint64, request *model.Request,
	r *robot.Robot) {
	var (
		isSucceed = false
		errCode   = model.HTTPOk
		byteLen   int64 // 协议传输字节数
	)

	startTime := time.Now()
	isSucceed = true
	//r.Create()
	//isSucceed = r.AddGrormetItem()
	byteLen = r.Login()
	if byteLen == 0 {
		isSucceed = false
	} else {
		byteLen += r.Create(i)
	}
	if byteLen == 0 {
		isSucceed = false
	}

	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
}