main.js

// main.js
(function () {
  let timerIntervalId = null;

  async function init() {
    Core.init();
    UI.init();

    wireTabs();
    wireFilters();
    wireDeckControls();
    wireQuestionControls();
    wireTimedControls();
    wireStateImportExport();
    wireExamOptions();

    // initial stats
    UI.updateGlobalStats(Core.getGlobalStatsSummary());
    UI.updateProgressMini(Core.getProgressSummary());
    UI.updateLastDeckInfo(Core.state.appState.lastDeck || null);
    UI.updateSelectionModeButtons(Core.state.filters.selectionMode);
    UI.updateStatusButtons(Core.state.filters.status);
    UI.updatePoolButtons(Core.state.filters.pool);

    // initial decks
    const deckSummaries = Core.getAllDeckSummaries();
    UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
    UI.updateDeckSummaryList(deckSummaries);
    UI.updateActivePlaylistInfo(Core.state.filters.pool,
      deckSummaries.find(d => d.name === Core.getActiveDeckName()));

    // load file when chosen
    UI.els.fileInput.addEventListener("change", onFileChosen);
    UI.els.resetProgressBtn.addEventListener("click", onResetProgress);

    // Initialize drag and drop
    wireDragAndDrop();

    // Try to load cached dataset
    await tryLoadCachedDataset();

    // main mode = practice
    Modes.setCurrent("practice");

    // tick timer
    timerIntervalId = setInterval(onTick, 1000);
  }

  async function tryLoadCachedDataset() {
    const cached = await Core.loadQuestionsFromDB();
    if (cached && cached.rawText) {
      loadDatasetFromText(cached.rawText, cached.filename || "deck");
    } else {
      UI.showEmptyState(true); // show welcome screen
    }
  }

  function wireDragAndDrop() {
    const dropZone = UI.els.dropZone;
    if (!dropZone) return;

    ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
      document.body.addEventListener(eventName, preventDefaults, false);
    });

    ['dragenter', 'dragover'].forEach(eventName => {
      document.body.addEventListener(eventName, () => dropZone.classList.add('drag-over'), false);
    });

    ['dragleave', 'drop'].forEach(eventName => {
      document.body.addEventListener(eventName, () => dropZone.classList.remove('drag-over'), false);
    });

    document.body.addEventListener('drop', handleDrop, false);
  }

  function preventDefaults(e) {
    e.preventDefault();
    e.stopPropagation();
  }

  function handleDrop(e) {
    const dt = e.dataTransfer;
    const files = dt.files;
    if (files && files.length > 0) {
      loadFile(files[0]);
    }
  }

  function wireTabs() {
    // done in UI.init
  }

  function onFileChosen(e) {
    const file = e.target.files[0];
    if (!file) return;
    loadFile(file);
    // Reset file input so you can select the same file again if needed
    e.target.value = "";
  }

  function loadFile(file) {
    const reader = new FileReader();
    reader.onload = async evt => {
      const text = evt.target.result;
      const filename = file.name || "deck";
      await loadDatasetFromText(text, filename);
    };
    reader.readAsText(file);
  }

  async function loadDatasetFromText(text, filename) {
    try {
      const info = Core.loadQuestionsFromText(text, filename);
      UI.showEmptyState(info.total === 0);
      UI.updateDatasetInfo(filename, info.total);
      UI.updateLastDeckInfo(Core.state.appState.lastDeck || null);

      // rebuild subjects & decks
      const allSubjects = Core.getAllSubjectsArray();
      UI.updateSubjectFilters(
        allSubjects,
        Core.state.subjectsActive,
        Core.isSubjectNoneActive ? Core.isSubjectNoneActive() : Core.state.subjectNoneActive
      );

      const deckSummaries = Core.getAllDeckSummaries();
      UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
      UI.updateDeckSummaryList(deckSummaries);
      UI.updateActivePlaylistInfo(Core.state.filters.pool,
        deckSummaries.find(d => d.name === Core.getActiveDeckName()));

      UI.updateGlobalStats(Core.getGlobalStatsSummary());
      UI.updateProgressMini(Core.getProgressSummary());

      Modes.setCurrent("practice");
      // Switch to practice mode, but don't auto-advance

      if (info.total > 0) {
        const lastId = Core.state.appState.currentQuestionId;
        const lastQ = lastId ? Core.state.questionById[lastId] : null;

        if (lastQ) {
          // Restore last question from previous session (if it exists in this deck)
          Modes.practice.showQuestion(lastQ, true);
          UI.showEmptyState(false);
        } else {
          // No previous question for this deck: show a neutral "ready" state
          UI.showEmptyState(false);
          UI.els.questionText.textContent = "Deck loaded. Click Next to begin practice.";
          UI.els.optionsContainer.innerHTML = "";
          UI.els.questionIdLabel.textContent = "";
          UI.els.questionStatsInline.textContent = "";
          UI.setFeedback("neutral", "Ready when you are — hit Next to see your first card.");
          UI.els.explanationText.textContent = "";
          UI.els.explanationBox.classList.remove("visible");
          UI.els.showExplanationBtn.disabled = true;
        }
      } else {
        // Empty deck – preserve old behaviour (show 'No questions available')
        Modes.practice.showNext();
      }

      UI.els.bookmarkBtn.disabled = false;
      UI.els.manageDecksBtn.disabled = false;
      UI.els.nextBtn.disabled = false;
      UI.els.showExplanationBtn.disabled = false;
    } catch (err) {
      console.error("Error loading questions:", err);
      await UI.alert("Could not parse file. Make sure it is MedMCQA JSON or newline-separated JSON.");
    }
  }

  async function onResetProgress() {
    const confirmed = await UI.confirm("Reset all stored progress and decks in this browser?");
    if (!confirmed) return;
    await Core.hardReset();
    UI.showEmptyState(true);
    UI.renderNoQuestion();
    UI.updateGlobalStats(Core.getGlobalStatsSummary());
    UI.updateProgressMini(Core.getProgressSummary());
    const deckSummaries = Core.getAllDeckSummaries();
    UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
    UI.updateDeckSummaryList(deckSummaries);
    UI.updateActivePlaylistInfo(Core.state.filters.pool,
      deckSummaries.find(d => d.name === Core.getActiveDeckName()));
    if (Modes.current && Modes.current.currentQuestion) {
      const q = Modes.current.currentQuestion;
      const stat = Core.getStatsFor(q.id);
      UI.updatePerQuestionStats(stat);
      UI.updateBookmarkButton(Core.isBookmarked(q.id));
    }
  }

  function wireFilters() {
    UI.els.modeSmart.addEventListener("click", () => {
      Core.setSelectionMode("smart");
      UI.updateSelectionModeButtons("smart");
      Modes.setCurrent("practice");
      // Do not advance immediately; applies from next question
    });
    UI.els.modeNew.addEventListener("click", () => {
      Core.setSelectionMode("new");
      UI.updateSelectionModeButtons("new");
      Modes.setCurrent("practice");
      // Do not advance immediately; applies from next question
    });
    UI.els.modeShuffle.addEventListener("click", () => {
      Core.setSelectionMode("shuffle");
      UI.updateSelectionModeButtons("shuffle");
      Modes.setCurrent("practice");
      // Do not advance immediately; applies from next question
    });

    UI.els.statusButtons.forEach(btn => {
      btn.addEventListener("click", () => {
        const status = btn.dataset.status;
        Core.setStatusFilter(status);
        UI.updateStatusButtons(status);
        Modes.setCurrent("practice");
        // No immediate showNext; apply on next click of Next
      });
    });

    UI.els.poolDeck.addEventListener("click", () => {
      Core.setPoolSource("deck");
      UI.updatePoolButtons("deck");
      const deckSummaries = Core.getAllDeckSummaries();
      UI.updateActivePlaylistInfo("deck",
        deckSummaries.find(d => d.name === Core.getActiveDeckName()));
      Modes.setCurrent("practice");
      // No immediate showNext; apply on next click of Next
    });

    UI.els.poolPlaylist.addEventListener("click", () => {
      Core.setPoolSource("playlist");
      UI.updatePoolButtons("playlist");
      const deckSummaries = Core.getAllDeckSummaries();
      UI.updateActivePlaylistInfo("playlist",
        deckSummaries.find(d => d.name === Core.getActiveDeckName()));
      Modes.setCurrent("practice");
      // No immediate showNext; apply on next click of Next
    });

    UI.els.subjectFilters.addEventListener("click", e => {
      const btn = e.target.closest(".filter-pill");
      if (!btn) return;

      const type = btn.dataset.type || null;
      const subj = btn.dataset.subject || null;
      const allSubjects = Core.getAllSubjectsArray();

      if (type === "subject-all") {
        // Explicit "All": all subjects included, None off
        Core.resetSubjectFiltersToAll();
        Core.setSubjectNoneActive(false);

      } else if (type === "subject-none") {
        // Explicit "None": exclude all by subject filter
        Core.setSubjectNoneActive(true);

      } else if (subj) {
        const wasNone = Core.isSubjectNoneActive && Core.isSubjectNoneActive();

        if (wasNone) {
          // From "None" → clicking a subject should mean:
          // leave None, and only this subject is active.
          Core.setSubjectNoneActive(false);
          Core.state.subjectsActive = new Set([subj]);
        } else {
          const activeSet = Core.state.subjectsActive;
          const total = allSubjects.length;
          const activeCount = activeSet.size;
          const isActive = activeSet.has(subj);

          // Preserve your old special behaviour:
          // when ALL subjects are active and you click one, go to only that subject.
          if (activeCount === total && isActive) {
            Core.state.subjectsActive = new Set([subj]);
          } else {
            // Normal toggle
            if (isActive) {
              activeSet.delete(subj);
            } else {
              activeSet.add(subj);
            }
            // If this empties the set, we keep the old meaning:
            // empty + subjectNoneActive=false = "All subjects allowed".
          }
        }
      }

      UI.updateSubjectFilters(
        allSubjects,
        Core.state.subjectsActive,
        Core.isSubjectNoneActive ? Core.isSubjectNoneActive() : Core.state.subjectNoneActive
      );

      // Refresh practice selection with new filters
      Modes.setCurrent("practice");
      // Do not call showNext; current question stays, filters affect next
    });
  }

  function wireDeckControls() {
    UI.els.playlistSelect.addEventListener("change", () => {
      const name = UI.els.playlistSelect.value;
      if (!name) return;
      Core.setActiveDeckName(name);
      const deckSummaries = Core.getAllDeckSummaries();
      UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
      UI.updateDeckSummaryList(deckSummaries);
      UI.updateActivePlaylistInfo(Core.state.filters.pool,
        deckSummaries.find(d => d.name === Core.getActiveDeckName()));
      if (Core.state.filters.pool === "playlist") {
        Modes.setCurrent("practice");
        // Don't auto-advance; new deck applies on next
      }
    });

    UI.els.createDeckBtn.addEventListener("click", () => {
      const visible = UI.els.newDeckControls.style.display === "flex";
      UI.els.newDeckControls.style.display = visible ? "none" : "flex";
      if (!visible) UI.els.newDeckNameInput.focus();
    });

    UI.els.confirmCreateDeckBtn.addEventListener("click", () => {
      const name = UI.els.newDeckNameInput.value.trim();
      if (!name) return;
      Core.ensureDeck(name);
      Core.setActiveDeckName(name);
      UI.els.newDeckNameInput.value = "";
      UI.els.newDeckControls.style.display = "none";

      const deckSummaries = Core.getAllDeckSummaries();
      UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
      UI.updateDeckSummaryList(deckSummaries);
      UI.updateActivePlaylistInfo(Core.state.filters.pool,
        deckSummaries.find(d => d.name === Core.getActiveDeckName()));

      if (Core.state.filters.pool === "playlist") {
        Modes.setCurrent("practice");
        // Don't auto-advance; new deck applies on next
      }
    });

    UI.els.bookmarkBtn.addEventListener("click", () => {
      const mode = Modes.current || Modes.practice;
      const q = mode.currentQuestion || mode.currentQuestion?.();
      const question = q || Modes.practice.currentQuestion;
      if (!question) return;
      Core.toggleBookmark(question.id);
      UI.updateBookmarkButton(Core.isBookmarked(question.id));
      const deckSummaries = Core.getAllDeckSummaries();
      UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
      UI.updateDeckSummaryList(deckSummaries);
    });

    UI.els.manageDecksBtn.addEventListener("click", () => {
      const mode = Modes.current || Modes.practice;
      const q = mode.currentQuestion || mode.currentQuestion?.();
      const question = q || Modes.practice.currentQuestion;
      if (!question) return;

      const deckSummaries = Core.getAllDeckSummaries();
      UI.showDeckManagerPanel(question.id, deckSummaries, (deckName, id) =>
        Core.isInDeck(deckName, id)
      );
    });

    UI.els.closeDeckPanelBtn.addEventListener("click", () => {
      UI.hideDeckManagerPanel();
    });

    UI.els.deckPanelAddBtn.addEventListener("click", () => {
      const mode = Modes.current || Modes.practice;
      const q = mode.currentQuestion || mode.currentQuestion?.();
      const question = q || Modes.practice.currentQuestion;
      if (!question) return;
      const name = UI.els.deckPanelNewNameInput.value.trim();
      if (!name) return;
      Core.ensureDeck(name);
      Core.addToDeck(name, question.id);
      Core.setActiveDeckName(name);
      UI.els.deckPanelNewNameInput.value = "";

      const deckSummaries = Core.getAllDeckSummaries();
      UI.showDeckManagerPanel(question.id, deckSummaries, (deckName, id) =>
        Core.isInDeck(deckName, id)
      );
      UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
      UI.updateDeckSummaryList(deckSummaries);
      UI.updateBookmarkButton(Core.isBookmarked(question.id));
      UI.updateActivePlaylistInfo(Core.state.filters.pool,
        deckSummaries.find(d => d.name === Core.getActiveDeckName()));
    });

    UI.els.deckCheckboxes.addEventListener("change", e => {
      if (e.target.tagName !== "INPUT") return;
      const checkbox = e.target;
      const deckName = checkbox.value;
      const mode = Modes.current || Modes.practice;
      const q = mode.currentQuestion || mode.currentQuestion?.();
      const question = q || Modes.practice.currentQuestion;
      if (!question) return;
      if (checkbox.checked) Core.addToDeck(deckName, question.id);
      else Core.removeFromDeck(deckName, question.id);

      const deckSummaries = Core.getAllDeckSummaries();
      UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
      UI.updateDeckSummaryList(deckSummaries);
      UI.updateBookmarkButton(Core.isBookmarked(question.id));
      UI.updateActivePlaylistInfo(Core.state.filters.pool,
        deckSummaries.find(d => d.name === Core.getActiveDeckName()));
    });
  }

  function wireQuestionControls() {
    UI.els.optionsContainer.addEventListener("click", e => {
      const btn = e.target.closest(".option-btn");
      if (!btn) return;
      const idx = Number(btn.dataset.index);
      if (Modes.current === Modes.exam) {
        Modes.exam.handleAnswer(idx);
      } else if (Modes.current === Modes.lite) {
        Modes.lite.handleAnswer(idx);
      } else {
        Modes.practice.handleAnswer(idx);
      }
    });

    UI.els.nextBtn.addEventListener("click", () => {
      if (Modes.current === Modes.exam) {
        Modes.exam.goNext();
      } else if (Modes.current === Modes.lite) {
        Modes.lite.goNext();
      } else {
        handlePracticeNextClick();
      }
    });

    UI.els.prevQuestionBtn.addEventListener("click", () => {
      if (Modes.current === Modes.practice) Modes.practice.goPrevious();
    });

    UI.els.backLatestBtn.addEventListener("click", () => {
      if (Modes.current === Modes.practice) Modes.practice.goLatest();
    });

    UI.els.showExplanationBtn.addEventListener("click", () => {
      if (Modes.current === Modes.exam) return;
      if (Modes.current === Modes.lite) Modes.lite.toggleExplanation();
      else Modes.practice.toggleExplanation();
    });
  }

  function handlePracticeNextClick() {
    const pool = Core.getFilteredPool();
    const hasAny = pool && pool.length > 0;

    if (!hasAny) {
      // Deck is loaded but filters are too restrictive
      if (Core.state.questions.length > 0) {
        UI.setFeedback(
          "neutral",
          "No questions match the current filters. Adjust subjects, status, or playlist."
        );
      } else {
        // No questions at all
        UI.setFeedback(
          "neutral",
          "No questions loaded. Load a MedMCQA deck to begin."
        );
      }
      // Important: do NOT call showNext(); keep current question visible
      return;
    }

    // Normal behavior: advance to the next question from the filtered pool
    Modes.practice.showNext();
  }

  function wireTimedControls() {
    UI.els.startLiteBtn.addEventListener("click", async () => {
      if (Modes.current === Modes.exam && Modes.exam.state && Modes.exam.state.active) {
        await UI.alert("Finish or end the current NEET exam first.");
        return;
      }
      const count = parseInt(UI.els.liteCountInput.value, 10) || 50;
      if (Modes.lite.startSession(count)) {
        Modes.setCurrent("lite");
        Modes.lite.showCurrent();
      }
    });

    UI.els.pauseLiteBtn.addEventListener("click", () => {
      if (Modes.current === Modes.lite) Modes.lite.pauseOrResume();
    });

    UI.els.endLiteBtn.addEventListener("click", async () => {
      if (!Modes.lite.state || !Modes.lite.state.active) return;
      const confirmed = await UI.confirm("End Lite session now and see summary?");
      if (!confirmed) return;
      Modes.lite.finishSession();
    });

    UI.els.startExamBtn.addEventListener("click", async () => {
      if (Modes.current === Modes.lite && Modes.lite.state && Modes.lite.state.active) {
        await UI.alert("Finish or end the current Lite session first.");
        return;
      }
      if (Modes.exam.startSession()) {
        Modes.setCurrent("exam");
        Modes.exam.showCurrent();
      }
    });

    UI.els.endExamBtn.addEventListener("click", async () => {
      if (!Modes.exam.state || !Modes.exam.state.active) return;
      const confirmed = await UI.confirm("End NEET exam now and score based on current answers?");
      if (!confirmed) return;
      Modes.exam.finishAndScore();
    });
  }

  function wireExamOptions() {
    if (!UI.els.examUseWeightsToggle) return;

    // Initialize from Core state
    const useWeights = Core.getExamUseWeights();
    UI.els.examUseWeightsToggle.checked = useWeights;

    UI.els.examUseWeightsToggle.addEventListener("change", () => {
      Core.setExamUseWeights(UI.els.examUseWeightsToggle.checked);
    });
  }

  function wireStateImportExport() {
    UI.els.exportStateBtn.addEventListener("click", () => {
      const blob = new Blob([JSON.stringify(Core.state.appState, null, 2)], {
        type: "application/json"
      });
      const now = new Date();
      const y = now.getFullYear();
      const m = String(now.getMonth() + 1).padStart(2, "0");
      const d = String(now.getDate()).padStart(2, "0");
      const filename = `medmcqa_progress_${y}${m}${d}.json`;
      const url = URL.createObjectURL(blob);
      const a = document.createElement("a");
      a.href = url;
      a.download = filename;
      document.body.appendChild(a);
      a.click();
      a.remove();
      URL.revokeObjectURL(url);
    });

    UI.els.importStateBtn.addEventListener("click", () => {
      UI.els.importStateInput.click();
    });

    UI.els.importStateInput.addEventListener("change", e => {
      const file = e.target.files[0];
      if (!file) return;
      const reader = new FileReader();
      reader.onload = async evt => {
        try {
          const imported = JSON.parse(evt.target.result);
          if (!imported || typeof imported !== "object") {
            await UI.alert("Invalid progress file.");
            return;
          }
          Core.state.appState = imported;
          Core.ensurePlaylistsShape();
          Core.saveAppState();

          UI.updateLastDeckInfo(Core.state.appState.lastDeck || null);
          const deckSummaries = Core.getAllDeckSummaries();
          UI.updatePlaylistSelects(deckSummaries, Core.getActiveDeckName());
          UI.updateDeckSummaryList(deckSummaries);
          UI.updateActivePlaylistInfo(Core.state.filters.pool,
            deckSummaries.find(d => d.name === Core.getActiveDeckName()));
          UI.updateGlobalStats(Core.getGlobalStatsSummary());
          UI.updateProgressMini(Core.getProgressSummary());

          await UI.alert("Progress imported successfully.");
        } catch (err) {
          console.error("Failed to import progress:", err);
          await UI.alert("Could not import progress file.");
        }
      };
      reader.readAsText(file);
      UI.els.importStateInput.value = "";
    });

    UI.els.exportWeakBtn.addEventListener("click", async () => {
      const weakQuestions = Core.state.questions.filter(q =>
        Core.isWeak(Core.getStatsFor(q.id))
      );
      const payload = Core.exportQuestionsAsNDJSON(weakQuestions, "medmcqa_weak");
      if (!payload) {
        await UI.alert("No weak questions to export.");
        return;
      }
      triggerDownload(payload);
    });

    UI.els.exportBookmarkedBtn.addEventListener("click", async () => {
      const deck = Core.getDeck("Bookmarks");
      const set = new Set(deck.ids);
      const bookmarkedQuestions = Core.state.questions.filter(q => set.has(q.id));
      const payload = Core.exportQuestionsAsNDJSON(bookmarkedQuestions, "medmcqa_bookmarks");
      if (!payload) {
        await UI.alert("No bookmarked questions to export.");
        return;
      }
      triggerDownload(payload);
    });

    UI.els.exportDeckBtn.addEventListener("click", async () => {
      const name = UI.els.exportDeckSelect.value;
      if (!name) {
        await UI.alert("Select a deck to export.");
        return;
      }
      const deck = Core.getDeck(name);
      if (!deck || !deck.ids || deck.ids.length === 0) {
        await UI.alert(`Deck "${name}" has no questions.`);
        return;
      }
      const set = new Set(deck.ids);
      const qs = Core.state.questions.filter(q => set.has(q.id));
      const payload = Core.exportQuestionsAsNDJSON(
        qs,
        `medmcqa_deck_${name.replace(/\s+/g, "_")}`
      );
      if (!payload) {
        await UI.alert("No questions to export.");
        return;
      }
      triggerDownload(payload);
    });
  }

  function triggerDownload(payload) {
    const blob = new Blob([payload.text], { type: "application/json" });
    const url = URL.createObjectURL(blob);
    const a = document.createElement("a");
    a.href = url;
    a.download = payload.filename;
    document.body.appendChild(a);
    a.click();
    a.remove();
    URL.revokeObjectURL(url);
  }

  function onTick() {
    if (Modes.current === Modes.lite) Modes.lite.onTimerTick();
    else if (Modes.current === Modes.exam) Modes.exam.onTimerTick();
  }

  document.addEventListener("DOMContentLoaded", init);
})();