content.js

(() => {
  "use strict";

  const BADGE_ID = "udemy-progress-percent-badge";
  const POPOVER_LINE_ID = "udemy-progress-percent-line";
  const UPDATE_DEBOUNCE_MS = 200;

  const COUNTS_REGEX = /(\d+)\s*\/\s*(\d+)/g;
  const PERCENT_REGEX = /(\d{1,3})(?:[.,](\d+))?\s*%/g;

  let lastKnownCounts = null;

  function normalizeText(value) {
    if (!value) return "";
    return value
      .normalize("NFKD")
      .replace(/[\u0300-\u036f]/g, "")
      .toLowerCase();
  }

  function isVisibleElement(element) {
    if (!(element instanceof Element)) return false;
    const style = window.getComputedStyle(element);
    if (style.display === "none" || style.visibility === "hidden") return false;
    const rect = element.getBoundingClientRect();
    return rect.width > 0 && rect.height > 0;
  }

  function extractAllCountsFromText(text) {
    if (!text) return [];
    const matches = [];
    let match;
    COUNTS_REGEX.lastIndex = 0;
    // eslint-disable-next-line no-cond-assign
    while ((match = COUNTS_REGEX.exec(text))) {
      const done = Number.parseInt(match[1], 10);
      const total = Number.parseInt(match[2], 10);
      if (!Number.isFinite(done) || !Number.isFinite(total)) continue;
      if (total <= 0) continue;
      if (done < 0 || done > total) continue;
      matches.push({ done, total });
    }
    return matches;
  }

  function extractAllPercentsFromText(text) {
    if (!text) return [];
    const percents = [];
    let match;
    PERCENT_REGEX.lastIndex = 0;
    // eslint-disable-next-line no-cond-assign
    while ((match = PERCENT_REGEX.exec(text))) {
      const whole = match[1];
      const decimal = match[2] || "";
      const normalized = decimal ? `${whole}.${decimal}` : whole;
      const value = Number.parseFloat(normalized);
      if (!Number.isFinite(value)) continue;
      if (value < 0 || value > 100) continue;
      percents.push(value);
    }
    return percents;
  }

  function extractCountsByLine(text) {
    if (!text) return [];
    const lines = text.split(/\n+/g);
    const results = [];
    for (const line of lines) {
      const matches = extractAllCountsFromText(line);
      if (matches.length === 1) results.push(matches[0]);
    }
    return results;
  }

  function sumCounts(pairs) {
    let done = 0;
    let total = 0;
    for (const p of pairs) {
      done += p.done;
      total += p.total;
    }
    if (total <= 0) return null;
    if (done < 0 || done > total) return null;
    return { done, total };
  }

  function findPercentNearAnchor(anchor) {
    if (!anchor) return null;

    const candidateTexts = [];
    candidateTexts.push(anchor.innerText || anchor.textContent || "");

    if (anchor.nextElementSibling) {
      candidateTexts.push(anchor.nextElementSibling.innerText || anchor.nextElementSibling.textContent || "");
    }
    if (anchor.previousElementSibling) {
      candidateTexts.push(anchor.previousElementSibling.innerText || anchor.previousElementSibling.textContent || "");
    }

    let current = anchor.parentElement;
    for (let i = 0; i < 3 && current; i += 1) {
      candidateTexts.push(current.innerText || current.textContent || "");
      current = current.parentElement;
    }

    const allValues = [];
    for (const text of candidateTexts) allValues.push(...extractAllPercentsFromText(text));
    if (allValues.length === 0) return null;

    const nonZero = allValues.filter((v) => v > 0);
    if (nonZero.length > 0) return Math.max(...nonZero);
    return allValues[0];

    return null;
  }

  function findCurriculumContainer() {
    const keywords = ["kurs icerigi", "course content"];
    const candidates = Array.from(document.querySelectorAll("h1,h2,h3,h4,div,span,button,a"));

    const scored = [];
    for (const el of candidates) {
      if (!isVisibleElement(el)) continue;
      const text = normalizeText(el.textContent || "");
      if (!keywords.some((k) => text.includes(k))) continue;

      const rect = el.getBoundingClientRect();
      const topWeight = rect.top >= 0 && rect.top <= 700 ? 2 : 0;
      const score = 5 + topWeight;
      scored.push({ el, score });
    }

    scored.sort((a, b) => b.score - a.score);
    const hit = scored[0]?.el || null;
    if (!hit) {
      return (
        document.querySelector("[data-purpose*='curriculum']") ||
        document.querySelector("[data-testid*='curriculum']") ||
        document.querySelector("[class*='curriculum']") ||
        null
      );
    }

    return (
      hit.closest(
        "aside, [role='complementary'], [data-purpose*='curriculum'], [data-testid*='curriculum'], [class*='curriculum'], [class*='sidebar']"
      ) ||
      hit.parentElement ||
      null
    );
  }

  function findCountsFromCurriculum() {
    const container = findCurriculumContainer();
    if (!container) return null;

    const pairs = extractCountsByLine(container.innerText || "");
    if (pairs.length < 2) return null;

    const maxTotal = Math.max(...pairs.map((p) => p.total));
    const summed = sumCounts(pairs);
    if (!summed) return null;
    if (summed.total <= maxTotal) return null;
    if (summed.total > 5000) return null;

    return { ...summed, source: { curriculum: container } };
  }

  function findBadgeInsertionTarget(anchor) {
    if (!anchor) return null;
    const siblingCandidates = [];
    if (anchor.nextElementSibling) siblingCandidates.push(anchor.nextElementSibling);
    if (anchor.previousElementSibling) siblingCandidates.push(anchor.previousElementSibling);

    const parent = anchor.parentElement;
    if (parent) {
      for (const child of Array.from(parent.children).slice(0, 10)) siblingCandidates.push(child);
    }

    for (const el of siblingCandidates) {
      if (!(el instanceof Element)) continue;
      if (!isVisibleElement(el)) continue;
      const text = (el.textContent || "").trim();
      if (/^\d{1,3}%$/.test(text)) return el;
    }

    return anchor;
  }

  function chooseBestCounts(matches) {
    if (!matches || matches.length === 0) return null;
    const sorted = matches
      .slice()
      .sort((a, b) => (b.total - a.total) || (b.done - a.done));
    return sorted[0] || null;
  }

  function computePercents(done, total) {
    const percent = (done / total) * 100;
    const roundedPercent = Math.round(percent);
    const exactPercent = Math.round(percent * 100) / 100;
    return { percent, roundedPercent, exactPercent };
  }

  function findProgressAnchor() {
    const keywords = ["ilerleme", "progress"];
    const candidates = Array.from(
      document.querySelectorAll(
        "button, [role='button'], a, [aria-label], [data-purpose], [data-testid]"
      )
    );

    const scored = [];
    for (const el of candidates) {
      if (!isVisibleElement(el)) continue;
      const text = normalizeText(el.textContent || "") + " " + normalizeText(el.getAttribute("aria-label") || "");
      if (!text) continue;
      if (!keywords.some((k) => text.includes(k))) continue;

      const rect = el.getBoundingClientRect();
      const topWeight = rect.top >= 0 && rect.top <= 500 ? 2 : 0;
      const lengthPenalty = Math.min(2, Math.floor((text.length || 0) / 80));
      const score = 5 + topWeight - lengthPenalty;
      scored.push({ el, score });
    }

    scored.sort((a, b) => b.score - a.score);
    return scored[0]?.el || null;
  }

  function findVisiblePopover() {
    const popoverCandidates = Array.from(
      document.querySelectorAll(
        "[role='dialog'], [role='tooltip'], [aria-modal='true'], [class*='popover'], [class*='tooltip'], [data-purpose*='popover'], [data-purpose*='tooltip']"
      )
    );

    const visible = popoverCandidates.filter((el) => isVisibleElement(el));
    if (visible.length === 0) return null;

    const withCounts = [];
    for (const el of visible) {
      const counts = extractAllCountsFromText(el.innerText || "");
      if (counts.length === 0) continue;
      // Prefer the smallest popover that contains counts (more specific).
      const rect = el.getBoundingClientRect();
      const area = rect.width * rect.height;
      withCounts.push({ el, area });
    }

    withCounts.sort((a, b) => a.area - b.area);
    return withCounts[0]?.el || null;
  }

  function findProgressCounts() {
    // 1) Prefer counts from a visible popover/tooltip.
    const popover = findVisiblePopover();
    if (popover) {
      const best = chooseBestCounts(extractAllCountsFromText(popover.innerText || ""));
      if (best) return { ...best, source: { popover } };
    }

    // 2) Try near the progress anchor/area.
    const anchor = findProgressAnchor();
    if (anchor) {
      const nearTexts = [];
      let current = anchor;
      for (let i = 0; i < 4 && current; i += 1) {
        if (current instanceof Element) {
          nearTexts.push(current.innerText || current.textContent || "");
        }
        current = current.parentElement;
      }

      for (const text of nearTexts) {
        const best = chooseBestCounts(extractAllCountsFromText(text));
        if (best) return { ...best, source: { anchor } };
      }
    }

    // 3) If Udemy lazy-loads overall progress, derive it from curriculum section counts.
    const fromCurriculum = findCountsFromCurriculum();
    if (fromCurriculum) return fromCurriculum;

    return null;
  }

  function upsertBadge(anchor, percents, counts) {
    if (!anchor) return;

    let badge = document.getElementById(BADGE_ID);
    if (!badge) {
      badge = document.createElement("span");
      badge.id = BADGE_ID;
      badge.setAttribute("role", "status");
      badge.setAttribute("aria-live", "polite");
    }

    anchor.insertAdjacentElement("afterend", badge);

    badge.textContent = `${percents.roundedPercent}%`;
    badge.title = counts
      ? `${percents.exactPercent.toFixed(2)}% (${counts.done}/${counts.total})`
      : `${percents.exactPercent.toFixed(2)}% (detay icin ilerlemeyi acin)`;
  }

  function upsertPopoverLine(percents, counts) {
    const popover = findVisiblePopover();
    if (!popover) return;

    let line = popover.querySelector(`#${POPOVER_LINE_ID}`);
    if (!line) {
      line = document.createElement("div");
      line.id = POPOVER_LINE_ID;
      popover.appendChild(line);
    }

    line.textContent = `\u0130lerleme: %${percents.exactPercent.toFixed(2)} (${counts.done}/${counts.total})`;
  }

  function updateUi() {
    const found = findProgressCounts();
    const anchor = found?.source?.anchor || findProgressAnchor();
    const insertionTarget = findBadgeInsertionTarget(anchor);

    if (found) {
      const { done, total } = found;
      const percents = computePercents(done, total);
      lastKnownCounts = { done, total };
      upsertBadge(insertionTarget, percents, { done, total });
      upsertPopoverLine(percents, { done, total });
      return;
    }

    if (lastKnownCounts) {
      const percents = computePercents(lastKnownCounts.done, lastKnownCounts.total);
      upsertBadge(insertionTarget, percents, lastKnownCounts);
      return;
    }

    const headerPercent = findPercentNearAnchor(anchor);
    if (headerPercent == null) return;
    if (headerPercent === 0) return;
    const percents = {
      percent: headerPercent,
      roundedPercent: Math.round(headerPercent),
      exactPercent: Math.round(headerPercent * 100) / 100
    };
    upsertBadge(insertionTarget, percents, null);
  }

  function observeDomChanges() {
    let scheduled = null;
    const scheduleUpdate = () => {
      if (scheduled) window.clearTimeout(scheduled);
      scheduled = window.setTimeout(() => {
        scheduled = null;
        try {
          updateUi();
        } catch {
          // Defensive: never throw into the page / console.
        }
      }, UPDATE_DEBOUNCE_MS);
    };

    const observer = new MutationObserver(() => scheduleUpdate());
    observer.observe(document.body, { subtree: true, childList: true, characterData: true });

    // Initial run + a delayed run for late-rendered SPA content.
    scheduleUpdate();
    window.setTimeout(scheduleUpdate, 800);
  }

  function main() {
    if (!document.body) return;
    observeDomChanges();
  }

  if (document.readyState === "loading") {
    document.addEventListener("DOMContentLoaded", main, { once: true });
  } else {
    main();
  }
})();