const crypto = require("crypto");

const PBKDF2_ITERATIONS = 10000;

function encrypt(text, masterKey) {
  const iv = crypto.randomBytes(12);
  const keyBuffer = Buffer.from(masterKey, "hex");
  const cipher = crypto.createCipheriv("aes-256-gcm", keyBuffer, iv);

  let encrypted = cipher.update(text, "utf8", "base64");
  encrypted += cipher.final("base64");

  return {
    ciphertext: encrypted,
    iv: iv.toString("base64"),
    authTag: cipher.getAuthTag().toString("base64"),
  };
}

function encryptCEK(cek, wrapKey) {
  const iv = crypto.randomBytes(12);
  const keyBuffer = Buffer.from(wrapKey, "hex");
  const cipher = crypto.createCipheriv("aes-256-gcm", keyBuffer, iv);

  let encrypted = cipher.update(cek);
  encrypted = Buffer.concat([encrypted, cipher.final()]);

  return {
    type: "fido2",
    encryptedCEK: encrypted.toString("base64"),
    iv: iv.toString("base64"),
    authTag: cipher.getAuthTag().toString("base64"),
  };
}

function derivePBKDF2Key(password, salt, iterations) {
  return crypto.pbkdf2Sync(
    Buffer.from(password, "utf8"),
    Buffer.from(salt, "utf8"),
    iterations,
    32,
    "sha256"
  );
}

function encryptCEKWithPassword(cek, password, salt, iterations) {
  const wrapKey = derivePBKDF2Key(password, salt, iterations);
  const iv = crypto.randomBytes(12);
  const cipher = crypto.createCipheriv("aes-256-gcm", wrapKey, iv);

  let encrypted = cipher.update(cek);
  encrypted = Buffer.concat([encrypted, cipher.final()]);

  return {
    type: "password",
    encryptedCEK: encrypted.toString("base64"),
    iv: iv.toString("base64"),
    authTag: cipher.getAuthTag().toString("base64"),
    salt: salt,
  };
}

function genTemplate(abbrlink, encData, wrappedKeys, prfSalt, cache, passwordHint) {
  const wrappedKeysJson = JSON.stringify(wrappedKeys).replace(/"/g, """);
  const hasFido2 = wrappedKeys.some((k) => k.type === "fido2");
  const hasPassword = wrappedKeys.some((k) => k.type === "password");

  const fido2Html = hasFido2
    ? `<button class="decrypt-btn" id="fido2-verify-btn"><i class="fa fa-fingerprint"></i> 通行密钥验证</button>`
    : "";

  const passwordHtml = hasPassword
    ? `<div class="password-decrypt-group">
        <button class="decrypt-btn" id="show-password-btn"><i class="fa fa-lock"></i> 密码验证</button>
        <div class="password-input-group" id="password-input-group" style="display:none">
          <input type="password" class="password-input" id="password-input" placeholder="输入密码" />
          <button class="decrypt-btn" id="password-decrypt-btn"><i class="fa fa-key"></i> 确定</button>
        </div>
      </div>`
    : "";

  return `<div class="encrypted-post-container" 
    data-ciphertext="${encData.ciphertext}"
    data-iv="${encData.iv}"
    data-auth-tag="${encData.authTag}"
    data-abbrlink="${abbrlink || ""}"
    data-wrapped-keys='${wrappedKeysJson}'
    data-prf-salt="${prfSalt}"
    data-cache="${cache || 0}"
    data-password-hint="${passwordHint || ""}">
  <div class="encrypted-post-notice">
    <div class="decrypt-methods">${fido2Html}${passwordHtml}</div>
    <div class="verification-status" id="verification-status"></div>
  </div>
  <div class="decrypted-content" id="decrypted-content" style="display:none"></div>
</div>`.trim();
}

function getKeys(cfg) {
  return Array.isArray(cfg.keys) ? cfg.keys : cfg.key ? [cfg.key] : [];
}

function validateConfig(cfg) {
  if (!cfg?.enabled) {
    hexo.log.warn("加密功能未启用");
    return false;
  }

  if (!cfg.salt || !/^[a-fA-F0-9]{64}$/.test(cfg.salt)) {
    hexo.log.error("PRF Salt 配置无效");
    return false;
  }

  const keys = getKeys(cfg);
  if (keys.length === 0) {
    hexo.log.error("请先注册 FIDO2 通行密钥");
    return false;
  }

  for (const key of keys) {
    if (!/^[a-fA-F0-9]{64}$/.test(key)) {
      hexo.log.error(`密钥格式无效: ${key}`);
      return false;
    }
  }
  return true;
}

hexo.extend.filter.register(
  "after_post_render",
  function (data) {
    if (!data.encrypted) return data;

    const cfg = hexo.config.encryption;
    if (!validateConfig(cfg)) return data;

    try {
      const cek = crypto.randomBytes(32);
      const encData = encrypt(data.content, cek.toString("hex"));
      const wrappedKeys = getKeys(cfg).map((key) => encryptCEK(cek, key));

      if (data.password) {
        wrappedKeys.push(
          encryptCEKWithPassword(
            cek,
            String(data.password),
            String(cfg.salt),
            PBKDF2_ITERATIONS
          )
        );
      }

      data.content = genTemplate(
        data.abbrlink,
        encData,
        wrappedKeys,
        cfg.salt,
        cfg.cache,
        data.hint
      );
      hexo.log.info(`Encrypted: ${data.title}`);
    } catch (err) {
      hexo.log.error(`Encrypted: ${data.title} ${err}`);
    }
    return data;
  },
  15
);

const PBKDF2_ITERATIONS = 500000;

function getRPID() {
  const hostname = location.hostname;
  return hostname === "127.0.0.1" ? "localhost" : hostname;
}

class Decryptor {
  constructor() {
    this.container = null;
    this.data = null;
    this.rpId = getRPID();
  }

  init() {
    this.container = document.querySelector(".encrypted-post-container");
    if (!this.container) return;

    this.data = {
      ciphertext: this.container.dataset.ciphertext,
      iv: this.container.dataset.iv,
      authTag: this.container.dataset.authTag,
      abbrlink: this.container.dataset.abbrlink,
      wrappedKeys: JSON.parse(this.container.dataset.wrappedKeys || "[]"),
      prfSalt: this.container.dataset.prfSalt,
      cache: parseInt(this.container.dataset.cache) || 0,
      passwordHint: this.container.dataset.passwordHint || "",
    };

    if (this.checkCache()) return;

    const fido2Btn = document.getElementById("fido2-verify-btn");
    if (fido2Btn) {
      if (!window.PublicKeyCredential) {
        this.showStatus("浏览器不支持 FIDO2/WebAuthn", "error");
      } else {
        fido2Btn.onclick = () => this.authenticate();
      }
    }

    const showPasswordBtn = document.getElementById("show-password-btn");
    if (showPasswordBtn) {
      showPasswordBtn.onclick = () => this.showPasswordInput();
    }

    const passwordBtn = document.getElementById("password-decrypt-btn");
    if (passwordBtn) {
      passwordBtn.onclick = () => this.decryptWithPassword();
    }

    const passwordInput = document.getElementById("password-input");
    if (passwordInput) {
      passwordInput.addEventListener("keydown", (e) => {
        if (e.key === "Enter") this.decryptWithPassword();
      });
    }
  }

  getCacheKey() {
    return this.data.abbrlink;
  }

  showPasswordInput() {
    const showBtn = document.getElementById("show-password-btn");
    const inputGroup = document.getElementById("password-input-group");
    const passwordInput = document.getElementById("password-input");

    if (showBtn) showBtn.style.display = "none";
    if (inputGroup) inputGroup.style.display = "flex";
    if (this.data.passwordHint) this.showPasswordHint();

    if (passwordInput) {
      passwordInput.focus();
      passwordInput.addEventListener("input", () =>
        this.updatePasswordButtonState()
      );
    }
    this.updatePasswordButtonState();
  }

  showPasswordHint() {
    const inputGroup = document.getElementById("password-input-group");
    if (!inputGroup) return;

    let hintElement = inputGroup.querySelector(".password-hint");
    if (!hintElement) {
      hintElement = document.createElement("div");
      hintElement.className = "password-hint";
      inputGroup.appendChild(hintElement);
    }
    hintElement.textContent = this.data.passwordHint;
  }

  updatePasswordButtonState() {
    const passwordInput = document.getElementById("password-input");
    const passwordBtn = document.getElementById("password-decrypt-btn");

    if (!passwordInput || !passwordBtn) return;

    const hasPassword = passwordInput.value.trim().length > 0;
    passwordBtn.disabled = !hasPassword;
    passwordBtn.style.opacity = hasPassword ? "1" : "0.5";
    passwordBtn.style.cursor = hasPassword ? "pointer" : "not-allowed";
  }

  checkCache() {
    if (!this.data.cache) return false;

    try {
      const cached = localStorage.getItem(this.getCacheKey());
      if (!cached) return false;

      const { html, expired } = JSON.parse(cached);
      if (Date.now() < expired) {
        this.render(html);
        setTimeout(() => this.hideStatus(), 2000);
        return true;
      }
      localStorage.removeItem(this.getCacheKey());
      return false;
    } catch (_) {
      return false;
    }
  }

  saveCache(html) {
    if (!this.data.cache) return;

    try {
      const expired = Date.now() + this.data.cache * 60 * 1000;
      localStorage.setItem(
        this.getCacheKey(),
        JSON.stringify({ html, expired })
      );
    } catch (_) {}
  }

  async authenticate() {
    this.showStatus("正在验证身份...", "info");

    try {
      const challenge = crypto.getRandomValues(new Uint8Array(32));

      const prfSalt = await crypto.subtle.digest(
        "SHA-256",
        new TextEncoder().encode(this.data.prfSalt)
      );

      const assertion = await navigator.credentials.get({
        publicKey: {
          challenge,
          rpId: this.rpId,
          userVerification: "preferred",
          timeout: 60000,
          extensions: { prf: { eval: { first: prfSalt } } },
        },
      });

      const prfResults = assertion.getClientExtensionResults().prf;
      if (!prfResults?.results?.first) throw new Error("PRF 扩展不可用");

      const wrappingKey = prfResults.results.first;

      this.showStatus("验证成功，正在解密...", "success");
      setTimeout(() => this.unwrapAndDecrypt(wrappingKey), 300);
    } catch (e) {
      if (e.name === "NotAllowedError") {
        this.showStatus("验证被拒绝", "error");
      } else if (e.name === "InvalidStateError" || e.name === "NotFoundError") {
        this.showStatus("未注册的通行密钥", "error");
      } else {
        this.showStatus(`验证失败: ${e.message}`, "error");
      }
    }
  }

  async derivePBKDF2Key(password, salt, iterations = PBKDF2_ITERATIONS) {
    const passwordBuffer = new TextEncoder().encode(password);
    const saltBuffer = new TextEncoder().encode(salt);

    const baseKey = await crypto.subtle.importKey(
      "raw",
      passwordBuffer,
      "PBKDF2",
      false,
      ["deriveBits"]
    );

    const derivedBits = await crypto.subtle.deriveBits(
      {
        name: "PBKDF2",
        salt: saltBuffer,
        iterations: iterations,
        hash: "SHA-256",
      },
      baseKey,
      256
    );

    return derivedBits;
  }

  async decryptWithPassword() {
    const passwordInput = document.getElementById("password-input");
    const password = passwordInput?.value.trim();

    if (!password) {
      this.showStatus("未输入密码", "error");
      return;
    }

    this.showStatus("正在解密...", "info");

    try {
      const passwordWrapped = this.data.wrappedKeys.find(
        (k) => k.type === "password"
      );
      if (!passwordWrapped) throw new Error("不支持密码认证");

      const wrappingKey = await this.derivePBKDF2Key(
        password,
        passwordWrapped.salt
      );
      await this.unwrapAndDecrypt(wrappingKey, "password");
    } catch (e) {
      this.showStatus(`解密失败: ${e.message}`, "error");
    }
  }

  combineWithAuthTag(data, authTag) {
    const combined = new Uint8Array(data.byteLength + authTag.byteLength);
    combined.set(new Uint8Array(data), 0);
    combined.set(new Uint8Array(authTag), data.byteLength);
    return combined;
  }

  async unwrapAndDecrypt(wrappingKey, type = "fido2") {
    try {
      const wrapKeyBuffer = await crypto.subtle.importKey(
        "raw",
        wrappingKey,
        { name: "AES-GCM" },
        false,
        ["decrypt"]
      );
      const targetKeys = this.data.wrappedKeys.filter((k) => k.type === type);

      let cek = null;
      for (const wrapped of targetKeys) {
        try {
          const encCEK = this.b64ToAB(wrapped.encryptedCEK);
          const wrapIV = this.b64ToAB(wrapped.iv);
          const wrapAuthTag = this.b64ToAB(wrapped.authTag);
          const wrappedCEK = this.combineWithAuthTag(encCEK, wrapAuthTag);

          cek = await crypto.subtle.decrypt(
            { name: "AES-GCM", iv: wrapIV, tagLength: 128 },
            wrapKeyBuffer,
            wrappedCEK
          );
          break;
        } catch (_) {}
      }

      if (!cek)
        throw new Error(type === "password" ? "密码错误" : "通行密钥无权限");
      await this.decryptContent(cek);
    } catch (e) {
      this.showStatus(`解密失败: ${e.message}`, "error");
    }
  }

  async decryptContent(decryptionKey) {
    try {
      this.showStatus("正在解密...", "info");

      const ciphertext = this.b64ToAB(this.data.ciphertext);
      const iv = this.b64ToAB(this.data.iv);
      const authTag = this.b64ToAB(this.data.authTag);
      const encData = this.combineWithAuthTag(ciphertext, authTag);

      const key = await crypto.subtle.importKey(
        "raw",
        decryptionKey,
        { name: "AES-GCM" },
        false,
        ["decrypt"]
      );
      const decrypted = await crypto.subtle.decrypt(
        { name: "AES-GCM", iv, tagLength: 128 },
        key,
        encData
      );

      const html = new TextDecoder().decode(decrypted);
      this.saveCache(html);
      this.render(html);
      setTimeout(() => this.hideStatus(), 2000);
    } catch (e) {
      this.showStatus(`解密失败: ${e.message}`, "error");
    }
  }

  executeScripts(container) {
    const scripts = container.querySelectorAll("script");
    scripts.forEach((oldScript) => {
      const newScript = document.createElement("script");
      Array.from(oldScript.attributes).forEach((attr) => {
        newScript.setAttribute(attr.name, attr.value);
      });
      newScript.textContent = oldScript.textContent;
      oldScript.parentNode.replaceChild(newScript, oldScript);
    });
  }

  render(html) {
    const content = document.getElementById("decrypted-content");
    const notice = document.querySelector(".encrypted-post-notice");
    if (!content || !notice) return;

    notice.style.display = "none";
    content.innerHTML = html;
    this.executeScripts(content);
    content.style.display = "block";

    this.updateLockIconState(true);
    this.renderRefresh();
  }

  updateLockIconState(isDecrypted) {
    const abbr = this.getCacheKey?.() || this.data?.abbrlink;
    if (!abbr) return;

    const lockIcon = document.getElementById(`lock-icon-${abbr}`);
    if (!lockIcon) return;

    if (isDecrypted) {
      lockIcon.classList.add("decrypted");
      lockIcon.classList.remove("fa-lock");
      lockIcon.classList.add("fa-unlock");
      lockIcon.style.cursor = "pointer";
      lockIcon.addEventListener(
        "click",
        () => {
          try {
            localStorage.removeItem(abbr);
          } catch (_) {}
          location.reload();
        },
        { once: true }
      );
    } else {
      lockIcon.classList.remove("decrypted");
      lockIcon.classList.remove("fa-unlock");
      lockIcon.classList.add("fa-lock");
      lockIcon.style.cursor = "";
    }
  }

  showStatus(msg, type = "info") {
    const el = document.getElementById("verification-status");
    if (!el) return;
    const icons = {
      info: "fa-info-circle",
      success: "fa-check-circle",
      error: "fa-times-circle",
    };
    el.style.display = "block";
    el.className = `verification-status ${type}`;
    el.innerHTML = `<i class="fa ${icons[type]}"></i> ${msg}`;
  }

  hideStatus() {
    const el = document.getElementById("verification-status");
    if (el) el.style.display = "none";
  }

  rebuildTOC() {
    try {
      const content = document.getElementById("decrypted-content");
      const tocWrap = document.querySelector(".post-toc-wrap");
      const sidebar = document.querySelector(".sidebar-inner");
      const utils = window.NexT?.utils;
      if (!content || !tocWrap) return;

      const headings = content.querySelectorAll("h1,h2,h3,h4,h5,h6");
      const ensureToc = () =>
        tocWrap.querySelector(".post-toc") ||
        (() => {
          const el = document.createElement("div");
          el.className = "post-toc animated";
          tocWrap.appendChild(el);
          return el;
        })();

      if (!headings.length) {
        const exist = tocWrap.querySelector(".post-toc");
        if (exist) exist.innerHTML = "";
        sidebar?.classList.remove("sidebar-nav-active", "sidebar-toc-active");
        sidebar?.classList.add("sidebar-overview-active");
        utils?.registerSidebarTOC?.();
        return;
      }

      const { roots } = Array.from(headings).reduce(
        (acc, h, i) => {
          if (!h.id) h.id = `heading-${i}`;
          const level = parseInt(h.tagName[1], 10);
          const node = {
            level,
            id: h.id,
            text: h.textContent.trim(),
            children: [],
          };
          while (acc.stack.length && acc.stack.at(-1).level >= level)
            acc.stack.pop();
          (acc.stack.length ? acc.stack.at(-1).children : acc.roots).push(node);
          acc.stack.push(node);
          return acc;
        },
        { roots: [], stack: [] }
      );

      const render = (nodes, depth = 1) =>
        nodes
          .map((n) => {
            const link = `<a class="nav-link" href="#${n.id}"><span class="nav-text">${n.text}</span></a>`;
            const kids = n.children.length
              ? `<ol class="nav-child">${render(n.children, depth + 1)}</ol>`
              : "";
            return `<li class="nav-item nav-level-${depth}">${link}${kids}</li>`;
          })
          .join("");

      const toc = ensureToc();
      toc.innerHTML = `<ol class="nav">${render(roots)}</ol>`;

      sidebar?.classList.add("sidebar-nav-active", "sidebar-toc-active");
      sidebar?.classList.remove("sidebar-overview-active");
      utils?.registerSidebarTOC?.();
    } catch (e) {
      console.error(`TOC 重建失败: ${e.message}`);
    }
  }

  triggerPageLoadedEvent() {
    document.dispatchEvent(
      new Event('page:loaded', {
        bubbles: true
      })
    );
  }

  renderRefresh() {
    this.rebuildTOC();
    NexT?.boot?.refresh?.();
    this.triggerPageLoadedEvent();
  }

  b64ToAB(b64) {
    const str = atob(b64);
    const bytes = new Uint8Array(str.length);
    for (let i = 0; i < str.length; i++) bytes[i] = str.charCodeAt(i);
    return bytes.buffer;
  }
}

const decryptor = new Decryptor();
document.addEventListener("DOMContentLoaded", () => {
  if (document.querySelector(".encrypted-post-container")) decryptor.init();
});