import { Package50 } from '@/services/websocket/package'
import { FunCode } from '@/constants/funcode'
import { encodeProto, decodeProto } from '@/services/websocket/package/package50/proto'
import Worker from 'worker-loader!./main'
import Service from '../service'

interface RequestParams {
  data: unknown;
  requestCode: keyof typeof FunCode;
  responseCode: keyof typeof FunCode;
}

export default new (class {
  private readonly worker = new Worker()
  private responseQueue = new Map()
  private isTokenValid = false

  constructor() {
    Service.onReady(() => {
      this.worker.postMessage({
        type: 'init',
        data: {
          url: Service.getServiceConfig('tradeUrl')
        }
      })
    })

    // 接收工作线程消息
    this.worker.onmessage = (e) => {
      const message = e.data
      if (typeof message === 'object') {
        switch (message.type) {
          case 'reconnecting': {
            this.stopCheckToken()
            break
          }
          case 'reconnected': {
            this.checkToken()
            break
          }
          case 'response': {
            console.log(message.data)
            const { responseCode, content, error } = message.data
            const queue = this.responseQueue.get(responseCode)
            if (queue) {
              const { resolve, reject } = queue
              error ? reject(error) : resolve(content)
            }
            break
          }
          case 'push': {
            console.log(message.data)
            break
          }
        }
      }
    }
  }

  request<T>({ data, requestCode, responseCode }: RequestParams) {
    return new Promise<T>((resolve, reject) => {
      const requestId = FunCode[requestCode]
      const responseId = FunCode[responseCode]

      encodeProto(requestCode, data).then(async (uint8Array) => {
        const run = () => {
          const content = new Package50(requestId, uint8Array)
          const queueId = new Date().getTime()

          content.serialNumber = queueId
          this.responseQueue.set(queueId, { resolve, reject })

          this.worker.postMessage({
            type: 'send',
            data: {
              messageId: responseId,
              content // worker 不支持包含函数对象，content.data() 函数会丢失
            }
          })
        }

        if (this.isTokenValid || ['TokenCheckReq', 'LoginReq'].includes(requestCode)) {
          run()
        } else {
          this.checkToken().then(() => run()).catch(reject)
        }
      }).catch(() => {
        reject('构建失败')
      })
    })
  }

  checkToken() {
    return new Promise<void>((resolve, reject) => {
      this.request({
        data: {
          LoginID: '',
          Token: ''
        },
        requestCode: 'TokenCheckReq',
        responseCode: 'TokenCheckRsp'
      }).then(() => {
        this.isTokenValid = true
        resolve()
      }).catch((error) => {
        this.isTokenValid = false
        reject(error)
      })
    })
  }

  stopCheckToken() {
    this.isTokenValid = false
  }
})