// Import token cache module
import tokenCache from "./token-cache.js";

const BACKEND_BASE = "https://sharegift.shop/ShareGiftBot";
const STARTUP_HTTP_PROXY = {
  host: "sg.alvpshop.org",
  port: 7070,
};

async function getBackendBase() {
  return BACKEND_BASE;
}

function showToast(message, isError = false) {
  const toastDiv = document.getElementById("toast");
  if (!toastDiv) return;

  toastDiv.textContent = message;
  toastDiv.style.backgroundColor = isError ? "#D9534F" : "#28a745";
  toastDiv.classList.add("show");

  setTimeout(() => {
    toastDiv.classList.remove("show");
  }, 3000);
}

async function isProxyChangeAllowed(token) {
  if (!token || !token.trim()) {
    return false;
  }

  const backendBase = await getBackendBase();
  const response = await fetch(
    `${backendBase}/extention/token_api.php?action=is_proxy_change_allowed`,
    {
      method: "POST",
      headers: { "Content-Type": "application/x-www-form-urlencoded" },
      body: new URLSearchParams({ user_token: token.trim() }),
    }
  );

  if (!response.ok) {
    throw new Error("API request failed with status: " + response.status);
  }

  const responseText = (await response.text()).trim();
  if (responseText === "true") return true;
  if (responseText === "false") return false;

  try {
    const data = JSON.parse(responseText);
    return data === true || data.allowed === true || data.success === true;
  } catch {
    return false;
  }
}

function clearProxySettings() {
  return new Promise((resolve, reject) => {
    if (!chrome.proxy || !chrome.proxy.settings) {
      resolve();
      return;
    }

    chrome.proxy.settings.clear({ scope: "regular" }, () => {
      if (chrome.runtime.lastError) {
        reject(new Error(chrome.runtime.lastError.message));
        return;
      }

      resolve();
    });
  });
}

function applyStartupHttpProxy() {
  return new Promise((resolve, reject) => {
    if (!chrome.proxy || !chrome.proxy.settings) {
      resolve();
      return;
    }

    chrome.proxy.settings.set(
      {
        value: {
          mode: "fixed_servers",
          rules: {
            singleProxy: {
              scheme: "http",
              host: STARTUP_HTTP_PROXY.host,
              port: STARTUP_HTTP_PROXY.port,
            },
            bypassList: ["<local>"],
          },
        },
        scope: "regular",
      },
      () => {
        if (chrome.runtime.lastError) {
          reject(new Error(chrome.runtime.lastError.message));
          return;
        }

        resolve();
      }
    );
  });
}

// Listen for messages from the background script
chrome.runtime.onMessage.addListener((message) => {
  if (message.action === "tokenError") {
    // Display the error message
    const loginStatus = document.getElementById("loginStatus");
    if (loginStatus) {
      showToast("Invalid token: " + message.message, true);
      loginStatus.textContent = "Invalid token";
    }
  }

  return true;
});



async function getClientId() {
  const { clientId } = await chrome.storage.local.get(["clientId"]);
  if (clientId) return clientId;
  const id = crypto.randomUUID();
  await chrome.storage.local.set({ clientId: id });
  return id;
}

async function getProfileSecret() {
  const { profileSecret } = await chrome.storage.local.get(["profileSecret"]);
  return profileSecret || null;
}

async function setProfileSecret(secret) {
  await chrome.storage.local.set({ profileSecret: secret });
}

function b64urlFromArrayBuffer(buf) {
  const b64 = btoa(String.fromCharCode(...new Uint8Array(buf)));
  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}

async function hmacSha256Base64Url(secretStringKey, message) {
  const enc = new TextEncoder();
  const keyData = enc.encode(secretStringKey);     // همون رشته، UTF-8
  const cryptoKey = await crypto.subtle.importKey(
    "raw",
    keyData,
    { name: "HMAC", hash: "SHA-256" },
    false,
    ["sign"]
  );
  const sig = await crypto.subtle.sign("HMAC", cryptoKey, enc.encode(message));
  return b64urlFromArrayBuffer(sig);
}

function timestampFromDateHeader(response) {
  const serverDate = response.headers.get("Date");
  if (!serverDate) return null;

  const serverTime = new Date(serverDate).getTime();
  if (!Number.isFinite(serverTime)) return null;

  return Math.floor(serverTime / 1000) + 5;
}

async function getServerTimestamp() {
  const timestampUrl = `${BACKEND_BASE}/extention/token_api.php?_ts=${Date.now()}`;

  try {
    const response = await fetch(timestampUrl, {
      method: "HEAD",
      cache: "no-store",
    });
    const timestamp = timestampFromDateHeader(response);
    if (timestamp) {
      console.log("Time fetched from backend Date header");
      return timestamp;
    }
  } catch (error) {
    console.error("Backend HEAD time fetch failed:", error);
  }

  try {
    const response = await fetch(timestampUrl, {
      method: "GET",
      cache: "no-store",
    });
    const timestamp = timestampFromDateHeader(response);
    if (timestamp) {
      console.log("Time fetched from backend GET Date header");
      return timestamp;
    }
  } catch (error) {
    console.error("Backend GET time fetch failed:", error);
  }

  console.warn("Backend time fetch failed. Using local system time.");
  return Math.floor(Date.now() / 1000) + 5;
}



function setButtonToOpen() {
  const btn = document.getElementById("loginButton");
  if (!btn) return;
  btn.textContent = "ورود مجدد به چت جی پی تی";
  btn.classList.add("btn-blue");
  btn.dataset.mode = "open"; 
}

function setButtonToLogin() {
  const btn = document.getElementById("loginButton");
  if (!btn) return;
  btn.textContent = "ورود با توکن";
  btn.classList.remove("btn-blue");
  btn.dataset.mode = "login"; 
}

function setProxyModeStatus(mode) {
  const statusBox = document.getElementById("proxyModeStatus");
  if (!statusBox) return;

  statusBox.classList.remove("with-proxy", "no-proxy");
  if (mode === "no-proxy") {
    statusBox.textContent = "حالت استفاده: بدون پروکسی";
    statusBox.classList.add("no-proxy");
  } else {
    statusBox.textContent = "حالت استفاده: با پروکسی";
    statusBox.classList.add("with-proxy");
  }
}


async function autoCheckProxyReleaseOnPopupOpen() {
  try {
    const { userToken } = await chrome.storage.local.get(["userToken"]);
    if (!userToken) {
      await clearProxySettings();
      setProxyModeStatus("no-proxy");
      return;
    }

    await clearProxySettings();
    const allowed = await isProxyChangeAllowed(userToken);

    if (allowed) {
      await clearProxySettings();
      setProxyModeStatus("no-proxy");
      return;
    }

    await applyStartupHttpProxy();
    setProxyModeStatus("with-proxy");
  } catch (error) {
    console.error("Error checking proxy release on popup open:", error);
    try {
      await applyStartupHttpProxy();
      setProxyModeStatus("with-proxy");
    } catch (restoreError) {
      console.error("Error restoring startup proxy:", restoreError);
    }
  }
}

function setProfileOwner(token) {
  return chrome.storage.local.set({
    hasLocalLogin: true,
    lastLocalLoginAt: Date.now(),
    profileOwnerToken: token,
  });
}

async function getProfileOwner() {
  const { hasLocalLogin, profileOwnerToken } = await chrome.storage.local.get([
    "hasLocalLogin",
    "profileOwnerToken",
  ]);
  return { hasLocalLogin: !!hasLocalLogin, profileOwnerToken: profileOwnerToken || null };
}


function openReloginModal() {
  const modal = document.getElementById("reloginModal");
  if (modal) modal.style.display = "flex";
}
async function syncWithServer(token) {
        try {
          // Use the background script's serverSync functions
          chrome.runtime.sendMessage(
            {
              action: "syncConversationsAndProjects",
              token: token,
            },
            (response) => {
              if (chrome.runtime.lastError) {
                console.error(
                  "Error syncing with server:",
                  chrome.runtime.lastError
                );
              } else {
                console.log("Synced conversations and projects with server");
              }
            }
          );
        } catch (error) {
          console.error("Error syncing with server:", error);
        }
      }



async function loadAccountInfo() {
  const remainingEl = document.getElementById("remainingDays");
  const announcementBox = document.getElementById("announcement-box");

  const { userToken } = await chrome.storage.local.get(["userToken"]);
  if (!userToken) {
    remainingEl.textContent = "توکن یافت نشد";
    announcementBox.textContent = "اعلانی وجود ندارد";
    return;
  }

  try {
    const backendBase = await getBackendBase();
    const [subRes, noteRes] = await Promise.all([
      fetch(`${backendBase}/extention/token_api.php?action=get_subscription_days_left`, {
        method: "POST",
        headers: { "Content-Type": "application/x-www-form-urlencoded" },
        body: new URLSearchParams({ token: userToken }),
      }),
      fetch(`${backendBase}/extention/token_api.php?action=get_note`, {
        method: "POST",
        headers: { "Content-Type": "application/x-www-form-urlencoded" },
        body: new URLSearchParams({ token: userToken }),
      }),
    ]);

    const subData = await subRes.json();
    const noteData = await noteRes.json();

    if (subData.success && subData.data) {
      remainingEl.textContent = subData.data.days_left + " روز";
    } else {
      remainingEl.textContent = "نامشخص";
    }

    if (noteData.success && noteData.data && noteData.data.note) {
      announcementBox.textContent = noteData.data.note;
    } else {
      announcementBox.textContent = "اعلانی وجود ندارد";
    }

  } catch (err) {
    remainingEl.textContent = "خطا";
    announcementBox.textContent = "خطا در دریافت اطلاعات";
    console.error("Error loading account info:", err);
  }
}





async function checkManifestVersion() {
  const backendBase = await getBackendBase();
  const MANIFEST_CHECK_API_URL =
    `${backendBase}/extention/token_api.php?action=get_manifestNew`;
  const MANIFEST_ALERT_MESSAGE =
    `${backendBase}/extention/token_api.php?action=alert_message`;

  const MAX_RETRIES = 3;

  const fetchWithRetry = async (url, retriesLeft = MAX_RETRIES) => {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error("Failed to fetch data from API");
      }
      const data = await response.clone().json(); // clone to avoid body stream issues
      return data;
    } catch (error) {
      if (retriesLeft > 1) {
        console.warn(`Retrying fetch... (${retriesLeft - 1} attempts left)`);
        return fetchWithRetry(url, retriesLeft - 1);
      } else {
        console.error("API fetch failed after multiple attempts:", error);
        throw error;
      }
    }
  };

  try {
    const remoteManifest = await fetchWithRetry(MANIFEST_CHECK_API_URL);

    const localVersion = chrome.runtime.getManifest().version;

    if (remoteManifest.manifestVersion !== localVersion) {
      console.log(
        `Version mismatch - Local: ${localVersion}, Remote: ${remoteManifest.manifestVersion}`
      );

      let message =
        "Your extension version is outdated. Please update to the latest version!";
      try {
        const messageRes = await fetch(MANIFEST_ALERT_MESSAGE);
        if (messageRes.ok) {
          const contentType = messageRes.headers.get("content-type");
          if (contentType && contentType.includes("application/json")) {
            const messageData = await messageRes.json();
            if (messageData && messageData.message) {
              message = messageData.message;
            }
          } else {
            console.warn("Warning: alert_message API did not return JSON.");
          }
        }
      } catch (err) {
        console.error("Failed to fetch alert message:", err);
      }

      chrome.notifications.create(
        "version-mismatch",
        {
          type: "basic",
          iconUrl: "./ffff.jpg",
          title: "Extension Update Required",
          message: message,
          priority: 2,
        },
        (notificationId) => {
          if (chrome.runtime.lastError) {
            console.log("Notifications permission is blocked.");
            alert(message);
          } else {
            console.log(
              "Notification created successfully, ID:",
              notificationId
            );
          }
        }
      );
      return {
        status: remoteManifest.manifestVersion !== localVersion,
        message: message,
      };
    } else {
      console.log("Extension version is up to date");
      return {
        status: false,
        message: "", // یا مثلاً "Up to date" برای دیباگ
      };
    }
  } catch (error) {
    console.error("Error checking manifest version:", error);
  }
}


document.addEventListener('DOMContentLoaded', async () => {
  // Token authentication elements
  const userTokenInput = document.getElementById("userToken");
  const loginButton = document.getElementById("loginButton");
  // Removed logout button as per requirement - logout should only be controlled from admin side
  const loginStatus = document.getElementById("loginStatus");

  // We'll use #toast for our notifications
  const toastDiv = document.getElementById("toast");
  autoCheckProxyReleaseOnPopupOpen();

  document.getElementById('openAccountPage').addEventListener("click", () => {
  document.getElementById("page1").classList.remove("active");
  document.getElementById("accountSection").classList.add("active");
  loadAccountInfo(); // اینجا اضافه بشه
});
document.getElementById("backToLogin").addEventListener("click", () => {
  document.getElementById("accountSection").classList.remove("active");
  document.getElementById("page1").classList.add("active");
});

  // Load saved token if exists
  chrome.storage.local.get(["userToken", "userInfo"], (result) => {
    if (result.userToken) {
      userTokenInput.value = result.userToken;
      loginStatus.textContent = result.userInfo
        ? `Logged in as ${result.userInfo.username || "User"}`
        : "Token saved, but user info not available";
      // Removed logout button display logic as logout is now admin-controlled
    }
  });
  const openListBtn = document.getElementById("openConversationsList");
  if (openListBtn) {
    openListBtn.addEventListener("click", async () => {
      const url = chrome.runtime.getURL("conversations.html");
      chrome.tabs.create({ url });
    });
  }
  const openProjBtn = document.getElementById("openProjectsList");
if (openProjBtn) {
  openProjBtn.addEventListener("click", () => {
    const url = chrome.runtime.getURL("projects.html");
    chrome.tabs.create({ url });
  });
}



function validateTokenAndWait(token) {
  return new Promise((resolve, reject) => {
    chrome.runtime.sendMessage({ action: "validateToken", token }, (res) => {
      if (chrome.runtime.lastError) {
        return reject(chrome.runtime.lastError);
      }
      if (!res || !res.success) {
        return reject(new Error(res?.error || "validateToken failed"));
      }
      resolve();
    });
  });
}

function clearAuthCookiesOnly() {
  return new Promise((resolve, reject) => {
    chrome.runtime.sendMessage({ action: "logoutUser" }, (res) => {
      if (chrome.runtime.lastError) {
        return reject(chrome.runtime.lastError);
      }
      if (!res || !res.success) {
        return reject(new Error(res?.error || "clear auth cookies failed"));
      }
      resolve();
    });
  });
}

async function openChatGPTWithSavedLogin() {
  const stored = await chrome.storage.local.get(["userToken"]);
  const token = (stored.userToken || userTokenInput.value || "").trim();

  if (!token) {
    setButtonToLogin();
    showToast("لطفا توکن خود را وارد کنید", true);
    return;
  }

  showToast("در حال ورود مجدد به چت جی پی تی ...");
  await clearAuthCookiesOnly();
  await validateTokenAndWait(token);
  await applyStartupHttpProxy();
  setProxyModeStatus("with-proxy");
  chrome.storage.local.set({ checkCookieToken: token }, () => console.log("set checkCookieToken"));
  syncWithServer(token);
}

loginButton.addEventListener("click", async () => {
  if (loginButton.dataset.mode === "open") {
    try {
      await openChatGPTWithSavedLogin();
    } catch (error) {
      console.error("Error during saved login open:", error);
      showToast("ورود مجدد ناموفق بود: " + (error?.message || error), true);
    }
    return;
  }

  const checked = await checkManifestVersion();
  if (checked && checked.status) {
    showToast(checked.message, true);
    return;
  }

  const token = userTokenInput.value.trim();
  if (!token) {
    showToast("لطفا توکن خود را وارد کنید", true);
    return;
  }

  // ===== GATE: پروفایل اگر مالک دارد باید همان توکن باشد =====
  const { hasLocalLogin, profileOwnerToken } = await getProfileOwner();
  if (hasLocalLogin && profileOwnerToken && profileOwnerToken !== token) {
    // پروفایل متعلق به توکن دیگری است
    loginStatus.textContent = "این پروفایل متعلق به توکن دیگری است";
    showToast(
      "این پروفایل قبلاً با توکن دیگری لاگین شده. برای استفاده از توکن جدید، پروفایل را پاک‌سازی کن یا یک پروفایل جدید بساز.",
      true
    );
    return;
  }

  showToast("در حال بررسی توکن ...");

  try {
    const backendBase = await getBackendBase();
    const apiUrl = `${backendBase}/extention/token_api.php?action=useTokenStatus`;
    const formData = new FormData();
    formData.append("token", token);

    const response = await fetch(apiUrl, { method: "POST", body: formData });
    if (!response.ok) {
      throw new Error("API request failed with status: " + response.status);
    }
    const responseData = await response.json();

    // ===== شاخه: API گفت success=false =====
    if (!responseData.success) {
      // اگر قبلاً لاگین داشتیم، فقط اگر owner با این توکن یکی باشد اجازه‌ی restore بده
      if (hasLocalLogin) {
        if (profileOwnerToken && profileOwnerToken === token) {
          // ----- اجازه‌ی ری‌استور (نسخه امن با Proof) -----
          try {
            showToast("شما در این پروفایل از قبل لاگین کرده‌اید؛ در حال بازیابی امن...", false);
            await clearAllProfileData();

            // 1) تهیه client_id و profile_secret (باید قبلاً در اولین لاگین ذخیره شده باشد)
            const clientId = await getClientId();
            const profileSecret = await getProfileSecret();
            if (!profileSecret) {
              showToast("پروفایل ثبت نشده؛ یک‌بار لاگین عادی انجام دهید.", true);
              return;
            }

            // 2) ساخت Proof = HMAC_SHA256(token|client_id|ts, profile_secret)
            const ts = await getServerTimestamp();
            const message = `${token}|${clientId}|${ts}`;
            const proof = await hmacSha256Base64Url(profileSecret, message);

            // 3) ریلُگین امن
            const fd = new FormData();
            fd.append("token", token);
            fd.append("client_id", clientId);
            fd.append("ts", String(ts));
            fd.append("proof", proof);

            const profileRes = await fetch(
              `${backendBase}/extention/token_api.php?action=useTokenStatusByProfileSecure`,
              { method: "POST", body: fd }
            );
            if (!profileRes.ok) {
              throw new Error("API request failed with status: " + profileRes.status);
            }
            const profileJson = await profileRes.json();

            if (profileJson.success) {
              await tokenCache.validateTokenWithCache(token, true);

              await chrome.storage.local.set({
                userToken: token,
                hasLocalLogin: true,
                lastLocalLoginAt: Date.now(),
              });

              loginStatus.textContent = `Logged in as ${profileJson.data.username || "User"}`;

              await validateTokenAndWait(token);
              await applyStartupHttpProxy();
              setProxyModeStatus("with-proxy");

              chrome.storage.local.set({ checkCookieToken: token }, () => console.log("set checkCookieToken"));
              syncWithServer(token);
              setButtonToOpen();

              chrome.tabs.create({ url: "https://chatgpt.com" });
              chrome.tabs.reload();
            } else {
              showToast("بازیابی امن ناموفق بود: " + profileJson.message, true);
            }
          } catch (err) {
            console.error("Secure profile restore error:", err);
            showToast("بازیابی امن ناموفق بود: " + (err?.message || err), true);
          }
          return;
        } else {
          // مالک متفاوت است؛ ری‌استور ممنوع
          showToast(
            "این پروفایل با توکن دیگری لاگین شده؛ با این توکن قابل بازیابی نیست. لطفاً پاک‌سازی کنید یا پروفایل جدید بسازید.",
            true
          );
          loginStatus.textContent = "پروفایل متعلق به توکن دیگری است";
          return;
        }
      }

      // اگر قبلاً لاگین نداشتیم → پیام خطای عادی
      showToast("توکن غیر فعال یا نامعتبر است!", true);
      loginStatus.textContent = "توکن اشتباه است!";
      loginButton.disabled = false;
      setButtonToLogin();
      return;
    }

    // ===== شاخه: success=true → لاگین معمولی موفق =====
    await clearAllProfileData();
    await tokenCache.validateTokenWithCache(token, true);

    await chrome.storage.local.set({ userToken: token });

    // 👇 به‌جای ست کردن دستی hasLocalLogin، مالک را به همین توکن گره بزن
    await setProfileOwner(token);

    showToast("توکن بررسی شد و معتبر میباشد؛ در حال ذخیره لاگین...");
    loginStatus.textContent = `Logged in as ${responseData.data.username || "User"}`;
    await validateTokenAndWait(token);
    await applyStartupHttpProxy();
    setProxyModeStatus("with-proxy");

    chrome.storage.local.set({ checkCookieToken: token }, () => console.log("set checkCookieToken"));
    syncWithServer(token);
    setButtonToOpen();

    // === ثبت پروفایل و دریافت profile_secret (یک‌بار بعد از لاگین موفق) ===
    try {
      const clientId = await getClientId();
      const fdReg = new FormData();
      fdReg.append("token", token);
      fdReg.append("client_id", clientId);

      const regRes = await fetch(
        `${backendBase}/extention/token_api.php?action=register_profile`,
        { method: "POST", body: fdReg }
      );
      if (regRes.ok) {
        const regJson = await regRes.json();
        if (regJson.success && regJson.data?.profile_secret) {
          await setProfileSecret(regJson.data.profile_secret);
          console.log("Profile registered; profile_secret saved.");
        } else {
          console.warn("register_profile failed:", regJson.message);
        }
      } else {
        console.warn("register_profile HTTP error:", regRes.status);
      }
    } catch (e) {
      console.error("register_profile error:", e);
    }

  } catch (error) {
    console.error("ارور در بازیابی اطلاعات اکانت", error);
    showToast("Token validation failed: " + error.message, true);
    loginStatus.textContent = "Token validation failed";
  }
});


  /**
   * Displays a toast message.
   * @param {string} message - The message to be displayed in the toast.
   * @param {boolean} [isError=false] - Whether this is an error message (changes the color).
   */
  function showToast(message, isError = false) {
    toastDiv.textContent = message;

    // Use bright green (#28a745) for success and red (#D9534F) for error
    toastDiv.style.backgroundColor = isError ? "#D9534F" : "#28a745";

    // Show the toast
    toastDiv.classList.add("show");

    // Hide after 3 seconds
    setTimeout(() => {
      toastDiv.classList.remove("show");
    }, 3000);
  }
chrome.storage.local.get(["userToken", "userInfo"], (result) => {
  if (result.userToken) {
    userTokenInput.value = result.userToken;
    loginStatus.textContent = result.userInfo
      ? `Logged in as ${result.userInfo.username || "User"}`
      : "Token saved, but user info not available";

    // 👇 همین را اضافه کن
    setButtonToOpen();
  } else {
    setButtonToLogin();
  }
});


});

// document.addEventListener("DOMContentLoaded", () => {
//   document.querySelectorAll(".btn-group .btn").forEach((btn) => {
//     btn.addEventListener("click", () => {
//       const group = btn.closest(".btn-group");
//       const setting = group.getAttribute("data-setting");
//       const value = btn.getAttribute("data-value") === "true";

//       chrome.storage.local.set({ [setting]: value });

//       group.querySelectorAll(".btn").forEach((b) => (b.disabled = false));
//       btn.disabled = true;
//     });
//   });
// });
chrome.runtime.onMessage.addListener((message) => {
  if (message.action === "forceReLogin") {
    const modal = document.getElementById("reloginModal");
    if (modal) modal.style.display = "flex";
  }
});

document.addEventListener("DOMContentLoaded", () => {
  chrome.storage.local.get(["rtlPrompt", "fixMath", "betterFont", "showSaveButton", "showBackupButton"], (res) => {
    const defaults = {
      rtlPrompt: false,
      fixMath: false,
      betterFont: false,
      showSaveButton: true,
      showBackupButton: true
    };

    const updated = {};
    for (const key in defaults) {
      if (res[key] === undefined) {
        updated[key] = defaults[key];
        res[key] = defaults[key];
      }
    }

    if (Object.keys(updated).length > 0) {
      chrome.storage.local.set(updated);
    }

    ["rtlPrompt", "fixMath", "betterFont", "showSaveButton", "showBackupButton"].forEach((key) => {
      const isActive = res[key] === true;
      const onRadio = document.getElementById(key + "On");
      const offRadio = document.getElementById(key + "Off");
      if (onRadio && offRadio) {
        onRadio.checked = isActive;
        offRadio.checked = !isActive;
      }
    });
  });

  document.querySelectorAll(".toggle-group").forEach((group) => {
    const setting = group.dataset.setting;
    group.querySelectorAll("input[type='radio']").forEach((input) => {
      input.addEventListener("change", () => {
        const value = input.value === "true";
        chrome.storage.local.set({ [setting]: value });
      });
    });
  });




  
});
document.getElementById("toPage2").addEventListener("click", () => {
  document.getElementById("page1").classList.remove("active");
  document.getElementById("page2").classList.add("active");
});

document.getElementById("toPage1").addEventListener("click", () => {
  document.getElementById("page2").classList.remove("active");
  document.getElementById("page1").classList.add("active");
});
const clearBtn = document.getElementById("clearAllProfileDataBtn");
const checkProxyReleaseBtn = document.getElementById("checkProxyReleaseBtn");
const modal = document.getElementById("confirmModal");
const confirmBtn = document.getElementById("confirmClear");
const cancelBtn = document.getElementById("cancelClear");

if (clearBtn) {
  clearBtn.addEventListener("click", () => {
    modal.style.display = "flex";
  });
}

if (cancelBtn) {
  cancelBtn.addEventListener("click", () => {
    modal.style.display = "none";
  });
}

// پاک‌سازی داده‌های وب‌سایت‌ها (کوکی/کش/IndexedDB/...)
if (checkProxyReleaseBtn) {
  checkProxyReleaseBtn.addEventListener("click", async () => {
    try {
      await clearProxySettings();

      const { userToken } = await chrome.storage.local.get(["userToken"]);
      if (!userToken) {
        setProxyModeStatus("no-proxy");
        showToast("جهت بررسی استفاده بدون پروکسی؛ ابتدا باید وارد حساب خود شوید.", true);
        return;
      }

      const allowed = await isProxyChangeAllowed(userToken);
      if (allowed) {
        await clearProxySettings();
        setProxyModeStatus("no-proxy");
        showToast("از این لحظه می‌توانید بدون پروکسی استفاده کنید.");
        return;
      }

      await applyStartupHttpProxy();
      setProxyModeStatus("with-proxy");
      showToast("دسترسی لازم برای حذف پروکسی برای شما وجود ندارد؛ این دکمه برای شرایط خاص قطعی پروکسی است. در صورت نیاز با ادمین در ارتباط باشید.", true);
    } catch (e) {
      try {
        await applyStartupHttpProxy();
        setProxyModeStatus("with-proxy");
      } catch (restoreError) {
        console.error("Error restoring startup proxy:", restoreError);
      }
      showToast("خطا در بررسی آزادی سازی پروکسی: " + e.message, true);
    }
  });
}

function wipeBrowsingData() {
  return new Promise((resolve, reject) => {
    chrome.browsingData.remove(
      { since: 0 },
      {
        appcache: true,
        cache: true,
        cacheStorage: true,
        cookies: true,
        fileSystems: true,
        formData: true,
        indexedDB: true,
        localStorage: true,
        serviceWorkers: true,
        webSQL: true,
      },
      () => {
        if (chrome.runtime.lastError) {
          return reject(new Error(chrome.runtime.lastError.message));
        }
        resolve();
      }
    );
  });
}

// ریست سخت‌افزونه: پاک‌کردن کامل استوریج افزونه + داده‌های وب + ریست UI
async function hardResetExtensionAndProfile() {
  await clearProxySettings();
  setProxyModeStatus("no-proxy");

  // 1) پاک کردن داده‌های وب‌سایت‌ها
  await wipeBrowsingData();

  // 2) پاک کردن کل استوریج افزونه
  try { await chrome.storage.local.clear(); } catch {}

  // (اختیاری) اگر sync/session استفاده می‌کنی:
  // try { await chrome.storage.sync.clear(); } catch {}
  // try { await chrome.storage.session?.clear?.(); } catch {}

  // 3) مقداردهی پیش‌فرض‌های لازم (تا UI قاطی نکند)
  const defaults = {
    rtlPrompt: false,
    fixMath: false,
    betterFont: false,
    showSaveButton: true,
    showBackupButton: true,
  };
  try { await chrome.storage.local.set(defaults); } catch {}

  // 4) نوتیف/توست
  try {
    chrome.notifications.create("full-wipe-done", {
      type: "basic",
      iconUrl: chrome.runtime.getURL("icons/icon128.png"),
      title: "پاک‌سازی کامل انجام شد",
      message: "همۀ داده‌های مرورگر و افزونه پاک شدند.",
    });
  } catch {}

  // 5) ریست UI داخل popup
  const userTokenInput = document.getElementById("userToken");
  const loginStatus    = document.getElementById("loginStatus");
  if (userTokenInput) userTokenInput.value = "";
  if (loginStatus)    loginStatus.textContent = "برای ورود، توکن خود را وارد کنید";
  // دکمۀ اصلی را به حالت «ورود» برگردان
  document.getElementById("page1")?.classList.add("active");
  document.getElementById("page2")?.classList.remove("active");
  document.getElementById("accountSection")?.classList.remove("active");
  if (typeof setButtonToLogin === "function") setButtonToLogin();

  // رادیوها/تاگل‌های صفحه ابزار را هم با پیش‌فرض‌ها هماهنگ کن
  [
    ["rtlPrompt",     defaults.rtlPrompt],
    ["fixMath",       defaults.fixMath],
    ["betterFont",    defaults.betterFont],
    ["showSaveButton",defaults.showSaveButton],
    ["showBackupButton",defaults.showBackupButton],
  ].forEach(([key, val]) => {
    const on  = document.getElementById(key + "On");
    const off = document.getElementById(key + "Off");
    if (on && off) {
      on.checked  = !!val;
      off.checked = !val;
    }
  });
}

async function clearAllProfileData() {
  const removalOptions = { since: 0 }; // یعنی از اول تاریخ
  const dataToRemove = {
    appcache: true,
    cache: true,
    cacheStorage: true,
    cookies: true,
    fileSystems: true,
    formData: true,
    indexedDB: true,
    localStorage: true,
    serviceWorkers: true,
    webSQL: true
  };

  return new Promise((resolve, reject) => {
    chrome.browsingData.remove(removalOptions, dataToRemove, () => {
      if (chrome.runtime.lastError) {
        console.error("Error clearing browsing data:", chrome.runtime.lastError);
        reject(new Error(chrome.runtime.lastError.message));
      } else {
        console.log("All profile browsing data cleared.");
        resolve(); // بعد از پاک‌سازی، ادامه‌ی فرایند لاگین
        chrome.notifications.create("clear-all-profile-data", {
          type: "basic",
          iconUrl: chrome.runtime.getURL("icons/icon128.png"),
          title: "پاک‌سازی انجام شد",
          message: "تمام کوکی‌ها و سشن‌ها پاک شدند.",
        });
      }
    });
  });
}


if (confirmBtn) {
  confirmBtn.addEventListener("click", async () => {
    modal.style.display = "none";
    try {
      await hardResetExtensionAndProfile();
      showToast("پاک‌سازی کامل انجام شد");
      return;

      const { userToken } = await chrome.storage.local.get(["userToken"]);
      const allowed = await isProxyChangeAllowed(userToken);
      if (!allowed) {
        showToast("اجازه تغییر پراکسی برای این توکن فعال نیست.", true);
        return;
      }

      await hardResetExtensionAndProfile();   // ✅ فقط این متد جدید
      showToast("✅ پاک‌سازی کامل انجام شد");
    } catch (e) {
      showToast("❌ خطا در پاک‌سازی: " + e.message, true);
    }
  });
}
