/**
 * 文件数据信息类
 */
class File {
  /**
   * 构造函数
   * @param {String} path 全路径
   * @param {String} parent 父级路径
   * @param {String} name 文件名
   * @param {String} size 大小(b)
   * @param {String} isdir 是否为文件
   * @param {String} {origin} 百度云文件信息的源对象
   */
  constructor(path, parent, name, size, isdir, origin) {
    this.path = path
    this.parent = parent
    this.name = name
    this.size = size
    this.isdir = isdir
    this.orgin = origin
  }
}
/**
 * 获取指定文件夹下的一级文件/文件夹列表
 * @param {String} path 绝对路径
 * @returns {Promise} 文件/文件夹列表
 */
async function getDir(path) {
  var baseUrl = 'https://pan.baidu.com/api/list?'
  try {
    var res = await fetch(`${baseUrl}dir=${encodeURIComponent(path)}`)
    var json = await res.json()
    return json.list
  } catch (err) {
    console.log(`读取文件夹 ${path} 发生了错误：`, err)
    return []
  }
}
/**
 * 将数组异步压平一层
 * @param {Array} arr 数组
 * @param {Function} fn 映射方法
 */
async function asyncFlatMap(arr, fn) {
  var res = []
  for (const i in arr) {
    res.push(...(await fn(arr[i])))
  }
  return res
}
/**
 * 递归获取到所有的子级文件/文件夹
 * @param {String} path 指定获取的文件夹路径
 * @returns {Array} 指定文件夹下所有的文件/文件夹列表
 */
async function syncList(path) {
  var fileList = await getDir(path)
  return asyncFlatMap(fileList, async file => {
    var res = new File(
      file.path,
      path,
      file.server_filename,
      file.size,
      file.isdir,
      file,
    )
    if (res.isdir !== 1) {
      return [res]
    }
    return [res].concat(await syncList(res.path))
  })
}

/**
 * 文件数据信息类
 */
class File {
  /**
   * 构造函数
   * @param {String} path 全路径
   * @param {String} parent 父级路径
   * @param {String} name 文件名
   * @param {String} size 大小(b)
   * @param {String} isdir 是否为文件
   * @param {String} {origin} 百度云文件信息的源对象
   */
  constructor(path, parent, name, size, isdir, origin) {
    this.path = path
    this.parent = parent
    this.name = name
    this.size = size
    this.isdir = isdir
    this.orgin = origin
  }
}
/**
 * 等待指定的时间/等待指定表达式成立
 * @param {Number|Function} param 等待时间/等待条件
 * @returns {Promise} Promise 对象
 */
function wait(param) {
  return new Promise(resolve => {
    if (typeof param === 'number') {
      setTimeout(resolve, param)
    } else if (typeof param === 'function') {
      var timer = setInterval(() => {
        if (param()) {
          clearInterval(timer)
          resolve()
        }
      }, 100)
    } else {
      resolve()
    }
  })
}
/**
 * 获取指定文件夹下的一级文件/文件夹列表
 * @param {String} path 绝对路径
 * @returns {Promise} 文件/文件夹列表
 */
async function getDir(path) {
  var baseUrl = 'https://pan.baidu.com/api/list?'
  try {
    var res = await fetch(`${baseUrl}dir=${encodeURIComponent(path)}`)
    var json = await res.json()
    return json.list
  } catch (err) {
    console.log(`读取文件夹 ${path} 发生了错误：`, err)
    return []
  }
}
/**
 * 递归获取所有文件/文件夹
 * 测试获取 34228 条数据
 * - 100 线程：156518ms
 * - 5   线程：220500ms
 * - 1   线程：超过 20min
 * 实现：
 * 1. 请求文件夹下的所有文件/文件夹
 * 2. 如果是文件则直接添加到结果数组中
 * 3. 如果是文件夹则递归调用当前方法
 * @param {String} [path] 指定文件夹，默认为根路径
 * @param {Number} [limit] 指定限定异步数量，默认为 5
 * @returns {Promise} 异步对象
 */
async function asyncList(path = '/', limit = 5) {
  return new Promise(resolve => {
    var count = 1
    var execCount = 0
    var waitQueue = 0

    // 结果数组
    var result = []
    async function children(path) {
      waitQueue++
      await wait(() => execCount < limit)
      waitQueue--
      execCount++
      getDir(path).then(fileList => {
        fileList.forEach(file => {
          var res = new File(
            file.path,
            path,
            file.server_filename,
            file.size,
            file.isdir,
            file,
          )
          result.push(res)
          if (res.isdir === 1) {
            children(res.path)
          }
        })
        if (--execCount === 0 && waitQueue === 0) {
          resolve(result)
        }
      })
    }
    children(path)
  })
}

/**
 * 测试函数的执行时间
 * 注：如果函数返回 Promise，则该函数也会返回 Promise，否则直接返回执行时间
 * @param {Function} 需要测试的函数
 * @returns {Number|Promise} 执行的毫秒数
 */
function timing(fn) {
  var begin = performance.now()
  var result = fn()
  if (!(result instanceof Promise)) {
    return performance.now() - begin
  }
  return result.then(() => performance.now() - begin)
}

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0)
}

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0)
}

for (var i = 0; i < 3; i++) {
  var k = 10 - i
}
console.log(`i: ${i}, k: ${k}`)

// 结果：
// i: 3, k: 8

var i = 0
var k
for (; i < 3; ) {
  k = 10 - i
  i++
}

for (let i = 0; i < 3; i++) {
  let k = 10 - i
}
console.log(`i: ${i}, k: ${k}`)

// 结果：
// Uncaught ReferenceError: i is not defined

for (var i = 0; i < 3; console.log('in for expression', i), i++) {
  let i
  console.log('in for block', i)
}

// 结果：
// in for block undefined
// in for expression 0
// in for block undefined
// in for expression 1
// in for block undefined
// in for expression 2

for (var i = 0; i < 3; i++) {
  ;(_i => {
    setTimeout(() => console.log(_i), 0)
    i = _i
  })(i)
}

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0)
}

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0)
}

document.oncopy = event => false

// 强制复制
document.addEventListener(
  'copy',
  event => {
    event.clipboardData.setData(
      'text/plain',
      document.getSelection().toString(),
    )
    // 阻止默认的事件处理
    event.preventDefault()
  },
  true,
)

/**
 * 字符串安全的转换为小写
 * @param {String} str 字符串
 * @returns {String} 转换后得到的全小写字符串
 */
function toLowerCase(str) {
  if (!str || typeof str !== 'string') {
    return str
  }
  return str.toLowerCase()
}

/**
 * 判断指定元素是否是可编辑元素
 * 注：可编辑元素并不一定能够进行编辑，例如只读的 input 元素
 * @param {Element} el 需要进行判断的元素
 * @returns {Boolean} 是否为可编辑元素
 */
function isEditable(el) {
  var inputEls = ['input', 'date', 'datetime', 'select', 'textarea']
  return (
    el && (el.isContentEditable || inputEls.includes(toLowerCase(el.tagName)))
  )
}

/**
 * 获取输入框中光标所在位置
 * @param  {Element} el 需要获取的输入框元素
 * @returns {Number} 光标所在位置的下标
 */
function getCusorPostion(el) {
  return el.selectionStart
}

/**
 * 设置输入框中选中的文本/光标所在位置
 * @param {Element} el 需要设置的输入框元素
 * @param {Number} start 光标所在位置的下标
 * @param {Number} {end} 结束位置，默认为输入框结束
 */
function setCusorPostion(el, start, end = start) {
  el.focus()
  el.setSelectionRange(start, end)
}

/**
 * 在指定范围内删除文本
 * @param {Element} el 需要设置的输入框元素
 * @param {Number} {start} 开始位置，默认为当前选中开始位置
 * @param {Number} {end} 结束位置，默认为当前选中结束位置
 */
function removeText(el, start = el.selectionStart, end = el.selectionEnd) {
  // 删除之前必须要 [记住] 当前光标的位置
  var index = getCusorPostion(el)
  var value = el.value
  el.value = value.substr(0, start) + value.substr(end, value.length)
  setCusorPostion(el, index)
}

// 强制剪切
document.addEventListener(
  'cut',
  event => {
    event.clipboardData.setData(
      'text/plain',
      document.getSelection().toString(),
    )
    // 如果是可编辑元素还要进行删除
    if (isEditable(event.target)) {
      removeText(event.target)
    }
    event.preventDefault()
  },
  true,
)

/**
 * 获取到最后一个获得焦点的元素
 */
var getLastFocus = (lastFocusEl => {
  document.addEventListener(
    'focus',
    event => {
      lastFocusEl = event.target
    },
    true,
  )
  document.addEventListener(
    'blur',
    event => {
      lastFocusEl = null
    },
    true,
  )
  return () => lastFocusEl
})(null)

/**
 * 字符串安全的转换为小写
 * @param {String} str 字符串
 * @returns {String} 转换后得到的全小写字符串
 */
function toLowerCase(str) {
  if (!str || typeof str !== 'string') {
    return str
  }
  return str.toLowerCase()
}

/**
 * 判断指定元素是否是可编辑元素
 * 注：可编辑元素并不一定能够进行编辑，例如只读的 input 元素
 * @param {Element} el 需要进行判断的元素
 * @returns {Boolean} 是否为可编辑元素
 */
function isEditable(el) {
  var inputEls = ['input', 'date', 'datetime', 'select', 'textarea']
  return (
    el && (el.isContentEditable || inputEls.includes(toLowerCase(el.tagName)))
  )
}

/**
 * 获取输入框中光标所在位置
 * @param  {Element} el 需要获取的输入框元素
 * @returns {Number} 光标所在位置的下标
 */
function getCusorPostion(el) {
  return el.selectionStart
}

/**
 * 设置输入框中选中的文本/光标所在位置
 * @param {Element} el 需要设置的输入框元素
 * @param {Number} start 光标所在位置的下标
 * @param {Number} {end} 结束位置，默认为输入框结束
 */
function setCusorPostion(el, start, end = start) {
  el.focus()
  el.setSelectionRange(start, end)
}

/**
 * 在指定位置后插入文本
 * @param {Element} el 需要设置的输入框元素
 * @param {String} value 要插入的值
 * @param {Number} {start} 开始位置，默认为当前光标处
 */
function insertText(el, text, start = getCusorPostion(el)) {
  var value = el.value
  el.value = value.substr(0, start) + text + value.substr(start)
  setCusorPostion(el, start + text.length)
}

/**
 * 在指定范围内删除文本
 * @param {Element} el 需要设置的输入框元素
 * @param {Number} {start} 开始位置，默认为当前选中开始位置
 * @param {Number} {end} 结束位置，默认为当前选中结束位置
 */
function removeText(el, start = el.selectionStart, end = el.selectionEnd) {
  // 删除之前必须要 [记住] 当前光标的位置
  var index = getCusorPostion(el)
  var value = el.value
  el.value = value.substr(0, start) + value.substr(end, value.length)
  setCusorPostion(el, index)
}

// 强制粘贴
document.addEventListener(
  'paste',
  event => {
    // 获取当前剪切板内容
    var clipboardData = event.clipboardData
    var items = clipboardData.items
    var item = items[0]
    if (item.kind !== 'string') {
      return
    }
    var text = clipboardData.getData(item.type)
    // 获取当前焦点元素
    // 粘贴的时候获取不到焦点？
    var focusEl = getLastFocus()
    // input 居然不是 [可编辑] 的元素？
    if (isEditable(focusEl)) {
      removeText(focusEl)
      insertText(focusEl, text)
      event.preventDefault()
    }
  },
  true,
)

;(function() {
  'use strict'

  /**
   * 两种思路：
   * 1. 自己实现
   * 2. 替换元素
   */

  /**
   * 获取到最后一个获得焦点的元素
   */
  var getLastFocus = (lastFocusEl => {
    document.addEventListener(
      'focus',
      event => {
        lastFocusEl = event.target
      },
      true,
    )
    document.addEventListener(
      'blur',
      event => {
        lastFocusEl = null
      },
      true,
    )
    return () => lastFocusEl
  })(null)

  /**
   * 字符串安全的转换为小写
   * @param {String} str 字符串
   * @returns {String} 转换后得到的全小写字符串
   */
  function toLowerCase(str) {
    if (!str || typeof str !== 'string') {
      return str
    }
    return str.toLowerCase()
  }

  /**
   * 字符串安全的转换为大写
   * @param {String} str 字符串
   * @returns {String} 转换后得到的全大写字符串
   */
  function toUpperCase(str) {
    if (!str || typeof str !== 'string') {
      return str
    }
    return str.toUpperCase()
  }

  /**
   * 判断指定元素是否是可编辑元素
   * 注：可编辑元素并不一定能够进行编辑，例如只读的 input 元素
   * @param {Element} el 需要进行判断的元素
   * @returns {Boolean} 是否为可编辑元素
   */
  function isEditable(el) {
    var inputEls = ['input', 'date', 'datetime', 'select', 'textarea']
    return (
      el && (el.isContentEditable || inputEls.includes(toLowerCase(el.tagName)))
    )
  }

  /**
   * 获取输入框中光标所在位置
   * @param  {Element} el 需要获取的输入框元素
   * @returns {Number} 光标所在位置的下标
   */
  function getCusorPostion(el) {
    return el.selectionStart
  }

  /**
   * 设置输入框中选中的文本/光标所在位置
   * @param {Element} el 需要设置的输入框元素
   * @param {Number} start 光标所在位置的下标
   * @param {Number} {end} 结束位置，默认为输入框结束
   */
  function setCusorPostion(el, start, end = start) {
    el.focus()
    el.setSelectionRange(start, end)
  }

  /**
   * 在指定位置后插入文本
   * @param {Element} el 需要设置的输入框元素
   * @param {String} value 要插入的值
   * @param {Number} {start} 开始位置，默认为当前光标处
   */
  function insertText(el, text, start = getCusorPostion(el)) {
    var value = el.value
    el.value = value.substr(0, start) + text + value.substr(start)
    setCusorPostion(el, start + text.length)
  }

  /**
   * 在指定范围内删除文本
   * @param {Element} el 需要设置的输入框元素
   * @param {Number} {start} 开始位置，默认为当前选中开始位置
   * @param {Number} {end} 结束位置，默认为当前选中结束位置
   */
  function removeText(el, start = el.selectionStart, end = el.selectionEnd) {
    // 删除之前必须要 [记住] 当前光标的位置
    var index = getCusorPostion(el)
    var value = el.value
    el.value = value.substr(0, start) + value.substr(end, value.length)
    setCusorPostion(el, index)
  }

  // 强制复制
  document.addEventListener(
    'copy',
    event => {
      event.clipboardData.setData(
        'text/plain',
        document.getSelection().toString(),
      )
      event.preventDefault()
    },
    true,
  )

  // 强制剪切
  document.addEventListener(
    'cut',
    event => {
      event.clipboardData.setData(
        'text/plain',
        document.getSelection().toString(),
      )
      // 如果是可编辑元素还要进行删除
      if (isEditable(event.target)) {
        removeText(event.target)
      }
      event.preventDefault()
    },
    true,
  )

  // 强制粘贴
  document.addEventListener(
    'paste',
    event => {
      // 获取当前剪切板内容
      var clipboardData = event.clipboardData
      var items = clipboardData.items
      var item = items[0]
      if (item.kind !== 'string') {
        return
      }
      var text = clipboardData.getData(item.type)
      // 获取当前焦点元素
      // 粘贴的时候获取不到焦点？
      var focusEl = getLastFocus()
      // input 居然不是 [可编辑] 的元素？
      if (isEditable(focusEl)) {
        removeText(focusEl)
        insertText(focusEl, text)
        event.preventDefault()
      }
    },
    true,
  )

  function selection() {
    var dom
    document.onmousedown = event => {
      dom = event.target
      // console.log('点击: ', dom)
      debugger
      console.log('光标所在处: ', getCusorPostion(dom))
    }
    document.onmousemove = event => {
      console.log('移动: ', dom)
    }
    document.onmouseup = event => {
      console.log('松开: ', dom)
    }
  }
})()

// ==UserScript==
// @name         解除网页限制
// @namespace    http://github.com/rxliuli
// @version      1.0
// @description  破解禁止复制/剪切/粘贴/选择/右键菜单的网站
// @author       rxliuli
// @include      https://www.jianshu.com/*
// @grant        GM.getValue
// @grant        GM.setValue
// 这里的 @run-at 非常重要，设置在文档开始时就载入脚本
// @run-at       document-start
// ==/UserScript==

;(() => {
  /**
   * 监听所有的 addEventListener, removeEventListener 事件
   */
  var documentAddEventListener = document.addEventListener
  var eventTargetAddEventListener = EventTarget.prototype.addEventListener
  var documentRemoveEventListener = document.removeEventListener
  var eventTargetRemoveEventListener = EventTarget.prototype.removeEventListener
  var events = []

  /**
   * 用来保存监听到的事件信息
   */
  class Event {
    constructor(el, type, listener, useCapture) {
      this.el = el
      this.type = type
      this.listener = listener
      this.useCapture = useCapture
    }
  }

  /**
   * 自定义的添加事件监听函数
   * @param {String} type 事件类型
   * @param {EventListener} listener 事件监听函数
   * @param {Boolean} {useCapture} 是否需要捕获事件冒泡，默认为 false
   */
  function addEventListener(type, listener, useCapture = false) {
    var _this = this
    var $addEventListener =
      _this === document
        ? documentAddEventListener
        : eventTargetAddEventListener
    events.push(new Event(_this, type, listener, useCapture))
    $addEventListener.apply(this, arguments)
  }

  /**
   * 自定义的根据类型删除事件函数
   * 该方法会删除这个类型下面全部的监听函数，不管数量
   * @param {String} type 事件类型
   */
  function removeEventListenerByType(type) {
    var _this = this
    var $removeEventListener =
      _this === document
        ? documentRemoveEventListener
        : eventTargetRemoveEventListener
    var removeIndexs = events
      .map((e, i) => (e.el === _this || e.type === arguments[0] ? i : -1))
      .filter(i => i !== -1)
    removeIndexs.forEach(i => {
      var e = events[i]
      $removeEventListener.apply(e.el, [e.type, e.listener, e.useCapture])
    })
    removeIndexs.sort((a, b) => b - a).forEach(i => events.splice(i, 1))
  }

  function clearEvent() {
    var eventTypes = [
      'copy',
      'cut',
      'select',
      'contextmenu',
      'selectstart',
      'dragstart',
    ]
    document.querySelectorAll('*').forEach(el => {
      eventTypes.forEach(type => el.removeEventListenerByType(type))
    })
  }

  ;(function() {
    document.addEventListener = EventTarget.prototype.addEventListener = addEventListener
    document.removeEventListenerByType = EventTarget.prototype.removeEventListenerByType = removeEventListenerByType
  })()

  window.onload = function() {
    clearEvent()
  }
})()

/**
 * 行转列
 * @param {Array} arr 需要进行行转列的数组
 * @returns {Array} 行转列得到的数组
 */
function rowToCol(arr) {
  /**
   * js 数组按照某个条件进行分组
   * 注：分组完成后会得到一个二维数组，并且顺序会被打乱
   * 时间复杂度为 2On
   * @param {Function} {fn} 元素分组的方法，默认使用 {@link JSON.stringify()}
   * @returns {Array} 新的数组
   */
  Array.prototype.groupBy = function(fn = item => JSON.stringify(item)) {
    // 将元素按照分组条件进行分组得到一个 条件 -> 数组 的对象
    const obj = {}
    this.forEach(item => {
      const name = fn(item)
      // 如果已经有这个键了就直接追加, 否则先将之赋值为 [] 再追加元素
      ;(obj[name] || (obj[name] = [])).push(item)
    })
    // 将对象转换为数组
    return Object.keys(obj).map(key => obj[key])
  }

  /**
   * js 的数组去重方法
   * @param {Function} {fn} 唯一标识元素的方法，默认使用 {@link JSON.stringify()}
   * @returns {Array} 进行去重操作之后得到的新的数组 (原数组并未改变)
   */
  Array.prototype.uniqueBy = function(fn = item => JSON.stringify(item)) {
    const obj = {}
    return this.filter(function(item) {
      return obj.hasOwnProperty(fn(item)) ? false : (obj[fn(item)] = true)
    })
  }

  /**
   * 获取所有的科目 -> 分数映射表
   * 看起来函数有点奇怪，但实际上只是一个闭包函数而已
   * @returns {Object} 所有的科目 -> 分数映射表的拷贝
   */
  const subjectMap = (obj => () => Object.assign({}, obj))(
    arr
      .map(row => row.subject)
      .uniqueBy()
      .reduce((res, subject) => {
        res[subject] = 0
        return res
      }, {})
  )
  return arr
    .groupBy(row => row.name)
    .map(arr =>
      arr
        .uniqueBy(row => row.subject)
        .reduce((res, temp) => {
          res = Object.assign(subjectMap(), res)
          res.name = temp.name
          res[temp.subject] = temp.score
          return res
        }, {})
    )
}