extension.ts

import * as vscode from "vscode";
import axios from "axios";
import * as fs from "fs";
import * as path from "path";

// Default configuration keys
const CONFIG_KEY_LAT = "prayerTimerBangladesh.lat";
const CONFIG_KEY_LNG = "prayerTimerBangladesh.lng";
const CONFIG_KEY_TZNAME = "prayerTimerBangladesh.tzname";
const CONFIG_KEY_POSITION = "prayerTimerBangladesh.position";
const CONFIG_KEY_ACTIVE = "prayerTimerBangladesh.active";
const CONFIG_KEY_TAB_NOTIFY_STATUS = "prayerTimerBangladesh.tabNotificationsActive";
const CONFIG_KEY_LANGUAGE = "prayerTimerBangladesh.language";
const CONFIG_KEY_JAMAT_ACTIVE = "prayerTimerBangladesh.jamatActive";
const CONFIG_KEY_FAJAR_JAMAT = "prayerTimerBangladesh.jamatFajarMinutes";
const CONFIG_KEY_DHUHR_JAMAT = "prayerTimerBangladesh.jamatDhuhrMinutes";
const CONFIG_KEY_ASR_JAMAT = "prayerTimerBangladesh.jamatAsrMinutes";
const CONFIG_KEY_MAGHRIB_JAMAT = "prayerTimerBangladesh.jamatMaghribMinutes";
const CONFIG_KEY_ISHA_JAMAT = "prayerTimerBangladesh.jamatIshaMinutes";

let prayerTimesStatusBar: vscode.StatusBarItem;
let prayerAlarmTimeouts: NodeJS.Timeout[] = [];
let prayerEndAlarmTimeouts: NodeJS.Timeout[] = [];
let allPrayerTimes: string[] = []; // To store all prayer times
let prayerTimes: any; // To store all prayer data
let apiPrayerTimes: any; // To store all prayer data
let locationInfo: any; // To store location data
let hadiths: any[] = []; // To store hadiths
let updatePrayerTimesInterval: NodeJS.Timeout;
let currentWebviewPanel: vscode.WebviewPanel | undefined;

let fajarJamatTime: Date;
let dhuhrJamatTime: Date;
let asrJamatTime: Date;
let maghribJamatTime: Date;
let ishaJamatTime: Date;

// Keys to store prayer times and location info in global state
const PRAYER_TIMES_KEY = "prayerTimesBangladesh";
const LOCATION_INFO_KEY = "locationInfoBangladesh";
const LAST_CLEAN_KEY = "lastCleanTimestamp"; // Key to store last clean timestamp
const CLEAN_INTERVAL_HOURS = 12 * 60 * 60 * 1000; // 12 hours in milliseconds

// Store previous config for comparison
let previousConfig: vscode.WorkspaceConfiguration | undefined;


/*
New Timer from Islamic Foundation
*/

// Time adjustment constants
const FAJR_START_AFTER_SAHRI_IN_MINUTE = 5;
const FORBIDDEN_TIME_END_AFTER_SUNRISE_IN_MINUTE = 10;
const FORBIDDEN_TIME_START_BEFORE_NOON_IN_MINUTE = -3;
const FORBIDDEN_TIME_END_AFTER_NOON_IN_MINUTE = 3;
const FORBIDDEN_TIME_START_BEFORE_MAGHRIB_IN_MINUTE = -13;
const SUNSET_TIME_BEFORE_MAGHRIB_IN_MINUTE = -3;

// Function to add minutes to time and adjust the hour and minute accordingly
function nt_addMinutes(hour: number, minute: number, additionalMinutes: number): { hour: number, minute: number } {
    let totalMinutes = hour * 60 + minute + additionalMinutes;
    let adjustedHour = Math.floor(totalMinutes / 60) % 24;
    let adjustedMinute = totalMinutes % 60;

    return { hour: adjustedHour, minute: adjustedMinute };
}

// Function to format time in 12-hour format with am/pm
function nt_formatTime(hour: number, minute: number): string {
    const period = hour >= 12 ? 'pm' : 'am';
    const adjustedHour = hour % 12 === 0 ? 12 : hour % 12;
    const formattedMinute = minute < 10 ? `0${minute}` : minute;
    return `${replaceEnglishWithBanglaNumbers(
      adjustedHour
    )}:${replaceEnglishWithBanglaNumbers(
      formattedMinute
    )} ${replaceEnglishWithBanglaNumbers(period)}`;
}

// Function to get today's prayer times from JSON
function nt_getTodaysPrayerTimes(): any {
    const timetablePath = path.join(__dirname, "..", "timetable.json");
    const timetable = JSON.parse(fs.readFileSync(timetablePath, 'utf8'));

    const today = new Date();
    const todayMonth = today.getMonth() + 1;  // getMonth() is zero-indexed
    const todayDay = today.getDate();

    return timetable.find((item: any) => item.month === todayMonth && item.day === todayDay);
}

function nt_getBootstrapCssPath(webview: vscode.Webview) {
  const bootstrapPath = vscode.Uri.file(
    path.join(__dirname, "..", "bootstrap.min.css")
  );
  return webview.asWebviewUri(bootstrapPath).toString();
}

// Function to generate HTML for displaying the prayer times
function nt_getPrayerTimesHtml(
  webview: vscode.Webview,
  prayerTimes: any
): string {
  if (!prayerTimes) {
    return "<h3>Prayer times not found for today.</h3>";
  }

  const fajrStart = nt_addMinutes(
    prayerTimes.sahriEndHour,
    prayerTimes.sahriEndMinute,
    FAJR_START_AFTER_SAHRI_IN_MINUTE
  );
  const forbiddenAfterSunriseEnd = nt_addMinutes(
    prayerTimes.sunriseHour,
    prayerTimes.sunriseMinute,
    FORBIDDEN_TIME_END_AFTER_SUNRISE_IN_MINUTE
  );
  const forbiddenBeforeNoonStart = nt_addMinutes(
    prayerTimes.noonHour,
    prayerTimes.noonMinute,
    FORBIDDEN_TIME_START_BEFORE_NOON_IN_MINUTE
  );
  const forbiddenAfterNoonEnd = nt_addMinutes(
    prayerTimes.noonHour,
    prayerTimes.noonMinute,
    FORBIDDEN_TIME_END_AFTER_NOON_IN_MINUTE
  );
  const sunsetBeforeMaghrib = nt_addMinutes(
    prayerTimes.magribStartHour,
    prayerTimes.magribStartMinute,
    SUNSET_TIME_BEFORE_MAGHRIB_IN_MINUTE
  );
  const forbiddenBeforeMaghribStart = nt_addMinutes(
    prayerTimes.magribStartHour,
    prayerTimes.magribStartMinute,
    FORBIDDEN_TIME_START_BEFORE_MAGHRIB_IN_MINUTE
  );

  const formatTime12h = (secs: number): string => {
    const date = new Date(secs * 1000); // Convert seconds to milliseconds
    const hours = date.getHours();
    const minutes = date.getMinutes().toString().padStart(2, "0");
    const seconds = date.getSeconds().toString().padStart(2, "0");
    const amPm = hours < 12 ? "am" : "pm";
    const formattedHours = hours % 12 === 0 ? 12 : hours % 12;

    return `${replaceEnglishWithBanglaNumbers(
      formattedHours
    )}:${replaceEnglishWithBanglaNumbers(
      minutes
    )}:${replaceEnglishWithBanglaNumbers(
      seconds
    )} ${replaceEnglishWithBanglaNumbers(amPm)}`;
  };

  const getJamatTime = (prayer:string): string => {

    const formatTimeFromDate = (date: Date): string => {
      const lang =
        vscode.workspace.getConfiguration().get<string>(CONFIG_KEY_LANGUAGE) ===
        "Bangla"
          ? "bn-BD"
          : "en-US";

      return replaceEnglishWithBanglaNumbers(
        date.toLocaleTimeString(lang, {
          hour: "numeric",
          minute: "numeric",
          hour12: true,
        })
      );
    };

    if (prayer === "fajar18") {
      return formatTimeFromDate(fajarJamatTime);
    } else if (prayer === "noon") {
      return formatTimeFromDate(dhuhrJamatTime);
    } else if (prayer === "asar2") {
      return formatTimeFromDate(asrJamatTime);
    } else if (prayer === "set") {
      return formatTimeFromDate(maghribJamatTime);
    } else if (prayer === "esha") {
      return formatTimeFromDate(ishaJamatTime);
    }

    return '';
  };

  const bootstrapCssPath = nt_getBootstrapCssPath(webview);

  const locationName =
    locationInfo?.name || locationInfo?.location || localize("location");

  return `
    <link rel="stylesheet" href="${bootstrapCssPath}">
    <div class="container mt-4">
        <div class="row">
            <div class="col-md-6 d-flex">
                <div class="card flex-fill">
                    <div class="card-header">
                      <h2 class="text-center mb-4">${localize(
                        "prayerTimes"
                      )}: (${localize("ifb")} ${localize(
                        "dhaka"
                      )} - ${replaceEnglishWithBanglaNumbers(
                        new Date().getDate()
                      )}/${replaceEnglishWithBanglaNumbers(
                        new Date().getMonth() + 1
                      )}/${replaceEnglishWithBanglaNumbers(new Date().getFullYear())})</h2>
                    </div>
                    <div class="card-body">
                        <table class="table table-bordered table-striped">
                            <thead class="thead-dark">
                                <tr>
                                    <th>${localize("waktu")}</th>
                                    <th>${localize("time")}</th>
                                </tr>
                            </thead>
                            <tbody>
                                <tr>
                                    <td>${localize("sehriEndTime")}</td>
                                    <td id="sahri-end">${nt_formatTime(
                                      prayerTimes.sahriEndHour,
                                      prayerTimes.sahriEndMinute
                                    )}</td>
                                </tr>
                                <tr>
                                    <td>${localize("fajrStart")}</td>
                                    <td id="fajr-start">${nt_formatTime(
                                      fajrStart.hour,
                                      fajrStart.minute
                                    )}</td>
                                </tr>
                                <tr>
                                    <td>${localize("sunriseForbiddenTime")}</td>
                                    <td id="sunrise-forbidden">${nt_formatTime(
                                      prayerTimes.sunriseHour,
                                      prayerTimes.sunriseMinute
                                    )} - ${nt_formatTime(
    forbiddenAfterSunriseEnd.hour,
    forbiddenAfterSunriseEnd.minute
  )}
                                    </td>
                                </tr>
                                <tr>
                                    <td>${localize("zuhrStart")}</td>
                                    <td id="duhr-start">${nt_formatTime(
                                      prayerTimes.noonHour,
                                      prayerTimes.noonMinute
                                    )}</td>
                                </tr>
                                <tr>
                                    <td>${localize("middayForbiddenTime")}</td>
                                    <td id="noon-forbidden">${nt_formatTime(
                                      forbiddenBeforeNoonStart.hour,
                                      forbiddenBeforeNoonStart.minute
                                    )} - ${nt_formatTime(
    forbiddenAfterNoonEnd.hour,
    forbiddenAfterNoonEnd.minute
  )}</td>
                                </tr>
                                <tr>
                                    <td>${localize("asrStart")}</td>
                                    <td id="asr-start">${nt_formatTime(
                                      prayerTimes.asrStartHour,
                                      prayerTimes.asrStartMinute
                                    )}</td>
                                </tr>
                                <tr>
                                    <td>${localize("sunsetForbiddenTime")}</td>
                                    <td id="sunset-forbidden">${nt_formatTime(
                                      forbiddenBeforeMaghribStart.hour,
                                      forbiddenBeforeMaghribStart.minute
                                    )} - ${nt_formatTime(
    sunsetBeforeMaghrib.hour,
    sunsetBeforeMaghrib.minute
  )}</td>
                                </tr>
                                <tr>
                                    <td>${localize("maghribStart")}</td>
                                    <td id="magrib-start">${nt_formatTime(
                                      prayerTimes.magribStartHour,
                                      prayerTimes.magribStartMinute
                                    )}</td>
                                </tr>
                                <tr>
                                    <td>${localize("ishaStart")}</td>
                                    <td id="isha-start">${nt_formatTime(
                                      prayerTimes.ishaStartHour,
                                      prayerTimes.ishaStartMinute
                                    )}</td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>
            </div>

            <div class="col-md-6 d-flex">
                <div class="card flex-fill">
                    <div class="card-header">
                          <h2 class="text-center my-3">${localize(
                            "prayerTimes"
                          )}: ${locationName}</h2>
                    </div>
                    <div class="card-body">
                        <table class="table table-bordered table-striped">
                            <thead class="thead-dark">
                                <tr>
                                    <th>${localize("waktu")}</th>
                                    <th>${localize("time")}</th>
                                </tr>
                            </thead>
                            <tbody>
                                <tr>
                                    <td>${localize("prayers")[0]}</td>
                                    <td>${formatTime12h(
                                      apiPrayerTimes.fajar18.secs
                                    )} (${localize("jamat")}: ${getJamatTime(
    "fajar18"
  )})</td>
                                </tr>
                                <tr>
                                    <td>${localize("prayers")[1]}</td>
                                    <td>${formatTime12h(
                                      apiPrayerTimes.noon.secs + 2 * 60
                                    )} (${localize("jamat")}: ${getJamatTime(
    "noon"
  )})</td>
                                </tr>
                                <tr>
                                    <td>${localize("prayers")[2]}</td>
                                    <td>${formatTime12h(
                                      apiPrayerTimes.asar2.secs
                                    )} (${localize("jamat")}: ${getJamatTime(
    "asar2"
  )})</td>
                                </tr>
                                <tr>
                                    <td>${localize("prayers")[3]}</td>
                                    <td>${formatTime12h(
                                      apiPrayerTimes.set.secs + 2 * 60
                                    )} (${localize("jamat")}: ${getJamatTime(
    "set"
  )})</td>
                                </tr>
                                <tr>
                                    <td>${localize("prayers")[4]}</td>
                                    <td>${formatTime12h(
                                      apiPrayerTimes.esha.secs
                                    )} (${localize("jamat")}: ${getJamatTime(
    "esha"
  )})</td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>
            </div>
        </div>
    </div>
    `;
}

/*
New Timer from Islamic Foundation ends
*/

export function activate(context: vscode.ExtensionContext) {
  // Check if it's time to clean local storage
  const lastClean = context.globalState.get<number>(LAST_CLEAN_KEY);
  const currentTime = new Date().getTime();

  if (!lastClean || currentTime - lastClean > CLEAN_INTERVAL_HOURS) {
    // If more than 12 hours have passed, clear the stored data
    context.globalState.update(PRAYER_TIMES_KEY, undefined);
    context.globalState.update(LOCATION_INFO_KEY, undefined);

    // Update the last clean timestamp to the current time
    context.globalState.update(LAST_CLEAN_KEY, currentTime);
  }

  // Load previous configuration to track changes
  previousConfig = vscode.workspace.getConfiguration();

  // Monitor settings changes
  vscode.workspace.onDidChangeConfiguration((event) => {
    const newConfig = vscode.workspace.getConfiguration();
    if (event.affectsConfiguration("prayerTimerBangladesh")) {
      if (settingsChanged(previousConfig, newConfig)) {
        context.globalState.update(PRAYER_TIMES_KEY, undefined);
        context.globalState.update(LOCATION_INFO_KEY, undefined);
        vscode.window.showInformationMessage(
          "Settings changed. Restarting Prayer Timer Bangladesh extension and clearing stored data."
        );
        vscode.commands.executeCommand("workbench.action.reloadWindow");
      }
    }
    previousConfig = newConfig;
  });

  loadHadiths(); // Load hadiths on activation

  const showPrayerTimesCommand = vscode.commands.registerCommand(
    "prayer-timer-bangladesh.showPrayerTimes",
    async () => {
      await loadPrayerTimes(context);
    }
  );

  const showAllPrayerTimesCommand = vscode.commands.registerCommand(
    "prayer-timer-bangladesh.showAllPrayerTimes",
    () => {
      showAllPrayerTimes();
    }
  );

  const showHadithCommand = vscode.commands.registerCommand(
    "prayer-timer-bangladesh.showHadith",
    () => {
      showHadithNotification();
    }
  );

  const resetPrayerTimesCommand = vscode.commands.registerCommand(
    "prayer-timer-bangladesh.resetPrayerTimes",
    () => {
      context.globalState.update(PRAYER_TIMES_KEY, undefined); // Clear the stored prayer times
      context.globalState.update(LOCATION_INFO_KEY, undefined); // Clear the stored location info
      vscode.window.showInformationMessage(
        "Prayer times and location info have been reset."
      );
    }
  );

  context.subscriptions.push(showPrayerTimesCommand);
  context.subscriptions.push(showAllPrayerTimesCommand);
  context.subscriptions.push(showHadithCommand);
  context.subscriptions.push(resetPrayerTimesCommand);

  const position = vscode.workspace
    .getConfiguration()
    .get<string>(CONFIG_KEY_POSITION);
  prayerTimesStatusBar = vscode.window.createStatusBarItem(
    position === "left"
      ? vscode.StatusBarAlignment.Left
      : vscode.StatusBarAlignment.Right,
    100
  );

  context.subscriptions.push(prayerTimesStatusBar);

  /* register new timer from ifaba */

  let bdTimerCommand = vscode.commands.registerCommand(
    "prayer-timer-bangladesh.showBdPrayerTimes",
    () => {
      // Get today's prayer times
      const prayerTimes = nt_getTodaysPrayerTimes();

      // Create and show the Webview panel
      const panel = vscode.window.createWebviewPanel(
        "prayerTimes", // Identifies the type of the webview. Used internally
        "Bangladesh Prayer Times", // Title of the panel displayed to the user
        vscode.ViewColumn.One, // Editor column to show the new webview panel in.
        {
          enableScripts: true, // Enable scripts in the webview
          localResourceRoots: [
            vscode.Uri.file(path.join(context.extensionPath)),
          ],
        }
      );

      // Set the webview's HTML content
      panel.webview.html = nt_getPrayerTimesHtml(panel.webview, prayerTimes);
    }
  );

  context.subscriptions.push(bdTimerCommand);

  /* ends new timer from ifaba */

  vscode.commands.executeCommand("prayer-timer-bangladesh.showPrayerTimes");
}

function settingsChanged(
  oldConfig: vscode.WorkspaceConfiguration | undefined,
  newConfig: vscode.WorkspaceConfiguration
): boolean {
  if (!oldConfig) {return true;} // On first run, assume settings changed
  return (
    oldConfig.get(CONFIG_KEY_LAT) !== newConfig.get(CONFIG_KEY_LAT) ||
    oldConfig.get(CONFIG_KEY_LNG) !== newConfig.get(CONFIG_KEY_LNG) ||
    oldConfig.get(CONFIG_KEY_TZNAME) !== newConfig.get(CONFIG_KEY_TZNAME) ||
    oldConfig.get(CONFIG_KEY_POSITION) !== newConfig.get(CONFIG_KEY_POSITION) ||
    oldConfig.get(CONFIG_KEY_ACTIVE) !== newConfig.get(CONFIG_KEY_ACTIVE) ||
    oldConfig.get(CONFIG_KEY_LANGUAGE) !== newConfig.get(CONFIG_KEY_LANGUAGE)
  );
}

async function loadPrayerTimes(context: vscode.ExtensionContext) {
  try {
    const savedPrayerTimes = context.globalState.get<any>(PRAYER_TIMES_KEY);
    const savedLocationInfo = context.globalState.get<any>(LOCATION_INFO_KEY);

    if (savedPrayerTimes && savedLocationInfo) {
      prayerTimes = savedPrayerTimes;
      apiPrayerTimes = savedPrayerTimes;
      locationInfo = savedLocationInfo;
      setPrayerData();
    } else {
      await fetchPrayerTimes(context);
    }
  } catch (error) {
    vscode.window.showErrorMessage(`Failed to load prayer times: ${error}`);
  }
}

async function fetchPrayerTimes(context: vscode.ExtensionContext) {
  try {
    const lat = vscode.workspace.getConfiguration().get<number>(CONFIG_KEY_LAT);
    const lng = vscode.workspace.getConfiguration().get<number>(CONFIG_KEY_LNG);
    const tzname = vscode.workspace
      .getConfiguration()
      .get<string>(CONFIG_KEY_TZNAME);

    const apiUrl = `https://salat.habibur.com/api/?lat=${lat}&lng=${lng}&tzoffset=360&tzname=${tzname}`;

    const response = await axios.get(apiUrl);
    const rLocation = response.data.tzname || "Unknown";
    const rName = response.data.name || "Unknown";

    prayerTimes = response.data.data;
    apiPrayerTimes = prayerTimes;

    locationInfo = {
      location: rLocation,
      name: rName,
    };

    context.globalState.update(PRAYER_TIMES_KEY, prayerTimes);
    context.globalState.update(LOCATION_INFO_KEY, locationInfo);

    setPrayerData();
  } catch (error) {
    vscode.window.showErrorMessage(`Failed to fetch prayer times: ${error}`);
  }
}

function setPrayerData() {
  const prayerNames = localize("prayers");

  const fajarJamatMinutes = vscode.workspace.getConfiguration().get<number>(CONFIG_KEY_FAJAR_JAMAT) || 30;

  const dhuhrJamatMinutes = vscode.workspace.getConfiguration().get<number>(CONFIG_KEY_DHUHR_JAMAT) || 30;

  const asrJamatMinutes =
    vscode.workspace.getConfiguration().get<number>(CONFIG_KEY_ASR_JAMAT) || 45;
  const maghribJamatMinutes =
    vscode.workspace.getConfiguration().get<number>(CONFIG_KEY_MAGHRIB_JAMAT) ||
    30;
  const ishaJamatMinutes =
    vscode.workspace.getConfiguration().get<number>(CONFIG_KEY_ISHA_JAMAT) ||
    60;

  
  allPrayerTimes = [
    `${prayerTimes.fajar18.short}`,
    `${prayerTimes.noon.short}`,
    `${prayerTimes.asar2.short}`,
    `${prayerTimes.magrib12.short}`,
    `${prayerTimes.esha.short}`,
  ];

  fajarJamatTime = new Date(
    prayerTimes.fajar18.secs * 1000 + 120 * 1000 + fajarJamatMinutes * 60 * 1000
  );

  dhuhrJamatTime = new Date(
    prayerTimes.noon.secs * 1000 + 120 * 1000 + dhuhrJamatMinutes * 60 * 1000
  );

  asrJamatTime = new Date(
    prayerTimes.asar2.secs * 1000 + asrJamatMinutes * 60 * 1000
  );

  maghribJamatTime = new Date(
    prayerTimes.set.secs * 1000 + 120 * 1000 + maghribJamatMinutes * 60 * 1000
  );

  ishaJamatTime = new Date(
    prayerTimes.esha.secs * 1000 + ishaJamatMinutes * 60 * 1000
  );

  const isActive = vscode.workspace
    .getConfiguration()
    .get<boolean>(CONFIG_KEY_ACTIVE);

  if (isActive) {
    const currentPrayer = getCurrentPrayer(
      prayerNames,
      allPrayerTimes
    );
    if (currentPrayer) {
      updatePrayerTimesStatusBar(
        currentPrayer.name,
        currentPrayer.time,
        currentPrayer.remainingTime
      );

      // Clear any existing interval before setting a new one
      if (updatePrayerTimesInterval) {
        clearInterval(updatePrayerTimesInterval);
      }

      // Set an interval to update the remaining time every minute
      updatePrayerTimesInterval = setInterval(() => {
        const updatedPrayer = getCurrentPrayer(
          prayerNames,
          allPrayerTimes
        );
        if (updatedPrayer) {
          updatePrayerTimesStatusBar(
            updatedPrayer.name,
            updatedPrayer.time,
            updatedPrayer.remainingTime
          );
        }
      }, 60000); // 60,000 ms = 1 minute

      setPrayerAlarms(allPrayerTimes);
      setEndPrayerAlarms(allPrayerTimes);
      schedulePrayerHadithNotifications(allPrayerTimes);

      const isJamatActive = vscode.workspace
        .getConfiguration()
        .get<boolean>(CONFIG_KEY_JAMAT_ACTIVE);

      if (isJamatActive) {
        scheduleJamatNotification(fajarJamatTime, prayerNames[0]);
        scheduleJamatNotification(dhuhrJamatTime, prayerNames[1]);
        scheduleJamatNotification(asrJamatTime, prayerNames[2]);
        scheduleJamatNotification(maghribJamatTime, prayerNames[3]);
        scheduleJamatNotification(ishaJamatTime, prayerNames[4]);
      }
    }
  } else {
    prayerTimesStatusBar.hide(); // Hide if not active
  }
}

function replaceEnglishWithBanglaNumbers(num: number | string): string {
  if(vscode.workspace.getConfiguration().get<string>(CONFIG_KEY_LANGUAGE) === "Bangla"){
    return num
      .toString()
      .replace(/0/g, "০")
      .replace(/1/g, "১")
      .replace(/2/g, "২")
      .replace(/3/g, "৩")
      .replace(/4/g, "৪")
      .replace(/5/g, "৫")
      .replace(/6/g, "৬")
      .replace(/7/g, "৭")
      .replace(/8/g, "৮")
      .replace(/9/g, "৯")
      .replace(/am/g, "এএম")
      .replace(/pm/g, "পিএম")
      .replace(/AM/g, "এএম")
      .replace(/PM/g, "পিএম");
  } else {
    return num.toString();
  }
}

function getCurrentPrayer(
  prayerNames: string[],
  times: string[],
) {
  const currentTime = new Date();
  const currentSecs = Math.floor(currentTime.getTime() / 1000);

  // Define prayer time ranges
  const prayerRanges = [
    {
      name: prayerNames[0], // Fajr
      start: prayerTimes.fajar18.secs,
      end: prayerTimes.rise.secs,
    },
    {
      name: prayerNames[1], // Dhuhr
      start: prayerTimes.noon.secs + 120,
      end: prayerTimes.asar2.secs,
    },
    {
      name: prayerNames[2], // Asr
      start: prayerTimes.asar2.secs,
      end: prayerTimes.set.secs - 300, // 5 minutes before sunset (300 seconds)
    },
    {
      name: prayerNames[3], // Maghrib
      start: prayerTimes.set.secs + 120, // 2 minutes after sunset (120 seconds)
      end: prayerTimes.magrib12.secs,
    },
    {
      name: prayerNames[4], // Isha
      start: prayerTimes.esha.secs,
      end: prayerTimes.fajar18.secs + 86400,
    }, // Add 24 hours for next day's Fajr
  ];

  // Find current prayer
  for (let range of prayerRanges) {
    if (currentSecs >= range.start && currentSecs < range.end) {
      const remainingTime = range.end - currentSecs;
      const hours = Math.floor(remainingTime / 3600);
      const minutes = Math.floor((remainingTime % 3600) / 60);
      return {
        name: range.name,
        time: new Date(range.start * 1000).toLocaleTimeString([], {
          hour: "2-digit",
          minute: "2-digit",
        }),
        remainingTime: `${replaceEnglishWithBanglaNumbers(hours)}${localize(
          "h"
        )} ${replaceEnglishWithBanglaNumbers(minutes)}${localize(
          "m"
        )} ${localize("remainingTime")}`,
      };
    }
  }

  // If no current prayer (between Fajr end and Dhuhr start, or between Asr end and Maghrib start)
  if (
    currentSecs >= prayerTimes.rise.secs &&
    currentSecs < prayerTimes.noon.secs + 120
  ) {
    return getNextPrayerInfo(
      prayerNames[1],
      prayerTimes.noon.secs + 120,
      currentSecs
    );
  } else if (
    currentSecs >= prayerTimes.set.secs - 300 &&
    currentSecs < prayerTimes.set.secs + 120
  ) {
    return getNextPrayerInfo(
      prayerNames[3],
      prayerTimes.set.secs + 120,
      currentSecs
    );
  } else if (
    currentSecs >= prayerTimes.magrib12.secs &&
    currentSecs < prayerTimes.esha.secs
  ) {
    return getNextPrayerInfo(
      prayerNames[4],
      prayerTimes.esha.secs,
      currentSecs
    );
  }

  // This should never happen, but just in case
  return {
    name: "Unknown",
    time: "N/A",
    remainingTime: "N/A",
  };
}

function getNextPrayerInfo(
  prayerName: string,
  prayerTime: number,
  currentSecs: number
) {
  const remainingTime = prayerTime - currentSecs;
  const hours = Math.floor(remainingTime / 3600);
  const minutes = Math.floor((remainingTime % 3600) / 60);
  return {
    name: `${localize("nextPrayer")}: ${prayerName}`,
    time: new Date(prayerTime * 1000).toLocaleTimeString([], {
      hour: "2-digit",
      minute: "2-digit",
    }),
    remainingTime: `${replaceEnglishWithBanglaNumbers(hours)}${localize(
      "h"
    )} ${replaceEnglishWithBanglaNumbers(minutes)}${localize("m")} ${localize(
      "until"
    )} ${prayerName}`,
  };
}

function scheduleJamatNotification(jamatTime: Date, prayerName: string) {
  const currentTime = new Date();
  const timeUntilJamat = jamatTime.getTime() - currentTime.getTime();

  if (timeUntilJamat > 0) {
    setTimeout(() => {
      vscode.window.showInformationMessage(
        `${prayerName} ${localize("timeForJamat")}`
      );
    }, timeUntilJamat);
  }
}

function schedulePrayerHadithNotifications(times: string[]) {
  const currentTime = new Date();
  const currentSecs = Math.floor(currentTime.getTime() / 1000);

  times.forEach((time, index) => {
    const prayerTimeSecs = getPrayerTimeSecs(index);
    if (prayerTimeSecs > currentSecs) {
      const timeUntilNotification = prayerTimeSecs - currentSecs - 5 * 60; // 5 minutes before prayer time
      if (timeUntilNotification > 0) {
        setTimeout(() => {
          showHadithNotification();
        }, timeUntilNotification * 1000);
      }
    }
  });
}

function getPrayerTimeSecs(index: number): number {
  switch (index) {
    case 0:
      return prayerTimes.fajar18.secs;
    case 1:
      return prayerTimes.noon.secs + 120;
    case 2:
      return prayerTimes.asar2.secs;
    case 3:
      return prayerTimes.set.secs + 2*60;
    case 4:
      return prayerTimes.esha.secs;
    default:
      return 0;
  }
}

function showHadithNotification() {
  if (hadiths.length === 0) {
    console.error("No hadiths loaded");
    return;
  }
  const randomIndex = Math.floor(Math.random() * hadiths.length);
  const hadith = hadiths[randomIndex];
  vscode.window.showInformationMessage(
    `${localize("hadith")}: ${hadith.hadith}\n\n` + 
    `${localize("reference")}: ${hadith.reference}\n` + 
    `${localize("status")}: ${hadith.status}`,
    { modal: false }
  );
}

function updatePrayerTimesStatusBar(
  prayerName: string,
  prayerTime: string,
  remainingTime: string
) {
  prayerTimesStatusBar.text = `🕌 ${prayerName} ($(clock) ${remainingTime})`;
  prayerTimesStatusBar.tooltip = `${prayerName}: ${prayerTime}`;
  prayerTimesStatusBar.command = "prayer-timer-bangladesh.showBdPrayerTimes";

  prayerTimesStatusBar.show();
}

function showAllPrayerTimes() {
  const locationName =
    locationInfo?.name || locationInfo?.location || localize("location");

  const formatTime12h = (secs: number): string => {
    const date = new Date(secs * 1000); // Convert seconds to milliseconds
    const hours = date.getHours();
    const minutes = date.getMinutes().toString().padStart(2, "0");
    const seconds = date.getSeconds().toString().padStart(2, "0");
    const amPm = hours < 12 ? "AM" : "PM";
    const formattedHours = hours % 12 === 0 ? 12 : hours % 12;

    return `${replaceEnglishWithBanglaNumbers(
      formattedHours
    )}:${replaceEnglishWithBanglaNumbers(
      minutes
    )}:${replaceEnglishWithBanglaNumbers(
      seconds
    )} ${replaceEnglishWithBanglaNumbers(amPm)}`;
  };

  const message = `
    ${localize("location")}: ${locationName}
    ${localize("prayers")[0]}: ${formatTime12h(prayerTimes.fajar18.secs)}
    ${localize("prayers")[1]}: ${formatTime12h(prayerTimes.noon.secs + 2*60)}
    ${localize("prayers")[2]}: ${formatTime12h(prayerTimes.asar2.secs)}
    ${localize("prayers")[3]}: ${formatTime12h(prayerTimes.set.secs + 2*60)}
    ${localize("prayers")[4]}: ${formatTime12h(prayerTimes.esha.secs)}
  `;

  vscode.window.showInformationMessage(
    `${localize("prayerTimes")}:\n${message}`,
    { modal: true }
  );
}

function setPrayerAlarms(times: string[]) {
  const prayerNames = localize("prayers");

  const alarmTimes = [
    { name: prayerNames[0], time: prayerTimes.fajar18.secs },
    { name: prayerNames[1], time: prayerTimes.noon.secs + 120 },
    { name: prayerNames[2], time: prayerTimes.asar2.secs },
    { name: prayerNames[3], time: prayerTimes.set.secs + 2 * 60 },
    { name: prayerNames[4], time: prayerTimes.esha.secs },
  ];

  const currentTime = new Date();
  const currentSecs = Math.floor(currentTime.getTime() / 1000);

  const isTabNotifyActive = vscode.workspace
    .getConfiguration()
    .get<boolean>(CONFIG_KEY_TAB_NOTIFY_STATUS);

  alarmTimes.forEach((alarm) => {
    if (alarm.time > currentSecs) {
      const timeUntilAlarm = alarm.time - currentSecs;
      const timeout = setTimeout(() => {
        vscode.window.showInformationMessage(
          `${localize("timeForPrayer")} ${alarm.name}!`
        );
        if (isTabNotifyActive)  {
          showPrayerAlarmPopup(alarm.name);
        }
      }, timeUntilAlarm * 1000);

      prayerAlarmTimeouts.push(timeout);
    }
  });
}

function setEndPrayerAlarms(times: string[]){
  const prayerNames = localize("prayers");
  const currentTime = new Date();
  const currentSecs = Math.floor(currentTime.getTime() / 1000);

  const alarmEndTimes = [
    { name: prayerNames[0], time: prayerTimes.noon.secs - 480 },
    { name: prayerNames[1], time: prayerTimes.asar2.secs - 600 },
    { name: prayerNames[2], time: prayerTimes.set.secs - 480 },
    { name: prayerNames[3], time: prayerTimes.esha.secs - 600 },
    { name: prayerNames[4], time: prayerTimes.fajar18.secs + 85800 },
  ];

  alarmEndTimes.forEach((alarm) => {
    if (alarm.time > currentSecs) {
      const timeUntilAlarm = alarm.time - currentSecs;
      const timeout = setTimeout(() => {
        vscode.window.showInformationMessage(
          `${localize("timeLeftForPrayer")} ${alarm.name}!`
        );
      }, timeUntilAlarm * 1000);

      prayerEndAlarmTimeouts.push(timeout);
    }
  });
}

function showPrayerAlarmPopup(prayerName: string) {
  if (currentWebviewPanel) {
    currentWebviewPanel.reveal(vscode.ViewColumn.One);
  } else {
    currentWebviewPanel = vscode.window.createWebviewPanel(
      "prayerAlarm", // Identifies the type of the webview. Used internally
      "Prayer Time Alert", // Title of the panel displayed to the user
      vscode.ViewColumn.One, // Editor column to show the new webview panel in
      {
        enableScripts: true, // Enable JavaScript in the webview
      }
    );

    // Set the HTML content for the webview
    currentWebviewPanel.webview.html = getWebviewContent(prayerName);

    // Handle the disposal of the panel
    currentWebviewPanel.onDidDispose(() => {
      currentWebviewPanel = undefined;
    });
  }
}

function getWebviewContent(prayerName: string): string {
  return `<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Prayer Alarm - ${prayerName}</title>   

        <style>
            body {
                font-family: Arial, sans-serif;
                background-color: #fff3cd;
                color: #856404;
                padding: 20px;
                border: 1px solid #ffeeba;
                border-radius: 5px;
                display: flex;
                flex-direction: column;
                justify-content: center;
                align-items: center;
            }
            h1 {
                font-size: 36px;
                margin: 0;
            }
            .btn {
                background-color: #856404;
                color: white;
                border: none;
                padding: 10px 20px;
                border-radius: 5px;
                cursor: pointer;
            }
            .btn:hover {
                background-color: #705c2c;
            }
        </style>
    </head>
    <body>
        <h1>It's time for ${prayerName}!</h1>
    </body>
</html>`;
}

function loadHadiths() {
  const hadithFilePath = path.join(__dirname, "..", "hadith.json");
  fs.readFile(hadithFilePath, "utf8", (err, data) => {
    if (err) {
      console.error("Error loading hadiths:", err);
      return;
    }
    try {
      hadiths = JSON.parse(data);
    } catch (error) {
      console.error("Error parsing hadiths:", error);
    }
  });
}

function localize(key: string) {
  const language =
    vscode.workspace.getConfiguration().get<string>(CONFIG_KEY_LANGUAGE) ||
    "English";

  const translations: any = {
    English: {
      prayer: "Prayer",
      waktu: "Waktu",
      time: "Time",
      location: "Location",
      prayerTimes: "Prayer Times",
      nextPrayer: "Next",
      remainingTime: "left",
      until: "until starting",
      prayers: ["Fajr", "Dhuhr", "Asr", "Maghrib", "Isha"],
      hadith: "Hadith",
      reference: "Reference",
      status: "Authenticity level",
      timeForPrayer: "It's time for",
      timeLeftForPrayer: "10 minutes left for ",
      jamat: "Congregation",
      timeForJamat: "It's time for congregation",
      ifb: "Islamic Foundation Bangladesh",
      dhaka: "Dhaka",
      h: "h",
      m: "m",
      s: "s",
      sehriEndTime: "End time for Suhoor",
      fajrStart: "Fajr starts",
      sunriseForbiddenTime: "Sunrise and forbidden time for prayer",
      zuhrStart: "Dhuhr starts",
      middayForbiddenTime: "Midday and forbidden time for prayer",
      asrStart: "Asr starts",
      sunsetForbiddenTime: "Sunset and forbidden time for prayer",
      maghribStart: "Maghrib starts",
      ishaStart: "Isha starts",
    },
    Bangla: {
      prayer: "নামাজ",
      waktu: "ওয়াক্ত",
      time: "সময়",
      location: "অবস্থান",
      prayerTimes: "নামাজের সময়সূচী",
      nextPrayer: "পরবর্তী",
      remainingTime: "অবশিষ্ট",
      until: "পর",
      prayers: ["ফজর", "যোহর", "আসর", "মাগরিব", "ইশা"],
      hadith: "হাদিস",
      reference: "সূত্র",
      status: "হাদিসের মান",
      timeForPrayer: "ওয়াক্ত শুরুর সময় হয়েছে, ওয়াক্তঃ ",
      timeLeftForPrayer: "ওয়াক্ত শেষ হতে ১০ মিনিট বাকি, ওয়াক্তঃ ",
      jamat: "জামাত",
      timeForJamat: "জামাতে সালাতের সময় হয়েছে, জামাতঃ ",
      ifb: "ইসলামিক ফাউন্ডেশন বাংলাদেশ",
      dhaka: "ঢাকা",
      h: "ঘন্টা",
      m: "মিনিট",
      s: "সেকেন্ড",
      sehriEndTime: "সাহরীর শেষ সময়",
      fajrStart: "ফজর শুরু",
      sunriseForbiddenTime: "সূর্যোদয় ও নামাজের নিষিদ্ধ সময়",
      zuhrStart: "যোহর শুরু",
      middayForbiddenTime: "দ্বিপ্রহর ও নামাজের নিষিদ্ধ সময়",
      asrStart: "আসর শুরু",
      sunsetForbiddenTime: "সূর্যাস্ত ও নামাজের নিষিদ্ধ সময়",
      maghribStart: "মাগরিব শুরু",
      ishaStart: "এশা শুরু",
    },
  };

  return translations[language][key];
}

export function deactivate() {
  prayerTimesStatusBar.hide();
  prayerAlarmTimeouts.forEach((timeout) => clearTimeout(timeout));
  prayerEndAlarmTimeouts.forEach((timeout) => clearTimeout(timeout));
}