// let lastProgress = 0;

// socket.on("download_progress", function (message) {
//   const version = localStorage.getItem("downloading_version");
//   // 监听进度更新事件
//   const progress = parseFloat(message.data);
//   if (document.getElementById("popup-modal").style.display === "none") {
//     showPopup(`正在下载并安装 ${version}，当前进度：${progress}%`, {
//       confirm: false,
//       cancel: false,
//     });
//   } else {
//     if (progress > lastProgress) {
//       lastProgress = progress; // 只允许进度递增
//       updatePopupMessage(
//         `正在下载并安装 ${version}，当前进度：${progress}%`,
//         false,
//         false
//       );
//     }
//   }
// });

let lastProgress = 0;

function setupSocketListeners() {
  socket.on("download_progress", async function (message) {
    // const version = localStorage.getItem("downloading_version") || "未知版本";
    let version;
    if (localStorage.getItem("downloading_version")) {
      version = localStorage.getItem("downloading_version");
    } else {
      version = await getPopupText("unknownVersionText");
    }
    const progress = parseFloat(message.progress);
    const speed = parseFloat(message.speed);
    if (progress < 100) {
      let downloadingText = await getPopupText("downloadingText");
      let downloadProgressText = await getPopupText("downloadProgressText");
      let downloadSpeedText = await getPopupText("downloadSpeedText");
      if (document.getElementById("popup-modal").style.display === "none") {
        showPopup(
          `${downloadingText} ${version}，${downloadProgressText}：${progress}%，${downloadSpeedText}：${speed}KB/s`,
          {
            confirm: false,
            cancel: false,
          }
        );
      } else {
        if (progress > lastProgress) {
          lastProgress = progress; // 只允许进度递增
          updatePopupMessage(
            `${downloadingText} ${version}，${downloadProgressText}：${progress}%，${downloadSpeedText}：${speed}KB/s`,
            false,
            false
          );
        }
      }
    } else if (progress >= 100) {
      if (document.getElementById("popup-modal").style.display === "none") {
        let installingText = await getPopupText("installingText");
        showPopup(
          installingText,
          {
            confirm: false,
            cancel: false,
          }
        );
      } else {
        if (progress > lastProgress) {
          lastProgress = progress; // 只允许进度递增
          updatePopupMessage(
            installingText,
            false,
            false
          );
        }
      }
    }
  });
}

function getAwaken() {
  fetch("/get_awaken")
    .then((response) => response.json())
    .then((data) => {
      const awakenTxt = document.getElementById("awaken-txt");
      awakenTxt.innerText = data.awaken;
      const awakenSelector = document.getElementById("awaken-selector");
      awakenSelector.value = data.awaken;
    })
    .catch((error) => console.error("Error getting awaken:", error));
}

let currentVersion = "default";

const pwdModal = document.getElementById("pwd-modal");
const pwdInput = document.getElementById("pwd-input");

let pwdResolve;

function showPwdModal() {
  pwdModal.style.display = "flex";
  pwdInput.value = "";
  pwdInput.focus();

  // 返回Promise，等待用户选择
  return new Promise((resolve) => {
    pwdResolve = resolve; // 保存 resolve 函数
  });
}

// 绑定 keydown 事件
pwdInput.addEventListener('keydown', function (event) {
  // 检查按下的键是否是 Enter 键
  if (event.key === 'Enter' || event.keyCode === 13) {
    // 回车键按下时的逻辑
    pwdConfirm()
  }
});

function pwdConfirm() {
  pwdModal.style.display = "none";
  pwdResolve(true);
}

function pwdCancel() {
  pwdModal.style.display = "none";
  pwdResolve(false);
}


document.addEventListener("DOMContentLoaded", function () {
  // 加载当前版本
  fetchCurrentVersion();
  // 加载已下载的版本
  fetchDownloadedVersions();
  // 加载可更新的版本
  fetchRemoteVersions();

  // 加载当前版本
  fetchVortXDBCurrentVersion();
  // 加载已下载的版本
  fetchVortXDBDownloadedVersions();
  // 加载可更新的版本
  fetchVortXDBRemoteVersions();

  // checkDownloadStatus();
  setupSocketListeners();
  getAwaken();


  fetch('/get_serial_number')
    .then(response => response.json())  // 假设返回的是 JSON 格式的数据
    .then(data => {
      // 假设接口返回的 JSON 数据中包含序列号字段，例如 data.serial_number
      const serialNumber = data.serial_number;

      // 将获取到的序列号插入到页面的 #serial-number 元素中
      document.getElementById('serial-number').textContent = serialNumber;
    })
    .catch(async error => {
      console.error('获取序列号失败:', error);
      // 处理错误，比如可以设置一个默认值或提示用户
      let getSnFailedText = await getPopupText("getSnFailedText");
      document.getElementById('serial-number').textContent = getSnFailedText;
    });


  // 监听已下载版本选择的变化
  document
    .getElementById("downloaded-versions")
    .addEventListener("change", async function () {
      const selectedVersion = this.value;

      // 如果选择的版本和当前版本相同，直接返回，不做任何操作
      if (selectedVersion === currentVersion) {
        let useIngText = await getPopupText("useIngText");
        let notNeedChangeText = await getPopupText("notNeedChangeText");
        showPopup(`${useIngText} ${selectedVersion}${notNeedChangeText}`, {
          confirm: true,
          cancel: false,
        });
        let selectDownloadText = await getPopupText("selectDownloadText");
        this.value = selectDownloadText;
        return;
      }

      if (selectedVersion) {
        const dropdown = this; // 保存当前选择框
        let askChangeVersionText = await getPopupText("askChangeVersionText");
        showPopup(`${askChangeVersionText} ${selectedVersion} ?`).then(async (confirmed) => {
          if (confirmed) {
            switchVersion(selectedVersion);
            let changeVersionText = await getPopupText("changeVersionText");
            let changeVersionWaitText = await getPopupText("changeVersionWaitText");
            showPopup(`${changeVersionText} ${selectedVersion}${changeVersionWaitText}`, {
              confirm: false,
              cancel: false,
            });
          } else {
            dropdown.value = currentVersion; // 用户取消时，还原选择框为当前版本
          }
        });
      }
    });

  // 监听可更新版本选择的变化
  document
    .getElementById("remote-versions")
    .addEventListener("change", async function () {
      const selectedVersion = this.value;
      if (selectedVersion) {
        const dropdown = this; // 保存当前选择框
        let askSureVersionText = await getPopupText("askSureVersionText");

        showPopup(`${askSureVersionText} ${selectedVersion} ?`).then(
          async (confirmed) => {
            if (confirmed) {
              let downloadingText = await getPopupText("downloadingText");
              let downloadSpeedText = await getPopupText("downloadSpeedText");
              showPopup(`${downloadingText} ${selectedVersion}${downloadSpeedText}`, {
                confirm: false,
                cancel: false,
              });
              downloadAndInstallVersion(selectedVersion);
            } else {
              let selectUpdateText = await getPopupText("selectUpdateText");
              dropdown.value = selectUpdateText; // 用户取消时，还原选择框为空
            }
          }
        );
      }
    });

  // 监听已下载版本选择的变化
  document
    .getElementById("downloaded-vtx-versions")
    .addEventListener("change", async function () {
      const selectedVersion = this.value;

      // 如果选择的版本和当前版本相同，直接返回，不做任何操作
      if (selectedVersion === currentVersion) {

        let useIngText = await getPopupText("useIngText");
        let notNeedChangeText = await getPopupText("notNeedChangeText");

        showPopup(`${useIngText} ${selectedVersion}${notNeedChangeText}`, {
          confirm: true,
          cancel: false,
        });
        let selectDownloadText = await getPopupText("selectDownloadText");
        this.value = selectDownloadText;
        return;
      }

      if (selectedVersion) {
        const dropdown = this; // 保存当前选择框
        let askChangeVersionText = await getPopupText("askChangeVersionText");
        showPopup(`${askChangeVersionText} ${selectedVersion} ?`).then(async (confirmed) => {
          if (confirmed) {
            switchVortXDBVersion(selectedVersion);
            let changeVersionText = await getPopupText("changeVersionText");
            let changeVersionWaitText = await getPopupText("changeVersionWaitText");
            showPopup(`${changeVersionText} ${selectedVersion}${changeVersionWaitText}`, {
              confirm: false,
              cancel: false,
            });
          } else {
            dropdown.value = currentVersion; // 用户取消时，还原选择框为当前版本
          }
        });
      }
    });

  // 监听可更新版本选择的变化
  document
    .getElementById("remote-vtx-versions")
    .addEventListener("change", async function () {
      const selectedVersion = this.value;

      if (selectedVersion) {
        const dropdown = this; // 保存当前选择框
        let askSureVersionText = await getPopupText("askSureVersionText");

        showPopup(`${askSureVersionText} ${selectedVersion} ?`).then(
          async (confirmed) => {
            if (confirmed) {
              let downloadingText = await getPopupText("downloadingText");
              let downloadSpeedText = await getPopupText("downloadSpeedText");
              showPopup(`${downloadingText} ${selectedVersion}${downloadSpeedText}`, {
                confirm: false,
                cancel: false,
              });
              downloadAndInstallVortXDBVersion(selectedVersion);
            } else {
              let selectUpdateText = await getPopupText("selectUpdateText");
              dropdown.value = selectUpdateText; // 用户取消时，还原选择框为空
            }
          }
        );
      }
    });

  document
    .getElementById("awaken-selector")
    .addEventListener("change", async function (e) {
      const oldAwaken = document.getElementById("awaken-txt").innerText;

      const selectedAwaken = this.value;
      if (selectedAwaken) {
        const dropdown = this; // 保存当前选择框

        let askChangeAwakenText = await getPopupText("askChangeAwakenText");
        showPopup(`${askChangeAwakenText} ${selectedAwaken} ?`).then(
          async (confirmed) => {
            if (confirmed) {
              let changeAwakenText = await getPopupText("changeAwakenText");
              showPopup(changeAwakenText, {
                confirm: false,
                cancel: false,
              });
              socket.emit("change_awaken", `change_awaken:${selectedAwaken}`);
              document.getElementById("awaken-txt").innerText = selectedAwaken;

              setTimeout(async () => {
                let newAwakenText = await getPopupText("newAwakenText");
                showPopup(
                  `${newAwakenText}“${selectedAwaken}”。`,
                  {
                    confirm: true,
                  }
                );
              }, 5000);
            } else {
              dropdown.value = oldAwaken; // 用户取消时，还原选择框为空
            }
          }
        );
      }
    });

  // 机器人演示功能
  const robotDemoBtn = document.getElementById("robot-demo-btn");
  if (robotDemoBtn) {
    robotDemoBtn.addEventListener("click", async function () {
      // 如果按钮已经禁用，不执行任何操作
      if (robotDemoBtn.disabled) {
        return;
      }
      let beginVisitText = await getPopupText("beginVisitText");
      if (robotDemoBtn.textContent === beginVisitText) {
        let headerText = await getPopupText("headerText");
        let notSupportText = await getPopupText("notSupportText");
        let notSupportToggleText = await getPopupText("notSupportToggleText");
        let beginWaitText = await getPopupText("beginWaitText");
        showPopup(`${headerText}！<br>${notSupportText}！<br>${beginWaitText}<br>${notSupportToggleText}`).then(
          async (confirmed) => {
            if (confirmed) {
              // 立即改变按钮状态
              let initializationText = await getPopupText("initializationText");
              robotDemoBtn.textContent = initializationText;
              robotDemoBtn.disabled = true;
              robotDemoBtn.style.opacity = "0.6";
              robotDemoBtn.style.cursor = "not-allowed";

              // 发送开始演示请求
              fetch("/start_robot_demo", {
                method: "POST",
              })
                .then(response => response.json())
                .then(async data => {
                  if (data.status === "success") {
                    let stopVisitText = await getPopupText("stopVisitText");
                    robotDemoBtn.textContent = stopVisitText;
                  } else {
                    let RobotStartFailText = await getPopupText("RobotStartFailText");
                    showPopup(RobotStartFailText + data.message);
                    robotDemoBtn.textContent = beginVisitText;
                  }
                  // 恢复按钮可点击状态
                  robotDemoBtn.disabled = false;
                  robotDemoBtn.style.opacity = "";
                  robotDemoBtn.style.cursor = "";
                })
                .catch(async error => {
                  let requestFail = await getPopupText("requestFail");
                  showPopup(requestFail + error);
                  // 发生错误时也恢复按钮状态
                  robotDemoBtn.textContent = beginVisitText;
                  robotDemoBtn.disabled = false;
                  robotDemoBtn.style.opacity = "";
                  robotDemoBtn.style.cursor = "";
                });
            }
          }
        );
      } else {
        // 立即改变按钮状态
        let stopIngText = await getPopupText("stopIngText");
        robotDemoBtn.textContent = stopIngText;
        robotDemoBtn.disabled = true;
        robotDemoBtn.style.opacity = "0.6";
        robotDemoBtn.style.cursor = "not-allowed";

        // 发送停止演示请求
        fetch("/stop_robot_demo", {
          method: "POST",
        })
          .then(response => response.json())
          .then(async data => {
            if (data.status === "success") {
              let beginVisitText = await getPopupText("beginVisitText");
              robotDemoBtn.textContent = beginVisitText;
            } else {
              let RobotStopFailText = await getPopupText("RobotStopFailText");
              let stopVisitText = await getPopupText("stopVisitText");
              showPopup(RobotStopFailText + data.message);
              robotDemoBtn.textContent = stopVisitText;
            }
            // 恢复按钮可点击状态
            robotDemoBtn.disabled = false;
            robotDemoBtn.style.opacity = "";
            robotDemoBtn.style.cursor = "";
          })
          .catch(async error => {
            let requestFail = await getPopupText("requestFail");
            showPopup(requestFail + error);
            // 发生错误时也恢复按钮状态

            let stopVisitText = await getPopupText("stopVisitText");
            robotDemoBtn.textContent = stopVisitText;
            robotDemoBtn.disabled = false;
            robotDemoBtn.style.opacity = "";
            robotDemoBtn.style.cursor = "";
          });
      }
    });
  }
});

async function fetchCurrentVersion() {
  let currentVersion = document.getElementById("current-version");
  let loadingText = await getPopupText("loadingText");
  currentVersion.textContent = loadingText;
  fetch("/get_current_version")
    .then((response) => response.json())
    .then((data) => {
      currentVersion.textContent =
        data.current_version;
      currentVersion = data.current_version;
    })
    .catch((error) => console.error("Error fetching current version:", error));
}

function fetchDownloadedVersions() {
  fetch("/get_versions")
    .then((response) => response.json())
    .then((data) => {
      const select = document.getElementById("downloaded-versions");
      select.innerHTML =
        '<option value="" i18n="setting.change_select_version" id="change_select_version"></option>'; // 添加默认选项
      data.versions.forEach((version) => {
        const option = document.createElement("option");
        option.value = version;
        option.textContent = version;
        select.appendChild(option);
      });

      translateElement("#change_select_version", lang);
    })
    .catch((error) =>
      console.error("Error fetching downloaded versions:", error)
    );
}

function fetchRemoteVersions() {
  fetch("/get_remote_versions")
    .then((response) => response.json())
    .then((data) => {
      const select = document.getElementById("remote-versions");
      select.innerHTML =
        '<option value="" i18n="setting.change_update_version" id="change_update_version"></option>'; // 添加默认选项
      data.versions.forEach((version) => {
        const option = document.createElement("option");
        option.value = version;
        option.textContent = version;
        select.appendChild(option);
      });

      translateElement("#change_update_version", lang);
    })
    .catch((error) => console.error("Error fetching remote versions:", error));
}

function switchVersion(version) {
  fetch("/switch_version", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ version: version }),
  })
    .then((response) => response.json())
    .then((data) => {
      // alert(`切换到版本 ${version} 成功`);
      fetchCurrentVersion(); // 更新当前版本显示
    })
    .catch((error) => console.error("Error switching version:", error));
}

function downloadAndInstallVersion(version) {
  lastProgress = 0; // 重置前端进度状态
  fetch("/download_package", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ version: version }),
  })
    .then((response) => response.json())
    .then((data) => {
      // alert(`下载并安装版本 ${version} 成功`);
      fetchDownloadedVersions(); // 更新已下载的版本列表
      localStorage.setItem("downloading_version", version); // 记录正在下载的版本
    })
    .catch((error) => console.error("Error downloading version:", error));
}

const staticUpdateBtn = document.getElementById("static-update-btn");
staticUpdateBtn.addEventListener("click", async function () {
  let askUpdateUIText = await getPopupText("askUpdateUIText");
  showPopup(askUpdateUIText).then(
    (confirmed) => {
      if (confirmed) {
        if (typeof AndroidInterface !== "undefined") {
          AndroidInterface.sendMessageToAndroid("Update Static Resources");
          console.log("发送Android消息: Update Static Resources");
        } else {
          console.log("AndroidInterface未定义，仅作测试")
        }
      }
    }
  );
})


async function fetchVortXDBCurrentVersion() {
  let currentVtxVersion = document.getElementById("current-vtx-version");
  let loadingText = await getPopupText("loadingText");
  currentVtxVersion.textContent = loadingText;
  fetch("/get_vtx_current_version")
    .then((response) => response.json())
    .then((data) => {
      currentVtxVersion.textContent =
        data.current_version;
      currentVersion = data.current_version;
    })
    .catch((error) => console.error("Error fetching current version:", error));
}

function fetchVortXDBDownloadedVersions() {
  fetch("/get_vtx_versions")
    .then((response) => response.json())
    .then((data) => {
      const select = document.getElementById("downloaded-vtx-versions");
      select.innerHTML =
        '<option value="" i18n="setting.change_select_version" id="change_select_version"></option>'; // 添加默认选项
      data.versions.forEach((version) => {
        const option = document.createElement("option");
        option.value = version;
        option.textContent = version;
        select.appendChild(option);
      });

      translateElement("#change_select_version", lang);
    })
    .catch((error) =>
      console.error("Error fetching downloaded versions:", error)
    );
}

function fetchVortXDBRemoteVersions() {
  fetch("/get_vtx_remote_versions")
    .then((response) => response.json())
    .then((data) => {
      const select = document.getElementById("remote-vtx-versions");
      select.innerHTML =
        '<option value="" id="vtx_change_update_version" i18n="setting.change_update_version"></option>'; // 添加默认选项
      data.versions.forEach((version) => {
        const option = document.createElement("option");
        option.value = version;
        option.textContent = version;
        select.appendChild(option);
      });

      translateElement("#vtx_change_update_version", lang);
    })
    .catch((error) => console.error("Error fetching remote versions:", error));
}

function switchVortXDBVersion(version) {
  fetch("/switch_vtx_version", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ version: version }),
  })
    .then((response) => response.json())
    .then((data) => {
      // alert(`切换到版本 ${version} 成功`);
      fetchVortXDBCurrentVersion(); // 更新当前版本显示
    })
    .catch((error) => console.error("Error switching version:", error));
}

function downloadAndInstallVortXDBVersion(version) {
  lastProgress = 0; // 重置前端进度状态
  fetch("/download_vtx_package", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ version: version }),
  })
    .then((response) => response.json())
    .then((data) => {
      // alert(`下载并安装版本 ${version} 成功`);
      fetchVortXDBDownloadedVersions(); // 更新已下载的版本列表
      localStorage.setItem("downloading_version", version); // 记录正在下载的版本
    })
    .catch((error) => console.error("Error downloading version:", error));
}

const resetBtn = document.getElementById("reset-btn");
resetBtn.addEventListener("click", async function () {
  if (massageServiceStarted && massageServiceStarted !== null) {
    let notSetZeroText = await getPopupText("notSetZeroText");
    showPopup(notSetZeroText);
    return;
  } else {
    let askSetZeroText = await getPopupText("askSetZeroText");
    showPopup(askSetZeroText).then(
      async (confirm) => {
        if (confirm) {
          let headerText = await getPopupText("headerText");
          showPopup(headerText).then(async (confirm) => {
            if (confirm) {
              let isSettingZeroText = await getPopupText("isSettingZeroText");
              showPopup(isSettingZeroText, {
                confirm: false,
                cancel: false,
              });
              fetch("/set_zero", {
                method: "POST",
                headers: {
                  "Content-Type": "application/x-www-form-urlencoded",
                },
              })
                .then((response) => response.json())
                .then(async (data) => {
                  if (data.message === "Set zero success") {
                    let setZeroText = await getPopupText("setZeroText");
                    showPopup(setZeroText, {
                      confirm: true,
                      cancel: false,
                    });
                  } else {
                    showPopup(data.message, {
                      confirm: true,
                      cancel: false,
                    });
                  }
                })
                .catch((error) =>
                  console.error("Error sending control command:", error)
                );
            }
          });
        }
      }
    );
  }
});
// 语音重置按钮
const resetLanguageBtn = document.getElementById("reset-language-btn");
resetLanguageBtn.addEventListener("click", function () {
  fetch("/reset-language", {
    method: "POST",
    headers: {
      "Content-Type": "application/x-www-form-urlencoded",
    },
  })
    .then((response) => response.json())
    .then((data) => {
      console.log(data);
    })
    .catch((error) => {
      console.error("Error:", error);
    });
});

// 机械臂上电按钮
const robotPowerOnBtn = document.getElementById("robot-power-on-btn");
robotPowerOnBtn.addEventListener("click", async function () {
  let askPowerOnText = await getPopupText("askPowerOnText");
  showPopup(askPowerOnText).then(
    async (confirm) => {
      if (confirm) {
        let powerOnIngText = await getPopupText("powerOnIngText");
        showPopup(powerOnIngText, { confirm: false, cancel: false });
        // 上电 do power on
        fetch("/power_toggle", {
          method: "POST",
          headers: {
            "Content-Type": "application/x-www-form-urlencoded", // 表单数据类型
          },
          body: new URLSearchParams({
            power_state: "power_on", // 传递的参数
          }),
        })
          .then((response) => response.json())
          .then(async (data) => {
            // let popupStr = `<p>请手动将机械臂移动到安全位置，移动完毕后点击“ 确定 ”按钮，确定后机械臂将会重新断电。</p>
            //   <p>如果需要重新调整机械臂位置，请重新点击上电按钮。</p>
            //   <p>如果拖动过程中发现机械臂无法继续拖动，可能是因为拖动速度过快或者拖动角度不对，触发安全机制，请按确定键断电后再重复上电调整操作。</p>`;
            let powerOnHintText = await getPopupText("powerOnHintText");
            let popupStr = powerOnHintText;
            let popup = showPopup(popupStr, {
              confirm: true,
              cancel: false,
            });
            // 选择已下载的版本
            const confirmBtn = document.getElementById("confirm-btn");

            confirmBtn.disabled = true;
            confirmBtn.style.background = "gray";
            let num = 10;
            let confirmText = await getPopupText("confirmText");
            confirmBtn.innerText = `${confirmText} (${num})`;
            let timer = setInterval(() => {
              num--;
              confirmBtn.innerText = `${confirmText} (${num})`;
              if (num === 0) {
                confirmBtn.innerText = `${confirmText}`;
                confirmBtn.style.setProperty(
                  "background",
                  "linear-gradient(to right bottom, rgb(212, 96, 241), rgba(145, 66, 197, 0.5))",
                  "important"
                );
                confirmBtn.disabled = false;
                clearInterval(timer);
              }
            }, 1000);

            popup.then(async (confirm) => {
              if (confirm) {
                let powerOffText = await getPopupText("powerOffText");
                showPopup(powerOffText, {
                  confirm: false,
                  cancel: false,
                });
                powerOff();
              }
            });
          })
          .catch((error) => {
            console.error("Error:", error);
            alert("An error occurred: " + error);
            showPopup(error, { confirm: true, cancel: false });
          });
      }
    }
  );
});

function powerOff() {
  fetch("/power_toggle", {
    method: "POST",
    headers: {
      "Content-Type": "application/x-www-form-urlencoded", // 表单数据类型
    },
    body: new URLSearchParams({
      power_state: "power_off", // 传递的参数
    }),
  })
    .then((response) => response.json())
    .then(async (data) => {
      let powerOffIngText = await getPopupText("powerOffIngText");
      let popupStr = powerOffIngText;
      let popup = showPopup(popupStr, {
        confirm: true,
        cancel: false,
      });
      const confirmBtn = document.getElementById("confirm-btn");

      confirmBtn.disabled = true;
      confirmBtn.style.background = "gray";
      let num = 10;

      let confirmText = await getPopupText("confirmText");
      confirmBtn.innerText = `${confirmText} (${num})`;
      let timer = setInterval(() => {
        num--;
        confirmBtn.innerText = `${confirmText} (${num})`;
        if (num === 0) {
          confirmBtn.innerText = `${confirmText}`;
          confirmBtn.style.setProperty(
            "background",
            "linear-gradient(to right bottom, rgb(212, 96, 241), rgba(145, 66, 197, 0.5))",
            "important"
          );
          confirmBtn.disabled = false;
          clearInterval(timer);
        }
      }, 1000);
    })
    .catch((error) => {
      console.error("Error:", error);
      alert("An error occurred: " + error);
      showPopup(error, { confirm: true, cancel: false });
    });
}

const robotInfoTitle = document.getElementById('robot-info-title');
// 获取“开发者模式”按钮元素
const developerModeBtn = document.getElementById('developer-mode-btn');

// 用于存储点击次数
let clickCount = 0;

// 用于存储最后一次点击的时间
let lastClickTime = 0;

// 定义点击间隔时间（单位：毫秒）
const clickInterval = 500; // 500毫秒内点击3次

// 监听点击事件
robotInfoTitle.addEventListener('click', function () {
  // 如果点击事件的目标是“开发者模式”按钮，则不执行逻辑
  if (event.target === developerModeBtn || event.target.closest('.btn')) {
    return;
  }

  const currentTime = new Date().getTime();

  // 如果当前点击时间与上次点击时间间隔大于设定的间隔时间，则重置点击次数
  if (currentTime - lastClickTime > clickInterval) {
    clickCount = 0;
  }

  // 增加点击次数
  clickCount++;

  // 更新最后一次点击时间
  lastClickTime = currentTime;

  // 如果点击次数达到3次，则执行相应的方法
  if (clickCount === 3) {
    toggleDeveloperMode();
    clickCount = 0; // 重置点击次数
  }
});

function toggleDeveloperMode() {
  const developerMode = document.getElementById('developer-mode-btn');
  if (developerMode.style.display === 'none') {
    developerMode.style.display = 'block';
    // localStorage.setItem("developerModeFlag", true);
  } else {
    developerMode.style.display = 'none';
    // localStorage.setItem("developerModeFlag", false);
  }
}

// 监听“开发者模式”按钮的点击事件
developerModeBtn.addEventListener('click', function () {
  // 显示密码框
  showPwdModal().then(async (confirm) => {
    if (confirm) {
      if (pwdInput.value === "") {
        let pwdEmptyText = await getPopupText("pwdEmptyText");
        showPopup(pwdEmptyText);
        return;
      } else {
        fetch("/develop_login", {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            password: pwdInput.value,
          }),
        })
          .then((response) => response.json())
          .then(async (data) => {
            if (data.success) {
              window.location.href = "/developer";
            } else {
              let pwdErrorText = await getPopupText("pwdErrorText");
              showPopup(pwdErrorText);
            }
          })
          .catch((error) => {
            console.error("Error:", error);
          });
      }
    }
  });
});

// const developerModeBtnStatus = localStorage.getItem("developerModeFlag") || false;
// if (developerModeBtnStatus) {
//   developerModeBtn.style.display = 'block';
// } else {
//   developerModeBtn.style.display = 'none';
// }