// db.js
const DB_NAME = "medical_reports";
const DB_VERSION = 1;

const initDB = () => {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(DB_NAME, DB_VERSION);

    request.onerror = () => reject(request.error);
    request.onsuccess = () => resolve(request.result);

    request.onupgradeneeded = (event) => {
      const db = event.target.result;

      // 报告基本信息表
      if (!db.objectStoreNames.contains("reports")) {
        const reportStore = db.createObjectStore("reports", { keyPath: "id" });
        reportStore.createIndex("patientId", "patientId", { unique: false });
        reportStore.createIndex("timestamp", "timestamp", { unique: false });
      }

      // 波形数据表
      if (!db.objectStoreNames.contains("waveforms")) {
        const waveformStore = db.createObjectStore("waveforms", {
          keyPath: "id",
        });
        waveformStore.createIndex("reportId", "reportId", { unique: false });
      }
    };
  });
};

// encryption.js
import JSEncrypt from "jsencrypt";

const encrypt = new JSEncrypt();
encrypt.setPublicKey(process.env.VUE_APP_PUBLIC_KEY);

export const encryptData = (data) => {
  return encrypt.encrypt(JSON.stringify(data));
};

export const decryptData = (encryptedData) => {
  const decrypt = new JSEncrypt();
  decrypt.setPrivateKey(process.env.VUE_APP_PRIVATE_KEY);
  return JSON.parse(decrypt.decrypt(encryptedData));
};

// preload.js
export const preloadReports = async (db, reportIds) => {
  const transaction = db.transaction(["reports", "waveforms"], "readonly");
  const reportStore = transaction.objectStore("reports");
  const waveformStore = transaction.objectStore("waveforms");

  const reports = await Promise.all(reportIds.map((id) => reportStore.get(id)));

  const waveforms = await Promise.all(
    reportIds.map((id) => {
      const index = waveformStore.index("reportId");
      return index.get(id);
    })
  );

  return { reports, waveforms };
};

// waveformStorage.js
const CHUNK_SIZE = 1024 * 1024; // 1MB per chunk

export const storeWaveform = async (db, reportId, waveformData) => {
  const chunks = splitIntoChunks(waveformData, CHUNK_SIZE);

  const transaction = db.transaction(["waveforms"], "readwrite");
  const store = transaction.objectStore("waveforms");

  for (let i = 0; i < chunks.length; i++) {
    await store.put({
      id: `${reportId}_${i}`,
      reportId,
      chunkIndex: i,
      data: chunks[i],
    });
  }
};

const splitIntoChunks = (data, size) => {
  const chunks = [];
  for (let i = 0; i < data.length; i += size) {
    chunks.push(data.slice(i, i + size));
  }
  return chunks;
};

// Vue2 的虚拟 DOM 结构
{
  tag: 'div',
  data: {
    attrs: { id: 'app' },
    on: { click: handler }
  },
  children: [
    {
      tag: 'span',
      data: { attrs: { class: 'text' } },
      children: ['Hello']
    }
  ]
}

// Vue3 的虚拟 DOM 结构
{
  type: 'div',
  props: {
    id: 'app',
    onClick: handler
  },
  children: [
    {
      type: 'span',
      props: { class: 'text' },
      children: ['Hello']
    }
  ]
}

function updateChildren(parentElm, oldCh, newCh) {
  let oldStartIdx = 0
  let oldEndIdx = oldCh.length - 1
  let newStartIdx = 0
  let newEndIdx = newCh.length - 1
  
  while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
    if (sameVnode(oldCh[oldStartIdx], newCh[newStartIdx])) {
      patchVnode(oldCh[oldStartIdx], newCh[newStartIdx])
      oldStartIdx++
      newStartIdx++
    } else if (sameVnode(oldCh[oldEndIdx], newCh[newEndIdx])) {
      patchVnode(oldCh[oldEndIdx], newCh[newEndIdx])
      oldEndIdx--
      newEndIdx--
    } else if (sameVnode(oldCh[oldStartIdx], newCh[newEndIdx])) {
      patchVnode(oldCh[oldStartIdx], newCh[newEndIdx])
      parentElm.insertBefore(oldCh[oldStartIdx].elm, oldCh[oldEndIdx].elm.nextSibling)
      oldStartIdx++
      newEndIdx--
    } else if (sameVnode(oldCh[oldEndIdx], newCh[newStartIdx])) {
      patchVnode(oldCh[oldEndIdx], newCh[newStartIdx])
      parentElm.insertBefore(oldCh[oldEndIdx].elm, oldCh[oldStartIdx].elm)
      oldEndIdx--
      newStartIdx++
    } else {
      // 创建 key 到 index 的映射
      const idxInOld = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
      const idxInNew = newCh[newStartIdx].key
      
      if (idxInOld[idxInNew]) {
        // 移动节点
        const vnodeToMove = oldCh[idxInOld[idxInNew]]
        patchVnode(vnodeToMove, newCh[newStartIdx])
        oldCh[idxInOld[idxInNew]] = undefined
        parentElm.insertBefore(vnodeToMove.elm, oldCh[oldStartIdx].elm)
      } else {
        // 创建新节点
        createElm(newCh[newStartIdx], parentElm, oldCh[oldStartIdx].elm)
      }
      newStartIdx++
    }
  }
}

function patchKeyedChildren(c1, c2, container) {
  let i = 0
  let e1 = c1.length - 1
  let e2 = c2.length - 1

  // 1. 从头部开始比较
  while (i <= e1 && i <= e2 && c1[i].key === c2[i].key) {
    patch(c1[i], c2[i], container)
    i++
  }

  // 2. 从尾部开始比较
  while (i <= e1 && i <= e2 && c1[e1].key === c2[e2].key) {
    patch(c1[e1], c2[e2], container)
    e1--
    e2--
  }

  // 3. 处理新增和删除的节点
  if (i > e1) {
    // 新增节点
    const nextPos = e2 + 1
    const anchor = nextPos < c2.length ? c2[nextPos].el : null
    while (i <= e2) {
      patch(null, c2[i], container, anchor)
      i++
    }
  } else if (i > e2) {
    // 删除节点
    while (i <= e1) {
      unmount(c1[i])
      i++
    }
  } else {
    // 4. 处理未知序列
    const s1 = i
    const s2 = i
    const keyToNewIndexMap = new Map()
    
    // 建立新子节点的 key 到 index 的映射
    for (let i = s2; i <= e2; i++) {
      keyToNewIndexMap.set(c2[i].key, i)
    }
    
    // 更新和移动节点
    let moved = false
    let maxNewIndexSoFar = 0
    const toBePatched = e2 - s2 + 1
    const newIndexToOldIndexMap = new Array(toBePatched).fill(0)
    
    for (let i = s1; i <= e1; i++) {
      const oldVNode = c1[i]
      const newIndex = keyToNewIndexMap.get(oldVNode.key)
      
      if (newIndex === undefined) {
        unmount(oldVNode)
      } else {
        newIndexToOldIndexMap[newIndex - s2] = i + 1
        if (newIndex >= maxNewIndexSoFar) {
          maxNewIndexSoFar = newIndex
        } else {
          moved = true
        }
        patch(oldVNode, c2[newIndex], container)
      }
    }
    
    // 移动节点
    if (moved) {
      const seq = getSequence(newIndexToOldIndexMap)
      let j = seq.length - 1
      for (let i = toBePatched - 1; i >= 0; i--) {
        const nextIndex = s2 + i
        const nextChild = c2[nextIndex]
        const anchor = nextIndex + 1 < c2.length ? c2[nextIndex + 1].el : null
        
        if (newIndexToOldIndexMap[i] === 0) {
          patch(null, nextChild, container, anchor)
        } else if (moved) {
          if (j < 0 || i !== seq[j]) {
            move(nextChild, container, anchor)
          } else {
            j--
          }
        }
      }
    }
  }
}

// Vue3 的静态标记示例
const vnode = {
  type: 'div',
  props: {
    id: 'app',
    class: 'container'
  },
  children: [
    {
      type: 'span',
      props: { class: 'text' },
      children: ['Hello'],
      patchFlag: 1 // 表示文本内容可能变化
    }
  ]
}

// Vue3 的静态提升
const hoisted = createVNode('div', null, '静态内容')

function render() {
  return createVNode('div', null, [
    hoisted,
    createVNode('span', null, state.message)
  ])
}

// Vue3 的事件监听器缓存
const render = (ctx) => {
  return createVNode('button', {
    onClick: ctx.onClick // 事件监听器被缓存
  }, '点击')
}

// 使用 shallowRef 减少响应式开销
const state = shallowRef({
  count: 0,
  user: {
    name: 'John'
  }
})

// 使用 markRaw 标记不需要响应式的对象
const staticData = markRaw({
  config: {
    theme: 'dark'
  }
})

  Vue.prototype.$mount = function (el) {
    // 挂载
    const vm = this;
    const options = vm.$options;
    el = document.querySelector(el);
    vm.$el = el;
    if(!options.render) { // 没有render方法
      let template = options.template;
      if(!template && el){ // 没有template 但是有el 获取el中的内容
        template = el.outerHTML
      }
      // 将模板编译成render函数
      const render = compileToFunctions(template)
      options.render = render;
    }
    // 渲染时用的都是render函数
    // 挂载组件
    mountComponent(vm,el);
  }

const abc