fs.watch(filename[, options], listener)

fs.watchFile(filename[, options], listener)

server.on('upgrade', function (req, socket, head) {
  const read = new WebsocketRead(req, socket)
  const write = new WebsocketWrite(socket)

  console.log('websocket connect success')

  read.on('text', function (data) {
    console.log('接收到响应', data)
  })

  read.on('ping', function () {
    write.pong()
  })

  watch.on('update', (data) => {
    write.send(data)
  })
})

let data = fs.readFileSync(filePath)
if (path.extname(filePath) === '.html') {
  data = data
    .toString()
    .replace(/\<\/\s*body>/, `${websocketTemplateStr}</body>`)
}

const fs = require('fs')
const { EventEmitter } = require('events')
const path = require('path')

const { resolveRootPath } = require('./utils')

class Watch extends EventEmitter {
  constructor(dir) {
    super()
    this.watchPath = resolveRootPath(dir)
    fs.watch(this.watchPath, { recursive: true }, this.handleCallback)
  }

  handleCallback = (eventType, filename) => {
    try {
      const content = fs
        .readFileSync(path.resolve(this.watchPath, filename), {
          encoding: 'utf-8',
        })
        .toString()
      this.emit('update', {
        filename,
        content,
      })
    } catch (e) {
      this.emit('remove', {
        filename,
        content: null,
      })
    }
  }
}

module.exports = Watch

const cb = (event) => {
  const data = event.clipboardData // 获取粘贴内容
  let fileContent
  let stopFlag = false
  // 遍历对象获取粘贴文件
  for (let i = 0; data && data.items && i < data.items.length; i++) {
    const item = data.items[i]
    if (item.kind === 'file' && item.type.match('^image/')) {
      stopFlag = true
      fileContent = item.getAsFile()
    }
  }
  // 对 fileContent 做处理
}

const bc = new BroadcastChannel('channel')

bc.postMessage(data)

bc.onmessage = function (e) {
  // e.data是发送过来的数据，可以根据数据做一些事情
}
bc.onmessageerror = function (e) {
  // 错误消息
}

bc.close()

localStorage.setItem('newValue', 'new')

window.addEventListener('storage', function (e) {
  // e.newValue表示新设置的值
  // e.key表示新设置的值的键
})

// 构建响应头
function buildHeaders(secWebsocketKey) {
  // 计算返回的key
  const resKey = crypto
    .createHash('sha1')
    .update(secWebsocketKey + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
    .digest('base64')

  // 构造响应头
  return [
    'HTTP/1.1 101 Switching Protocols',
    'Upgrade: websocket',
    'Connection: Upgrade',
    'Sec-WebSocket-Accept: ' + resKey,
  ]
    .concat('', '')
    .join('\r\n')
}

/**
 * 
  1               2               3               4
  0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
 +-+-+-+-+-------+-+-------------+-------------------------------+
 |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
 |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
 |N|V|V|V|       |S|             |   (if payload len==126/127)   |
 | |1|2|3|       |K|             |                               |
 +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
 |     Extended payload length continued, if payload len == 127  |
 + - - - - - - - - - - - - - - - +-------------------------------+
 |                               |Masking-key, if MASK set to 1  |
 +-------------------------------+-------------------------------+
 | Masking-key (continued)       |          Payload Data         |
 +-------------------------------- - - - - - - - - - - - - - - - +
 :                     Payload Data continued ...                :
 + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
 |                     Payload Data continued ...                |
 +---------------------------------------------------------------+
 */

class CustomReadSocket extends EventEmitter {
  static MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'

  constructor(req, socket, head) {
    super()
    // 保存上下文信息
    this.req = req
    this.socket = socket
    this.head = head

    // 内部状态
    this.dataType = ''
    this.resHeaders = this.buildHeaders(req.headers['sec-websocket-key'])
    this.buffer = null

    // 接收数据
    this.socket.on('data', this.handleData)

    // 响应给客户端
    this.socket.write(this.resHeaders)
  }

  // 构建响应头
  buildHeaders(secWebsocketKey) {
    // 计算返回的key
    const resKey = crypto
      .createHash('sha1')
      .update(secWebsocketKey + CustomReadSocket.MAGIC_STRING)
      .digest('base64')

    // 构造响应头
    return [
      'HTTP/1.1 101 Switching Protocols',
      'Upgrade: websocket',
      'Connection: Upgrade',
      'Sec-WebSocket-Accept: ' + resKey,
    ]
      .concat('', '')
      .join('\r\n')
  }

  // 处理收到的数据
  handleData = (data) => {
    do {
      const type = this.getFrameType(data[0])
      if (type && type !== 'continue') {
        this.dataType = type
      }
      if (type === 'continue' || type === 'text' || type === 'binary') {
        let maskLen = 0
        if (this.hasMask(data[1])) {
          maskLen = 4
        }
        const [start, len] = this.getFrameDataLength(data)

        this.getDataFromFrame(
          data.slice(start + maskLen),
          data.slice(start, start + maskLen),
        )
      }
    } while (!this.isLastFrame(data[0]))
    this.handleAllType(this.dataType)
  }

  // 获取当前帧类型
  getFrameType(byte) {
    const realType = byte & 0x7f
    if (!realType) {
      // 代表连续的帧
      return 'continue'
    } else if (realType === 0x01) {
      return 'text'
    } else if (realType === 0x09) {
      return 'ping'
    } else if (realType === 0x0a) {
      return 'pong'
    } else if (realType === 0x02) {
      return 'binary'
    } else if (realType === 0x08) {
      return 'close'
    } else {
      return ''
    }
  }

  // 处理所有帧类型
  handleAllType(type) {
    switch (type) {
      case 'continue': {
        console.log('continue')
        break
      }
      case 'text': {
        this.emit('message', this.buffer.toString())
        break
      }
      case 'binary': {
        this.emit('message', this.buffer)
        break
      }
      case 'close': {
        this.emit('close')
        break
      }
      case 'ping': {
        this.emit('ping')
        break
      }
      case 'pong': {
        this.emit('pong')
        break
      }
      default: {
        console.log('others')
      }
    }
    // 释放 buffer 和重置数据类型
    this.buffer = null
    this.dataType = ''
  }

  // 判断是否是最后一个帧
  isLastFrame(byte) {
    return !!(byte & 0x80)
  }

  // 提取帧的长度
  getFrameDataLength(buffer) {
    // 第二个字节的底 7 位
    const firtLen = buffer[1] & 0x7f
    if (firtLen < 125) {
      return [2, firtLen]
    } else if (firtLen === 126) {
      const len = buffer.readUInt16BE(2)
      return [4, len]
    } else {
      const len = buffer.readUInt64BE(2)
      return [10, len]
    }
  }

  // 判断是否有掩码
  hasMask(byte) {
    return !!(0x80 & byte)
  }

  // 从帧里提取数据
  getDataFromFrame(buffer, maskBuffer) {
    if (buffer && buffer.length) {
      const len = buffer.length
      if (maskBuffer && maskBuffer.length === 4) {
        for (let i = 0; i < len; i++) {
          buffer[i] = buffer[i] ^ maskBuffer[i % 4]
        }
      }
      this.buffer = this.buffer ? Buffer.concat([this.buffer, buffer]) : buffer
    }
  }
}

class CustomWebsocket extends CustomReadSocket {
  timer = null
  constructor(req, socket, head, options) {
    super(req, socket, head)
    this.options = options

    this.timeout()
    this.socket.on('data', () => {
      this.timeout()
    })
  }

  send(message) {
    const buffer = Buffer.from(message)
    const list = this.buildDataFrameList('text', buffer)
    list.forEach((frame) => {
      this.socket.write(frame)
    })
    this.timeout()
  }

  ping() {
    const frame = this.buildFrame('ping')
    this.socket.write(frame)
    this.timeout()
  }

  pong() {
    const frame = this.buildFrame('pong')
    this.socket.write(frame)
    this.timeout()
  }

  close() {
    const frame = this.buildFrame('close')
    this.socket.write(frame)
    this.socket.end()
    process.nextTick(() => {
      this.socket.destroy()
    })
  }

  timeout() {
    const { timeout = 10000 } = this.options || {}
    clearTimeout(this.timer)
    this.timer = setTimeout(() => {
      this.ping()
    }, timeout)
  }

  buildDataFrameList(type, buffer) {
    const bufferList = []
    let tempBuffer = buffer
    while (tempBuffer.length) {
      bufferList.push(tempBuffer.slice(0, this.MAX_FRAME_SIZE))
      tempBuffer = tempBuffer.slice(this.MAX_FRAME_SIZE)
    }
    const len = bufferList.length
    return bufferList.map((buf, index) =>
      this.buildFrame(index ? 'continue' : type, len === index + 1, buf),
    )
  }

  buildFrame(dataType, isLast = true, buffer = null) {
    let firstByte = isLast ? 0x80 : 0x00
    switch (`${dataType || ''}`.toLowerCase()) {
      case 'continue': {
        firstByte = firstByte | 0x00
        break
      }
      case 'text': {
        firstByte = firstByte | 0x01
        break
      }
      case 'binary': {
        firstByte = firstByte | 0x02
        break
      }
      case 'close': {
        firstByte = firstByte | 0x08
        break
      }
      case 'ping': {
        firstByte = firstByte | 0x09
        break
      }
      case 'pong': {
        firstByte = firstByte | 0x0a
        break
      }
      default: {
        console.log('others')
      }
    }
    let secondByte = 0x00

    if (buffer && buffer.length) {
      const lenByteList = []
      const len = buffer.length
      if (len <= 125) {
        secondByte = secondByte | len
      } else if (len >= 126 && len < 65536) {
        secondByte = secondByte | 0x7e
        for (let i = 0; i < 2; i++) {
          lenByteList.push(0xff & (len >> (i * 8)))
        }
      } else {
        secondByte = secondByte | 0x7f
        for (let i = 0; i < 8; i++) {
          lenByteList.push(0xff & (len >> (i * 8)))
        }
      }
      lenByteList.reverse()
      const prefixBuffer = Buffer.from([firstByte, secondByte, ...lenByteList])
      return Buffer.concat([prefixBuffer, buffer])
    }
    return Buffer.from([firstByte, secondByte])
  }
}

class Queue {
  constructor(maxTask) {
    this.maxTask = maxTask
    this.runningTask = 0
    this.taskQueue = []
  }

  push(task) {
    if (Array.isArray(task)) {
      task.forEach((t) => {
        this.taskQueue.push(t)
      })
    } else {
      this.taskQueue.push(task)
    }

    this.run()
  }

  async runTask(task) {
    try {
      this.runningTask++
      await task()
    } catch (e) {
      console.error(e)
    } finally {
      this.run()
      this.runningTask--
    }
  }

  run() {
    if (this.canRunTask()) {
      const task = this.taskQueue.shift()
      this.runTask(task)
      this.run()
    }
  }

  canRunTask() {
    return !this.isEmpty() && this.runningTask < this.maxTask
  }

  isEmpty() {
    return !this.taskQueue.length
  }
}

const taskQueue = new Queue(3)

const timeList = [100, 300, 500, 900, 600]
const taskList = new Array(20).fill(0).map((item, index) => {
  return () =>
    new Promise((resolve, reject) => {
      const time = index % timeList.length
      console.log('task ', index, 'time ', timeList[time], 'start')
      const timer = setTimeout(() => {
        clearTimeout(timer)
        console.log('task ', index, 'time ', timeList[time], 'finished')
        if (index % 5 === 0) {
          reject('error')
        } else {
          resolve('success')
        }
      }, timeList[time])
    })
})

taskQueue.push(taskList)