import {
  announce,
  apiJson,
  registerWorkspace,
  setActiveButton,
} from "../core.js";
import { setPreviewRefreshInterval } from "../scene-board.js";
import {
  ANIMATION_PREVIEW_DEFAULT_MAX_CONCURRENT,
  ANIMATION_PREVIEW_MAX_MAX_CONCURRENT,
  ANIMATION_PREVIEW_MIN_MAX_CONCURRENT,
  normalizeAnimationPreviewMaxConcurrent,
  setAnimationPreviewMaxConcurrent,
} from "../animation-thumbnail-preview.js";
import { refreshStatus } from "./device.js";
import { setControlBusy, setControlReady, setControlUnavailable } from "../interaction-feedback.js";
import { discardWifiSettingsDrafts, loadWifiSettings } from "./wifi-settings.js";
import { discardFrpDrafts, loadFrpSettings } from "./frp-settings.js";

const orientationButtons = Array.from(document.querySelectorAll("[data-orientation]"));
const matrixRefreshRateButtons = Array.from(
  document.querySelectorAll("[data-matrix-refresh-rate]"),
);
const brightness = document.getElementById("config-brightness");
const brightnessValue = document.getElementById("brightness-value");
const brightnessProtectionStatus = document.getElementById("brightness-protection-status");
const feedback = document.getElementById("settings-feedback");
const voltageCurrent = document.getElementById("voltage-current");
const voltageSensorStatus = document.getElementById("voltage-sensor-status");
const voltageCalibrationStatus = document.getElementById("voltage-calibration-status");
const voltageCalibratedAt = document.getElementById("voltage-calibrated-at");
const startCalibration = document.getElementById("start-voltage-calibration");
const resetCalibration = document.getElementById("reset-voltage-calibration");
const calibrationDialog = document.getElementById("voltage-calibration-dialog");
const calibrationReference = document.getElementById("voltage-reference-input");
const calibrationDialogFeedback = document.getElementById("voltage-calibration-dialog-feedback");
const calibrationPreview = document.getElementById("voltage-calibration-preview");
const previewCalibration = document.getElementById("preview-voltage-calibration");
const confirmCalibration = document.getElementById("confirm-voltage-calibration");
const previewRefreshInput = document.getElementById("preview-refresh-interval");
const previewRefreshWarning = document.getElementById("preview-refresh-warning");
const previewRefreshError = document.getElementById("preview-refresh-error");
const lowVoltageProtectionToggle = document.getElementById("low-voltage-protection-enabled");
const lowVoltageProtectionSwitchState = document.getElementById("low-voltage-protection-switch-state");
const lowVoltageProtectionFeedback = document.getElementById("low-voltage-protection-feedback");
const performanceModeToggle = document.getElementById("performance-mode-enabled");
const performanceModeSwitchState = document.getElementById("performance-mode-switch-state");
const performanceModeFeedback = document.getElementById("performance-mode-feedback");
const animationPreviewMaxConcurrentInput = document.getElementById("animation-preview-max-concurrent");
const animationPreviewConcurrencyFeedback = document.getElementById("animation-preview-concurrency-feedback");
const otaCurrentVersion = document.getElementById("ota-current-version");
const otaFeatureUpdatedAt = document.getElementById("ota-feature-updated-at");
const otaFileInput = document.getElementById("ota-file-input");
const otaSelectFile = document.getElementById("ota-select-file");
const otaProgressGroup = document.getElementById("ota-progress-group");
const otaProgressStage = document.getElementById("ota-progress-stage");
const otaProgressValue = document.getElementById("ota-progress-value");
const otaProgress = document.getElementById("ota-progress");
const otaFeedback = document.getElementById("ota-feedback");
const otaFailureLogActions = document.getElementById("ota-failure-log-actions");
const otaViewFailureLog = document.getElementById("ota-view-failure-log");
const otaCopyFailureLog = document.getElementById("ota-copy-failure-log");
const otaFailureLogDialog = document.getElementById("ota-failure-log-dialog");
const otaFailureLogContent = document.getElementById("ota-failure-log-content");
const otaFailureLogFeedback = document.getElementById("ota-failure-log-feedback");
const otaFailureLogClose = document.getElementById("ota-failure-log-close");
const otaFailureLogCopy = document.getElementById("ota-failure-log-copy");
let confirmedOrientation = 0;
let confirmedBrightness = 40;
let confirmedMatrixRefreshRate = 100;
let confirmedPreviewRefreshInterval = 1000;
let confirmedLowVoltageProtectionEnabled = false;
let confirmedPerformanceModeEnabled = false;
let confirmedAnimationPreviewMaxConcurrent = ANIMATION_PREVIEW_DEFAULT_MAX_CONCURRENT;
let voltageConfig = null;
let voltageStatus = null;
let lowVoltageProtectionStatus = null;
let latestEffectiveBrightness = null;
let displayTestActive = false;
let displayTestBrightness = null;
let calibrationProposal = null;
let desiredBrightness = null;
let applyingBrightness = false;
let orientationPending = false;
let matrixRefreshRatePending = false;
let previewRefreshPending = false;
let desiredPreviewRefreshInterval = null;
let savingPreviewRefreshInterval = null;
let lowVoltageProtectionPending = false;
let performanceModePending = false;
let animationPreviewConcurrencyPending = false;
let otaCurrentSoftwareVersion = null;
let otaPolling = false;
let otaFailureLogText = "";
let otaFailureDialogShownFor = null;

const LOW_VOLTAGE_PROTECTION_MODES = new Set([
  "disabled",
  "unavailable",
  "inactive",
  "limiting",
  "critical",
]);

function setFeedback(text, state = "idle") {
  feedback.textContent = text;
  feedback.dataset.state = state;
  feedback.hidden = !text;
}

function setOtaFeedback(text, state = "idle") {
  otaFeedback.textContent = text;
  otaFeedback.dataset.state = state;
  otaFeedback.hidden = !text;
}

function showOtaProgress(percent, stage) {
  const value = Math.max(0, Math.min(100, Number(percent) || 0));
  otaProgressGroup.hidden = false;
  otaProgress.value = value;
  otaProgress.textContent = `${value}%`;
  otaProgressValue.textContent = `${value}%`;
  otaProgressStage.textContent = stage || "正在更新";
}

function xhrUpload(file) {
  return new Promise((resolve, reject) => {
    const request = new XMLHttpRequest();
    request.open("POST", `/api/ota/update?filename=${encodeURIComponent(file.name)}`);
    request.setRequestHeader("Content-Type", "application/octet-stream");
    request.upload.addEventListener("progress", (event) => {
      if (!event.lengthComputable) return;
      showOtaProgress(Math.floor(event.loaded * 100 / event.total), "正在上传更新包");
    });
    request.addEventListener("load", () => {
      let body = {};
      try { body = request.responseText ? JSON.parse(request.responseText) : {}; } catch {}
      if (request.status >= 200 && request.status < 300) resolve(body);
      else reject(new Error(body.detail || `上传失败（HTTP ${request.status}）`));
    });
    request.addEventListener("error", () => reject(new Error("上传连接中断，设备尚未接受更新包")));
    request.addEventListener("abort", () => reject(new Error("上传已中止")));
    request.send(file);
  });
}

async function fetchOtaStatus() {
  const response = await fetch("/api/ota/status", { cache: "no-store" });
  if (!response.ok) throw new Error(`读取 OTA 状态失败（HTTP ${response.status}）`);
  return response.json();
}

async function fetchOtaFailureLog() {
  const response = await fetch("/api/ota/failure-log", { cache: "no-store" });
  if (!response.ok) throw new Error(`读取 OTA 失败日志失败（HTTP ${response.status}）`);
  return response.text();
}

function setOtaFailureLogFeedback(text, state = "idle") {
  otaFailureLogFeedback.textContent = text;
  otaFailureLogFeedback.dataset.state = state;
  otaFailureLogFeedback.hidden = !text;
}

async function ensureOtaFailureLog() {
  if (!otaFailureLogText) otaFailureLogText = await fetchOtaFailureLog();
  return otaFailureLogText;
}

async function showOtaFailureLog() {
  try {
    const text = await ensureOtaFailureLog();
    otaFailureLogContent.textContent = text;
    setOtaFailureLogFeedback("");
    if (!otaFailureLogDialog.open) otaFailureLogDialog.showModal();
    otaFailureLogContent.focus();
  } catch (error) {
    announce(error.message, "error");
  }
}

function fallbackCopyText(text) {
  const textarea = document.createElement("textarea");
  textarea.value = text;
  textarea.setAttribute("readonly", "");
  textarea.style.position = "fixed";
  textarea.style.opacity = "0";
  document.body.append(textarea);
  textarea.select();
  const copied = document.execCommand("copy");
  textarea.remove();
  if (!copied) throw new Error("浏览器拒绝复制操作");
}

async function copyOtaFailureLog() {
  try {
    const text = await ensureOtaFailureLog();
    let copied = false;
    if (navigator.clipboard?.writeText) {
      try {
        await navigator.clipboard.writeText(text);
        copied = true;
      } catch {}
    }
    if (!copied) fallbackCopyText(text);
    setOtaFailureLogFeedback("日志已复制到剪贴板。", "success");
    announce("OTA 失败日志已复制", "success");
  } catch (error) {
    setOtaFailureLogFeedback(`复制失败：${error.message}`, "error");
    announce(`复制 OTA 失败日志失败：${error.message}`, "error");
  }
}

function formatBeijingFeatureUpdatedAt(value) {
  const date = new Date(value);
  if (!value || Number.isNaN(date.getTime())) return "读取失败";
  const parts = Object.fromEntries(
    new Intl.DateTimeFormat("zh-CN", {
      timeZone: "Asia/Shanghai",
      year: "numeric",
      month: "2-digit",
      day: "2-digit",
      hour: "2-digit",
      minute: "2-digit",
      hourCycle: "h23",
    }).formatToParts(date).map(({ type, value: part }) => [type, part]),
  );
  return `${parts.year}-${parts.month}-${parts.day} ${parts.hour}:${parts.minute}（北京时间）`;
}

function applyOtaStatus(status) {
  const current = status?.current_version;
  if (current) {
    otaCurrentVersion.textContent = current;
    if (otaCurrentSoftwareVersion && current !== otaCurrentSoftwareVersion) {
      window.location.reload();
      return;
    }
    otaCurrentSoftwareVersion = current;
  }
  otaFeatureUpdatedAt.textContent = formatBeijingFeatureUpdatedAt(status?.feature_updated_at);
  const job = status?.job;
  if (status?.active && job) {
    otaFailureLogActions.hidden = true;
    otaFailureLogText = "";
    showOtaProgress(job.percent, job.message || job.phase);
    setControlBusy(otaSelectFile, { label: "正在更新…" });
    setOtaFeedback("更新已交给设备后台处理；网页短暂断开属于正常现象。", "pending");
  } else {
    setControlReady(otaSelectFile);
    if (job?.phase === "failed") {
      showOtaProgress(0, "更新失败");
      setOtaFeedback(job.error || "更新失败，设备已恢复原版本。", "error");
      otaFailureLogActions.hidden = !status.failure_log_available;
      const failureKey = `${job.id || "unknown"}:${job.finished_at || ""}`;
      if (status.failure_log_available && otaFailureDialogShownFor !== failureKey) {
        otaFailureDialogShownFor = failureKey;
        void showOtaFailureLog();
      }
    } else if (job?.phase === "complete") {
      otaFailureLogActions.hidden = true;
      otaFailureLogText = "";
      otaProgressGroup.hidden = true;
      setOtaFeedback("");
    }
    if (job?.phase !== "failed") {
      const recovery = status?.kernel_recovery;
      if (recovery?.state === "pending") {
        setOtaFeedback("应用更新完成；正在进行一次候选内核恢复重启…", "pending");
      } else if (recovery?.state === "succeeded") {
        setOtaFeedback("候选内核与 CPU 调频策略已恢复。", "ready");
      } else if (recovery?.state === "failed") {
        setOtaFeedback(`内核恢复失败：${recovery.reason || "请查看设备诊断"}`, "error");
      } else if (recovery?.state === "requires_package") {
        setOtaFeedback("应用已更新；内核材料缺失或损坏，需要专用修复包。", "error");
      } else if (recovery?.state === "ready") {
        setOtaFeedback("当前设备运行原内核，性能模式不可用；下次 OTA 将尝试轻量恢复。", "error");
      }
    }
  }
}

otaViewFailureLog.addEventListener("click", () => void showOtaFailureLog());
otaCopyFailureLog.addEventListener("click", () => void copyOtaFailureLog());
otaFailureLogCopy.addEventListener("click", () => void copyOtaFailureLog());
otaFailureLogClose.addEventListener("click", () => otaFailureLogDialog.close());

async function pollOtaUntilFinished() {
  if (otaPolling) return;
  otaPolling = true;
  let disconnected = false;
  try {
    while (true) {
      try {
        const status = await fetchOtaStatus();
        if (disconnected) setOtaFeedback("设备服务已恢复，正在确认更新结果…", "pending");
        applyOtaStatus(status);
        if (!status.active && status.kernel_recovery?.state !== "pending") return;
      } catch {
        disconnected = true;
        setOtaFeedback("设备正在切换软件版本，等待服务恢复…", "pending");
      }
      await new Promise((resolve) => window.setTimeout(resolve, 1000));
    }
  } finally {
    otaPolling = false;
  }
}

async function loadOtaStatus() {
  try {
    const status = await fetchOtaStatus();
    applyOtaStatus(status);
    if (status.active || status.kernel_recovery?.state === "pending") pollOtaUntilFinished();
  } catch (error) {
    otaCurrentVersion.textContent = "读取失败";
    otaFeatureUpdatedAt.textContent = "读取失败";
    setOtaFeedback(error.message, "error");
  }
}

otaSelectFile.addEventListener("click", () => otaFileInput.click());
otaFileInput.addEventListener("change", async () => {
  const file = otaFileInput.files?.[0];
  if (!file) return;
  setControlBusy(otaSelectFile, { label: "正在上传…", message: "开始上传完整 OTA 更新包" });
  setOtaFeedback("正在上传；上传完成并通过校验后将自动开始安装。", "pending");
  showOtaProgress(0, "正在上传更新包");
  try {
    await xhrUpload(file);
    setOtaFeedback("更新包已接受，安装将在设备后台继续。", "success");
    await pollOtaUntilFinished();
  } catch (error) {
    setControlReady(otaSelectFile);
    setOtaFeedback(error.message, "error");
  } finally {
    otaFileInput.value = "";
  }
});

function showOrientation(value) {
  setActiveButton(
    orientationButtons,
    orientationButtons.find((button) => Number(button.dataset.orientation) === Number(value)),
  );
}

function showBrightness(value) {
  brightness.value = String(value);
  brightnessValue.textContent = `${value}%`;
}

function showMatrixRefreshRate(value) {
  setActiveButton(
    matrixRefreshRateButtons,
    matrixRefreshRateButtons.find(
      (button) => Number(button.dataset.matrixRefreshRate) === Number(value),
    ),
  );
}

function finitePercent(value) {
  if (value === null || value === undefined || value === "") return null;
  const number = Number(value);
  if (!Number.isFinite(number)) return null;
  return Math.max(1, Math.min(100, Math.floor(number)));
}

function lowVoltageProtectionMode() {
  const mode = lowVoltageProtectionStatus?.mode;
  return LOW_VOLTAGE_PROTECTION_MODES.has(mode) ? mode : "unavailable";
}

function estimatedEffectiveBrightness(userBrightness) {
  const user = finitePercent(userBrightness);
  if (user === null) return null;
  const mode = lowVoltageProtectionMode();
  if (mode === "critical") return 35;
  if (mode === "limiting") {
    const limit = finitePercent(lowVoltageProtectionStatus?.brightness_limit_percent);
    return limit === null ? user : Math.min(user, limit);
  }
  return user;
}

function showBrightnessProtectionStatus(userBrightness, effectiveBrightness = undefined) {
  const mode = lowVoltageProtectionMode();
  brightnessProtectionStatus.dataset.mode = mode;
  if (mode !== "limiting" && mode !== "critical") {
    brightnessProtectionStatus.hidden = true;
    if (brightnessProtectionStatus.textContent) brightnessProtectionStatus.textContent = "";
    return;
  }

  const user = finitePercent(userBrightness) ?? confirmedBrightness;
  const reportedEffective = finitePercent(effectiveBrightness);
  const effective = reportedEffective ?? estimatedEffectiveBrightness(user);
  const staleSuffix = lowVoltageProtectionStatus?.reading_stale === true
    ? " 电压读数异常，正在保持上次保护。"
    : "";
  let text;
  if (mode === "critical") {
    text = `用户画面已禁用，低电图标固定以 35% 亮度显示。用户设置 ${user}% 会保留并在电压恢复后生效。${staleSuffix}`;
  } else {
    const limit = finitePercent(lowVoltageProtectionStatus?.brightness_limit_percent);
    const limitText = limit === null ? "-" : String(limit);
    const effectiveText = effective === null ? "-" : String(effective);
    text = `当前允许的最高亮度：${limitText}%。用户设置：${user}%；当前实际亮度：${effectiveText}%。${staleSuffix}`;
  }
  if (brightnessProtectionStatus.textContent !== text) {
    brightnessProtectionStatus.textContent = text;
  }
  brightnessProtectionStatus.hidden = false;
}

function showLowVoltageProtectionSwitch(enabled) {
  const checked = enabled === true;
  lowVoltageProtectionToggle.checked = checked;
  lowVoltageProtectionSwitchState.textContent = checked ? "开启" : "关闭";
}

function setLowVoltageProtectionFeedback(text, state = "idle") {
  lowVoltageProtectionFeedback.textContent = text;
  lowVoltageProtectionFeedback.dataset.state = state;
  lowVoltageProtectionFeedback.hidden = !text;
}

function syncLowVoltageProtectionEnabled(value) {
  if (typeof value !== "boolean") return false;
  confirmedLowVoltageProtectionEnabled = value;
  showLowVoltageProtectionSwitch(value);
  if (!lowVoltageProtectionPending) setControlReady(lowVoltageProtectionToggle);
  return true;
}

function showPerformanceModeSwitch(enabled) {
  const checked = enabled === true;
  performanceModeToggle.checked = checked;
  performanceModeSwitchState.textContent = checked ? "开启" : "关闭";
}

function setPerformanceModeFeedback(text, state = "idle") {
  performanceModeFeedback.textContent = text;
  performanceModeFeedback.dataset.state = state;
  performanceModeFeedback.hidden = !text;
}

function syncPerformanceModeStatus(status) {
  if (!status || typeof status !== "object") {
    setControlUnavailable(performanceModeToggle, "CPU 调频状态不可用，请稍后重试。");
    setPerformanceModeFeedback("CPU 调频状态不可用", "error");
    return;
  }
  if (!performanceModePending && typeof status.requested === "boolean") {
    confirmedPerformanceModeEnabled = status.requested === true && status.effective === true;
    showPerformanceModeSwitch(confirmedPerformanceModeEnabled);
  }
  if (performanceModePending) return;
  if (status.available === true) {
    setControlReady(performanceModeToggle);
    if (status.requested === true && status.effective !== true) {
      setPerformanceModeFeedback(
        `性能模式未实际生效${status.last_error ? `：${status.last_error}` : ""}`,
        "error",
      );
    } else {
      setPerformanceModeFeedback(
        status.effective === true ? "性能模式已开启并实际生效" : "性能模式已关闭",
        "ready",
      );
    }
    return;
  }
  const reason = status.last_error
    ? `CPU 调频策略不可用：${status.last_error}`
    : "CPU 调频策略不可用；系统修复完成前不能开启性能模式。";
  setControlUnavailable(performanceModeToggle, reason);
  setPerformanceModeFeedback(reason, "error");
}

function brightnessFeedbackText(stage, userBrightness) {
  const user = finitePercent(userBrightness) ?? confirmedBrightness;
  const mode = lowVoltageProtectionMode();
  if (displayTestActive && mode !== "critical") {
    const test = finitePercent(displayTestBrightness);
    const suffix = test === null ? "测试亮度" : `测试亮度 ${test}%`;
    return stage === "pending"
      ? `正在保存用户亮度 ${user}%；当前仍由${suffix}覆盖…`
      : `用户亮度 ${user}% 已保存，但当前由${suffix}覆盖`;
  }
  if (mode !== "limiting" && mode !== "critical") {
    return stage === "pending"
      ? `正在应用并保存用户亮度 ${user}%…`
      : `用户亮度 ${user}% 已生效并保存`;
  }
  const effective = estimatedEffectiveBrightness(user);
  return stage === "pending"
    ? `正在应用并保存用户亮度 ${user}%；当前实际亮度 ${effective}%…`
    : `用户亮度 ${user}% 已保存；当前实际亮度 ${effective}%`;
}

function showPreviewRefreshWarning(value) {
  previewRefreshWarning.hidden = !(Number.isInteger(value) && value < 100);
}

function showPreviewRefreshError(message = "") {
  previewRefreshError.textContent = message;
  previewRefreshError.hidden = !message;
}

function showPreviewRefreshInterval(value) {
  previewRefreshInput.value = String(value);
  showPreviewRefreshWarning(Number(value));
  showPreviewRefreshError();
}

function showAnimationPreviewMaxConcurrent(value) {
  animationPreviewMaxConcurrentInput.value = String(value);
}

function setAnimationPreviewConcurrencyFeedback(message = "", state = "idle") {
  animationPreviewConcurrencyFeedback.textContent = message;
  animationPreviewConcurrencyFeedback.dataset.state = state;
  animationPreviewConcurrencyFeedback.hidden = !message;
}

function voltageStatusText(status) {
  if (status === "ok") return "正常";
  if (status === "disconnected") return "传感器断开";
  if (status === "error") return "读取异常";
  return "正在读取";
}

function showVoltageDetails() {
  const status = voltageStatus?.status || "starting";
  voltageCurrent.textContent = status === "ok" && Number.isFinite(Number(voltageStatus.volts))
    ? `${Number(voltageStatus.volts).toFixed(2)} V`
    : "-";
  voltageSensorStatus.textContent = voltageStatusText(status);
  const calibratedAt = voltageConfig?.voltage_calibrated_at;
  voltageCalibrationStatus.textContent = calibratedAt ? "已校准" : "未校准（标称值）";
  voltageCalibratedAt.textContent = calibratedAt
    ? new Date(calibratedAt).toLocaleString("zh-CN")
    : "-";
  if (status === "ok") setControlReady(startCalibration);
  else if (status === "disconnected") setControlUnavailable(startCalibration, "电压传感器已断开，请连接传感器并等待状态恢复后再校准。");
  else if (status === "error") setControlUnavailable(startCalibration, "电压读取异常，请检查传感器和接线后再校准。");
  else setControlUnavailable(startCalibration, "正在读取电压传感器状态，请稍候。");
  if (resetCalibration.dataset.controlState !== "busy") {
    if (calibratedAt) setControlReady(resetCalibration);
    else setControlUnavailable(resetCalibration, "当前没有已保存的校准，无需恢复标称值。");
  }
}

function resetCalibrationDialog() {
  calibrationProposal = null;
  calibrationPreview.hidden = true;
  setControlUnavailable(confirmCalibration, "请先完成“采样并预览”，再保存校准。");
  setControlReady(previewCalibration);
  calibrationReference.disabled = false;
  calibrationDialogFeedback.textContent = "点击“采样并预览”，约需 1 秒。";
}

function showCalibrationProposal(proposal) {
  document.getElementById("calibration-reference-result").textContent = `${Number(proposal.reference_volts).toFixed(3)} V`;
  document.getElementById("calibration-raw-result").textContent = `${Number(proposal.uncalibrated_volts).toFixed(3)} V`;
  document.getElementById("calibration-current-factor").textContent = Number(proposal.current_factor).toFixed(6);
  document.getElementById("calibration-proposed-factor").textContent = Number(proposal.proposed_factor).toFixed(6);
  document.getElementById("calibration-projected-result").textContent = `${Number(proposal.projected_volts).toFixed(3)} V`;
  calibrationPreview.hidden = false;
}

async function loadSettings() {
  loadWifiSettings();
  loadFrpSettings();
  try {
    const config = await apiJson("/api/config");
    confirmedOrientation = Number(config.orientation);
    confirmedBrightness = Number(config.brightness);
    confirmedMatrixRefreshRate = Number(config.matrix_refresh_rate_limit_hz);
    confirmedPreviewRefreshInterval = Number(config.preview_refresh_interval_ms);
    confirmedPerformanceModeEnabled = config.performance_mode_enabled === true;
    confirmedAnimationPreviewMaxConcurrent = normalizeAnimationPreviewMaxConcurrent(
      config.animation_preview_max_concurrent,
    );
    setAnimationPreviewMaxConcurrent(confirmedAnimationPreviewMaxConcurrent);
    voltageConfig = config;
    syncLowVoltageProtectionEnabled(config.low_voltage_protection_enabled);
    showPerformanceModeSwitch(confirmedPerformanceModeEnabled);
    showAnimationPreviewMaxConcurrent(confirmedAnimationPreviewMaxConcurrent);
    setAnimationPreviewConcurrencyFeedback();
    showOrientation(confirmedOrientation);
    showBrightness(confirmedBrightness);
    showMatrixRefreshRate(confirmedMatrixRefreshRate);
    showBrightnessProtectionStatus(confirmedBrightness, latestEffectiveBrightness);
    showPreviewRefreshInterval(confirmedPreviewRefreshInterval);
    setPreviewRefreshInterval(confirmedPreviewRefreshInterval);
    showVoltageDetails();
    setFeedback("");
  } catch (error) {
    setFeedback(`设置读取失败：${error.message}`, "error");
    announce(`设置读取失败：${error.message}`, true);
  }
}

loadOtaStatus();

startCalibration.addEventListener("click", () => {
  resetCalibrationDialog();
  calibrationDialog.showModal();
  calibrationReference.focus();
  calibrationReference.select();
});

previewCalibration.addEventListener("click", async () => {
  const referenceVolts = Number(calibrationReference.value);
  if (!Number.isFinite(referenceVolts) || referenceVolts < 4.5 || referenceVolts > 5.5) {
    calibrationDialogFeedback.textContent = "请输入 4.500V 到 5.500V 之间的万用表读数。";
    return;
  }
  calibrationProposal = null;
  calibrationPreview.hidden = true;
  setControlUnavailable(confirmCalibration, "正在生成新的校准预览，请稍候。");
  setControlBusy(previewCalibration, { label: "正在采样…", message: "正在采集 15 个新样本…" });
  calibrationReference.disabled = true;
  calibrationDialogFeedback.textContent = "正在采集 15 个新样本，请保持供电和表笔稳定…";
  try {
    const proposal = await apiJson("/api/power/voltage/calibration/preview", {
      method: "POST",
      body: JSON.stringify({ reference_volts: referenceVolts }),
    });
    calibrationProposal = proposal;
    showCalibrationProposal(proposal);
    setControlReady(confirmCalibration);
    calibrationDialogFeedback.textContent = "请核对预览结果；确认后才会写入本机校准。";
  } catch (error) {
    calibrationDialogFeedback.textContent = `校准预览失败：${error.message}`;
    setControlUnavailable(confirmCalibration, "请先完成“采样并预览”，再保存校准。");
  } finally {
    setControlReady(previewCalibration);
    calibrationReference.disabled = false;
  }
});

confirmCalibration.addEventListener("click", async () => {
  if (!calibrationProposal) return;
  setControlBusy(confirmCalibration, { label: "正在保存…", message: "正在保存校准并重新采样…" });
  setControlBusy(previewCalibration);
  calibrationDialogFeedback.textContent = "正在保存并重新采样…";
  try {
    const result = await apiJson("/api/power/voltage/calibration/confirm", {
      method: "POST",
      body: JSON.stringify({ proposal_id: calibrationProposal.proposal_id }),
    });
    voltageConfig = result.config;
    voltageStatus = result.screen_input_voltage;
    syncLowVoltageProtectionEnabled(result.config?.low_voltage_protection_enabled);
    showVoltageDetails();
    calibrationDialog.close();
    setFeedback("电压传感器已完成本机校准", "success");
    announce("电压传感器校准已保存");
    await refreshStatus();
  } catch (error) {
    calibrationDialogFeedback.textContent = `保存校准失败：${error.message}`;
  } finally {
    setControlReady(confirmCalibration);
    setControlReady(previewCalibration);
  }
});

resetCalibration.addEventListener("click", async () => {
  const confirmed = window.confirm("确认恢复标称校准系数 1.0？更换 ADC 或测量接线后应执行此操作并重新校准。");
  if (!confirmed) return;
  setControlBusy(resetCalibration, { label: "正在恢复…", message: "正在恢复标称校准…" });
  setFeedback("正在恢复标称校准…", "pending");
  try {
    const result = await apiJson("/api/power/voltage/calibration/reset", {
      method: "POST",
      body: "{}",
    });
    voltageConfig = result.config;
    voltageStatus = result.screen_input_voltage;
    syncLowVoltageProtectionEnabled(result.config?.low_voltage_protection_enabled);
    showVoltageDetails();
    setFeedback("已恢复标称校准系数 1.0", "success");
    announce("电压传感器已恢复标称值");
    await refreshStatus();
  } catch (error) {
    setFeedback(`恢复标称值失败：${error.message}`, "error");
    announce(`恢复标称值失败：${error.message}`, true);
  } finally {
    setControlReady(resetCalibration);
    showVoltageDetails();
  }
});

lowVoltageProtectionToggle.addEventListener("change", async () => {
  if (lowVoltageProtectionPending) {
    showLowVoltageProtectionSwitch(confirmedLowVoltageProtectionEnabled);
    return;
  }

  const requested = lowVoltageProtectionToggle.checked === true;
  const previous = confirmedLowVoltageProtectionEnabled;
  lowVoltageProtectionPending = true;
  setControlBusy(lowVoltageProtectionToggle);
  lowVoltageProtectionSwitchState.textContent = requested ? "正在开启" : "正在关闭";
  setLowVoltageProtectionFeedback(
    requested ? "正在开启低电压亮度保护…" : "正在关闭低电压亮度保护…",
    "pending",
  );

  let saved = false;
  try {
    const config = await apiJson("/api/config", {
      method: "PUT",
      body: JSON.stringify({ low_voltage_protection_enabled: requested }),
    });
    if (typeof config.low_voltage_protection_enabled !== "boolean") {
      throw new Error("服务器返回了无效的保护开关状态");
    }
    voltageConfig = config;
    confirmedLowVoltageProtectionEnabled = config.low_voltage_protection_enabled;
    showLowVoltageProtectionSwitch(confirmedLowVoltageProtectionEnabled);
    setLowVoltageProtectionFeedback(
      confirmedLowVoltageProtectionEnabled
        ? "低电压亮度保护已开启"
        : "低电压亮度保护已关闭",
      "success",
    );
    announce(confirmedLowVoltageProtectionEnabled
      ? "低电压亮度保护已开启"
      : "低电压亮度保护已关闭");
    saved = true;
  } catch (error) {
    confirmedLowVoltageProtectionEnabled = previous;
    showLowVoltageProtectionSwitch(previous);
    setLowVoltageProtectionFeedback(`低电压亮度保护保存失败：${error.message}`, "error");
    announce(`低电压亮度保护保存失败：${error.message}`, true);
  } finally {
    lowVoltageProtectionPending = false;
    setControlReady(lowVoltageProtectionToggle);
  }

  if (saved) {
    try {
      await refreshStatus();
    } catch (error) {
      setLowVoltageProtectionFeedback(
        `保护开关已保存，但状态刷新失败：${error.message}`,
        "error",
      );
    }
  }
});

performanceModeToggle.addEventListener("change", async () => {
  if (performanceModePending) {
    showPerformanceModeSwitch(confirmedPerformanceModeEnabled);
    return;
  }
  const requested = performanceModeToggle.checked === true;
  const previous = confirmedPerformanceModeEnabled;
  performanceModePending = true;
  setControlBusy(performanceModeToggle);
  performanceModeSwitchState.textContent = requested ? "正在开启" : "正在关闭";
  setPerformanceModeFeedback(
    requested ? "正在应用 performance governor…" : "正在恢复原 CPU governor…",
    "pending",
  );
  try {
    const config = await apiJson("/api/config", {
      method: "PUT",
      body: JSON.stringify({ performance_mode_enabled: requested }),
    });
    if (typeof config.performance_mode_enabled !== "boolean") {
      throw new Error("服务器返回了无效的性能模式状态");
    }
    confirmedPerformanceModeEnabled = config.performance_mode_enabled;
    showPerformanceModeSwitch(confirmedPerformanceModeEnabled);
    setPerformanceModeFeedback(
      confirmedPerformanceModeEnabled ? "性能模式已开启" : "性能模式已关闭并恢复原 governor",
      "success",
    );
    announce(confirmedPerformanceModeEnabled ? "性能模式已开启" : "性能模式已关闭");
  } catch (error) {
    confirmedPerformanceModeEnabled = previous;
    showPerformanceModeSwitch(previous);
    setPerformanceModeFeedback(`性能模式切换失败：${error.message}`, "error");
    announce(`性能模式切换失败：${error.message}`, true);
  } finally {
    performanceModePending = false;
    setControlReady(performanceModeToggle);
  }
  try {
    await refreshStatus();
  } catch (error) {
    setPerformanceModeFeedback(`性能模式状态刷新失败：${error.message}`, "error");
  }
});

async function saveAnimationPreviewMaxConcurrent(requested) {
  if (animationPreviewConcurrencyPending) return;
  const previous = confirmedAnimationPreviewMaxConcurrent;
  animationPreviewConcurrencyPending = true;
  setControlBusy(animationPreviewMaxConcurrentInput);
  setAnimationPreviewConcurrencyFeedback(`正在保存同时播放数量 ${requested}…`, "pending");
  try {
    const config = await apiJson("/api/config", {
      method: "PUT",
      body: JSON.stringify({ animation_preview_max_concurrent: requested }),
    });
    const saved = normalizeAnimationPreviewMaxConcurrent(
      config.animation_preview_max_concurrent,
    );
    confirmedAnimationPreviewMaxConcurrent = saved;
    setAnimationPreviewMaxConcurrent(saved);
    showAnimationPreviewMaxConcurrent(saved);
    setAnimationPreviewConcurrencyFeedback(`同时播放数量 ${saved} 已保存`, "success");
    announce(`模板界面同时播放的动图数量已设置为 ${saved}`);
  } catch (error) {
    confirmedAnimationPreviewMaxConcurrent = previous;
    setAnimationPreviewMaxConcurrent(previous);
    showAnimationPreviewMaxConcurrent(previous);
    setAnimationPreviewConcurrencyFeedback(`同时播放数量保存失败：${error.message}`, "error");
    announce(`同时播放数量保存失败：${error.message}`, true);
  } finally {
    animationPreviewConcurrencyPending = false;
    setControlReady(animationPreviewMaxConcurrentInput);
  }
}

function commitAnimationPreviewMaxConcurrent() {
  if (animationPreviewConcurrencyPending) return;
  const raw = animationPreviewMaxConcurrentInput.value.trim();
  const requested = Number(raw);
  try {
    if (raw === "" || !/^\d+$/.test(raw)) throw new Error();
    normalizeAnimationPreviewMaxConcurrent(requested);
  } catch {
    showAnimationPreviewMaxConcurrent(confirmedAnimationPreviewMaxConcurrent);
    setAnimationPreviewConcurrencyFeedback(
      `请输入 ${ANIMATION_PREVIEW_MIN_MAX_CONCURRENT} 到 ${ANIMATION_PREVIEW_MAX_MAX_CONCURRENT} 之间的整数。`,
      "error",
    );
    return;
  }
  if (requested === confirmedAnimationPreviewMaxConcurrent) {
    setAnimationPreviewConcurrencyFeedback();
    return;
  }
  void saveAnimationPreviewMaxConcurrent(requested);
}

animationPreviewMaxConcurrentInput.addEventListener("input", () => {
  setAnimationPreviewConcurrencyFeedback();
});
animationPreviewMaxConcurrentInput.addEventListener("change", commitAnimationPreviewMaxConcurrent);
animationPreviewMaxConcurrentInput.addEventListener("blur", commitAnimationPreviewMaxConcurrent);
animationPreviewMaxConcurrentInput.addEventListener("keydown", (event) => {
  if (event.key !== "Enter") return;
  event.preventDefault();
  animationPreviewMaxConcurrentInput.blur();
});

orientationButtons.forEach((button) => {
  button.addEventListener("click", async () => {
    if (orientationPending) return;
    const requested = Number(button.dataset.orientation);
    if (requested === confirmedOrientation) return;
    orientationPending = true;
    orientationButtons.forEach((item) => setControlBusy(item));
    showOrientation(requested);
    setFeedback("正在应用屏幕方向…", "pending");
    try {
      const config = await apiJson("/api/config", {
        method: "PUT",
        body: JSON.stringify({ orientation: requested }),
      });
      confirmedOrientation = Number(config.orientation);
      showOrientation(confirmedOrientation);
      setFeedback(`方向 ${confirmedOrientation}° 已生效并保存`, "success");
      announce(`屏幕方向已切换为 ${confirmedOrientation}°`);
      await refreshStatus();
    } catch (error) {
      showOrientation(confirmedOrientation);
      setFeedback(`方向应用失败：${error.message}`, "error");
      announce(`方向应用失败：${error.message}`, true);
    } finally {
      orientationPending = false;
      orientationButtons.forEach((item) => setControlReady(item));
    }
  });
});

matrixRefreshRateButtons.forEach((button) => {
  button.addEventListener("click", async () => {
    if (matrixRefreshRatePending) return;
    const requested = Number(button.dataset.matrixRefreshRate);
    if (requested === confirmedMatrixRefreshRate) return;

    const previous = confirmedMatrixRefreshRate;
    matrixRefreshRatePending = true;
    matrixRefreshRateButtons.forEach((item) => setControlBusy(item));
    showMatrixRefreshRate(requested);
    setFeedback(`正在应用 ${requested}Hz 扫描上限…`, "pending");
    try {
      const config = await apiJson("/api/config", {
        method: "PUT",
        body: JSON.stringify({ matrix_refresh_rate_limit_hz: requested }),
      });
      const applied = Number(config.matrix_refresh_rate_limit_hz);
      if (!matrixRefreshRateButtons.some(
        (item) => Number(item.dataset.matrixRefreshRate) === applied
      )) {
        throw new Error("服务器返回了无效的扫描刷新率挡位");
      }
      confirmedMatrixRefreshRate = applied;
      showMatrixRefreshRate(confirmedMatrixRefreshRate);
      setFeedback(`${confirmedMatrixRefreshRate}Hz 上限已生效并保存`, "success");
      announce(`屏幕扫描刷新率上限已切换为 ${confirmedMatrixRefreshRate}Hz`);
      await refreshStatus();
    } catch (error) {
      confirmedMatrixRefreshRate = previous;
      showMatrixRefreshRate(previous);
      setFeedback(`扫描刷新率应用失败：${error.message}`, "error");
      announce(`扫描刷新率应用失败：${error.message}`, true);
    } finally {
      matrixRefreshRatePending = false;
      matrixRefreshRateButtons.forEach((item) => setControlReady(item));
    }
  });
});

async function processBrightnessQueue() {
  if (applyingBrightness) return;
  applyingBrightness = true;
  while (desiredBrightness !== null) {
    const requested = desiredBrightness;
    desiredBrightness = null;
    setFeedback(brightnessFeedbackText("pending", requested), "pending");
    try {
      const config = await apiJson("/api/config", {
        method: "PUT",
        body: JSON.stringify({ brightness: requested }),
      });
      confirmedBrightness = Number(config.brightness);
      latestEffectiveBrightness = null;
      showBrightnessProtectionStatus(confirmedBrightness);
      setFeedback(brightnessFeedbackText("success", confirmedBrightness), "success");
    } catch (error) {
      if (desiredBrightness === null) {
        showBrightness(confirmedBrightness);
        showBrightnessProtectionStatus(confirmedBrightness, latestEffectiveBrightness);
      }
      setFeedback(`亮度应用失败：${error.message}`, "error");
      announce(`亮度应用失败：${error.message}`, true);
    }
  }
  applyingBrightness = false;
  await refreshStatus().catch(() => {});
}

function queueBrightness(value) {
  desiredBrightness = Math.max(1, Math.min(100, Number(value)));
  processBrightnessQueue();
}

brightness.addEventListener("input", () => {
  brightnessValue.textContent = `${brightness.value}%`;
  showBrightnessProtectionStatus(brightness.value);
  setFeedback(brightnessFeedbackText("pending", brightness.value), "pending");
  queueBrightness(brightness.value);
});
brightness.addEventListener("change", () => {
  queueBrightness(brightness.value);
});

async function processPreviewRefreshQueue() {
  if (previewRefreshPending) return;
  previewRefreshPending = true;
  while (desiredPreviewRefreshInterval !== null) {
    const requested = desiredPreviewRefreshInterval;
    desiredPreviewRefreshInterval = null;
    savingPreviewRefreshInterval = requested;
    setFeedback(`正在保存预览刷新间隔 ${requested}ms…`, "pending");
    try {
      const config = await apiJson("/api/config", {
        method: "PUT",
        body: JSON.stringify({ preview_refresh_interval_ms: requested }),
      });
      confirmedPreviewRefreshInterval = Number(config.preview_refresh_interval_ms);
      showPreviewRefreshInterval(confirmedPreviewRefreshInterval);
      setPreviewRefreshInterval(confirmedPreviewRefreshInterval);
      setFeedback(`预览刷新间隔 ${confirmedPreviewRefreshInterval}ms 已保存`, "success");
    } catch (error) {
      if (desiredPreviewRefreshInterval === null) {
        showPreviewRefreshInterval(confirmedPreviewRefreshInterval);
      }
      setFeedback(`预览刷新间隔保存失败：${error.message}`, "error");
      announce(`预览刷新间隔保存失败：${error.message}`, true);
    } finally {
      savingPreviewRefreshInterval = null;
    }
  }
  previewRefreshPending = false;
  await refreshStatus().catch(() => {});
}

function commitPreviewRefreshInterval() {
  const value = previewRefreshInput.value.trim();
  const requested = Number(value);
  if (
    value === ""
    || !/^\d+$/.test(value)
    || !Number.isInteger(requested)
    || requested < 1
    || requested > 60000
  ) {
    previewRefreshInput.value = String(confirmedPreviewRefreshInterval);
    showPreviewRefreshWarning(confirmedPreviewRefreshInterval);
    showPreviewRefreshError("请输入 1 到 60000 之间的整数。");
    return;
  }
  showPreviewRefreshError();
  showPreviewRefreshWarning(requested);
  if (
    requested === savingPreviewRefreshInterval
    || requested === desiredPreviewRefreshInterval
  ) return;
  if (requested === confirmedPreviewRefreshInterval && !previewRefreshPending) return;
  desiredPreviewRefreshInterval = requested;
  void processPreviewRefreshQueue();
}

previewRefreshInput.addEventListener("input", () => {
  showPreviewRefreshWarning(null);
  showPreviewRefreshError();
});
previewRefreshInput.addEventListener("change", commitPreviewRefreshInterval);
previewRefreshInput.addEventListener("blur", commitPreviewRefreshInterval);
previewRefreshInput.addEventListener("keydown", (event) => {
  if (event.key !== "Enter") return;
  event.preventDefault();
  previewRefreshInput.blur();
});

document.addEventListener("matrix:status", (event) => {
  const detail = event.detail || {};
  syncPerformanceModeStatus(detail.system?.performance_mode);
  const statusMatrixRefreshRate = Number(
    detail.screen?.driver_options?.limit_refresh_rate_hz,
  );
  if (
    Number.isInteger(statusMatrixRefreshRate)
    && !matrixRefreshRatePending
    && matrixRefreshRateButtons.some(
      (button) => Number(button.dataset.matrixRefreshRate) === statusMatrixRefreshRate,
    )
  ) {
    confirmedMatrixRefreshRate = statusMatrixRefreshRate;
    showMatrixRefreshRate(confirmedMatrixRefreshRate);
  }
  const statusPreviewInterval = Number(detail.ui?.preview_refresh_interval_ms);
  if (
    Number.isInteger(statusPreviewInterval)
    && !previewRefreshPending
    && desiredPreviewRefreshInterval === null
    && document.activeElement !== previewRefreshInput
  ) {
    confirmedPreviewRefreshInterval = statusPreviewInterval;
    showPreviewRefreshInterval(confirmedPreviewRefreshInterval);
    setPreviewRefreshInterval(confirmedPreviewRefreshInterval);
  }

  const state = detail.state;
  displayTestActive = state?.display_test?.active === true;
  displayTestBrightness = displayTestActive
    ? finitePercent(state?.display_test?.brightness)
    : null;
  voltageStatus = detail.power?.screen_input_voltage || null;
  lowVoltageProtectionStatus = detail.power?.low_voltage_protection || null;
  latestEffectiveBrightness = finitePercent(state?.effective_brightness);
  showVoltageDetails();

  if (!lowVoltageProtectionPending && typeof lowVoltageProtectionStatus?.enabled === "boolean") {
    const protectionChanged = lowVoltageProtectionStatus.enabled
      !== confirmedLowVoltageProtectionEnabled;
    syncLowVoltageProtectionEnabled(lowVoltageProtectionStatus.enabled);
    if (protectionChanged && voltageConfig !== null) {
      setLowVoltageProtectionFeedback(
        confirmedLowVoltageProtectionEnabled
          ? "保护开关已从其他页面同步为开启"
          : "保护开关已从其他页面同步为关闭",
        "ready",
      );
    }
  }
  showBrightnessProtectionStatus(state?.brightness ?? confirmedBrightness, latestEffectiveBrightness);

  if (orientationPending || applyingBrightness || desiredBrightness !== null) return;
  if (!state) return;
  const nextOrientation = Number(state.orientation);
  const nextBrightness = Number(state.brightness);
  const changed = nextOrientation !== confirmedOrientation || nextBrightness !== confirmedBrightness;
  confirmedOrientation = nextOrientation;
  confirmedBrightness = nextBrightness;
  showOrientation(confirmedOrientation);
  showBrightness(confirmedBrightness);
  showBrightnessProtectionStatus(confirmedBrightness, latestEffectiveBrightness);
  if (changed && detail.externalChange) {
    setFeedback("方向或亮度已由其他控制页面更新", "ready");
  }
});

registerWorkspace({
  id: "settings",
  title: "系统设置",
  elementId: "workspace-settings",
  order: 20,
  persistence: "server",
  onEnter: loadSettings,
  onLeave: () => {
    discardWifiSettingsDrafts();
    discardFrpDrafts();
  },
});