package ws

import (
	"errors"
	okex "gitee.com/zqs118/go-okx"
	"gitee.com/zqs118/go-okx/common"
	"github.com/gorilla/websocket"
	"time"
)

func publicSubscribe(message interface{}, handler WsHandler, errHandler ErrHandler) (doneC, stopC chan struct{}, err error) {
	conn, err := dail(PUBLIC)
	if err != nil {
		return nil, nil, err
	}
	return subscribe(conn, message, handler, errHandler)
}

func privateSubscribe(conf *okex.Config, message interface{}, handler WsHandler, errHandler ErrHandler) (doneC, stopC chan struct{}, err error) {
	conn, err := dail(PRIVATE)
	if err != nil {
		return nil, nil, err
	}
	err = login(conn, conf)
	if err != nil {
		return nil, nil, err
	}
	return subscribe(conn, message, handler, errHandler)
}

func dail(channelType ChannelType) (conn *websocket.Conn, err error) {
	conf := newConfig(channelType)
	conn, _, err = websocket.DefaultDialer.Dial(string(conf.endpoint), nil)
	return
}

func login(conn *websocket.Conn, conf *okex.Config) error {
	param := map[string]interface{}{
		"op": "login",
	}
	args := make([]interface{}, 0)
	timestamp := common.EpochTime()
	preHash := common.PreHashString(timestamp, common.RequestMethodGET, "/users/self/verify", "")
	sign, err := common.HmacSha256Base64Signer(preHash, conf.SecretKey)
	if err != nil {
		return err
	}
	temp := map[string]interface{}{}
	temp["apiKey"] = conf.ApiKey
	temp["passphrase"] = conf.PassPhrase
	temp["timestamp"] = timestamp
	temp["sign"] = sign
	args = append(args, temp)
	param["args"] = args
	err = conn.WriteJSON(param)
	if err != nil {
		return err
	}
	_, message, err := conn.ReadMessage()
	if err != nil {
		return err
	}
	m, err := common.NewJSON(message)
	if err != nil {
		return err
	}
	code := m.Get("code").MustString()
	if code != "0" {
		return errors.New("\n  event: " + m.Get("event").MustString() + "\n  code: " + code + "\n  msg: " + m.Get("msg").MustString())
	}
	return nil
}

func subscribe(conn *websocket.Conn, message interface{}, handler WsHandler, errHandler ErrHandler) (doneC, stopC chan struct{}, err error) {
	err = conn.WriteJSON(message)
	if err != nil {
		return nil, nil, err
	}
	doneC = make(chan struct{})
	stopC = make(chan struct{})
	go func() {
		// 出现错误或者收到停止指令时关闭链接
		defer close(doneC)
		if KeepAlive {
			keepAlive(conn)
		}
		// 接收指令等待关闭连接
		silent := false
		go func() {
			select {
			case <-stopC:
				silent = true
			case <-doneC:
			}
			conn.Close()
		}()
		for {
			_, message, err := conn.ReadMessage()
			if err != nil {
				if !silent {
					errHandler(err)
				}
				return
			}
			handler(message)
		}
	}()
	return
}

func keepAlive(c *websocket.Conn) {
	ticker := time.NewTicker(Timeout)

	go func() {
		defer ticker.Stop()
		for {
			deadline := time.Now().Add(10 * time.Second)
			err := c.WriteControl(websocket.PingMessage, []byte("ping"), deadline)
			if err != nil {
				c.Close()
				return
			}
			<-ticker.C
		}
	}()
}