const {
  startContainer, // 起始節(jié)點
  startOffset, // 起始節(jié)點偏移量
  endContainer, // 終止節(jié)點
  endOffset // 終止節(jié)點偏移量
} = document.getSelection().getRangeAt(0)

// 創(chuàng)建一個 range 對象
const range = document.createRange()
// 設置需要獲取位置信息的文本節(jié)點以及偏移量
range.setStart(startContainer, startOffset)
range.setEnd(startContainer, startContainer.textContent.length)
// 通過 getBoundingClientRect 獲取位置信息
const rect = range.getBoundingClientRect()

// 獲取 start 到 end 深度優(yōu)先遍歷之間的所有 Text Node 節(jié)點
function getTextNodesByDfs(start: Text, end: Text) {
  if (start === end) return []
  const iterator = nodeDfsGenerator(start, false)
  const textNodes: Text[] = []
  iterator.next()
  let value = iterator.next().value
  while (value && value !== end) {
    if (node.nodeType === 3) {
      textNodes.push(value)
    }
    value = iterator.next().value
  }
  if (!value) {
    return []
  }
  return textNodes
}

// 返回節(jié)點的深度優(yōu)先迭代器
// 對于有子節(jié)點的 Node 會遍歷到兩次，不過 Text Node 肯定沒有子節(jié)點，所以不會重復統(tǒng)計到
function * nodeDfsGenerator(node: Node, isGoBack = false): Generator<Node, void, Node> {
  yield node
  // isGoBack 用于判斷是否屬于子節(jié)點遍歷結束回退到父節(jié)點，如果是那么該節(jié)點不再遍歷其子節(jié)點
  if (!isGoBack && node.childNodes.length > 0) {
    yield * nodeDfsGenerator(node.childNodes[0], false)
  } else if (node.nextSibling) {
    yield * nodeDfsGenerator(node.nextSibling, false)
  } else if (node.parentNode) {
    yield * nodeDfsGenerator(node.parentNode, true)
  }
}

// 將一個跨行的 range 切割為多個不跨行的 range
function splitRange(node: Text, startOffset: number, endOffset: number): Range[] {
  const range = document.createRange()
  const rowTop = getCharTop(node, startOffset)
  // 字符數(shù)小于兩個不用判斷是否跨行
  // 頭尾高度一致說明在同一行
  if ((endOffset - startOffset < 2) || rowTop === getCharTop(node, endOffset - 1)) {
    range.setStart(node, startOffset)
    range.setEnd(node, endOffset)
    return [range]
  } else {
    const last = findRowLastChar(rowTop, node, startOffset, endOffset - 1)
    range.setStart(node, startOffset)
    range.setEnd(node, last + 1)
    const others = splitRange(node, last + 1, endOffset)
    return [range, ...others]
  }
}

// 二分法找到 range 某一行的最右字符
function findRowLastChar(top: number, node: Text, start: number, end: number): number {
  if (end - start === 1) {
    return getCharTop(node, end) === top ? end : start
  }
  const mid = (end + start) >> 1
  return getCharTop(node, mid) === top
    ? findRowLastChar(top, node, mid, end)
    : findRowLastChar(top, node, start, mid)
}

// 獲取 range 某個字符位置的 top 值
function getCharTop(node: Text, offset: number) {
  return getCharRect(node, offset).top
}

// 獲取 range 某個字符位置的 DOMRect
function getCharRect(node: Text, offset: number) {
  const range = document.createRange()
  range.setStart(node, offset)
  range.setEnd(node, offset + 1 > node.textContent!.length ? offset : offset + 1)
  return range.getBoundingClientRect()
}

// 獲取從文本容器到文本節(jié)點的路徑信息，用于存儲
function getPath(textNode: Text) {
  const path = [0]
  let parentNode = textNode.parentNode
  let cur: Node = textNode
  while (parentNode) {
    if (cur === parentNode.firstChild) {
      // this.root 為文本容器
      if (parentNode === this.root) {
        break
      } else {
        cur = parentNode
        parentNode = cur.parentNode
        path.unshift(0)
      }
    } else {
      cur = cur.previousSibling!
      path[0]++
    }
  }
  return parentNode ? path : null
}

// 根據(jù)路徑信息獲取文本節(jié)點，用于返顯
getNodeByPath(path: number[]) {
  // this.root 為文本容器
  let node: Node = this.root
  for (let i = 0; i < path.length; i++) {
    if (node && node.childNodes && node.childNodes[path[i]]) {
      node = node.childNodes[path[i]]
    } else {
      return null
    }
  }
  return node
}