/**
 * Défilement de la page hôte vers l'élément source d'un bloc du mode lecture
 * (BCMS_SCROLL_TO). Module pur (DOM seulement), testé sans le reste de Lisio.
 */

const SCROLLABLE_OVERFLOWS = new Set(["auto", "scroll", "overlay"]);
// Un en-tête couvre au moins la moitié de la largeur de la fenêtre…
const HEADER_MIN_WIDTH_RATIO = 0.5;
// …et au plus la moitié de sa hauteur : au-delà, c'est une bannière, une
// popup ou un préchargeur plein écran, pas un en-tête.
const HEADER_MAX_HEIGHT_RATIO = 0.5;
// En-têtes empilés (bandeau d'infos puis menu…) examinés au plus.
const MAX_STACKED_HEADERS = 5;
const PROBE_X_RATIOS = [0.25, 0.5, 0.75];
const SCROLL_END_TIMEOUT = 1000;

/** Ancêtre (ou l'élément) en `position: fixed|sticky`, hors interface de Lisio. */
function findFixedAncestor(element: Element): Element | undefined {
  for (
    let current: Element | null = element;
    current != undefined && current !== element.ownerDocument.documentElement;
    current = current.parentElement
  ) {
    if (current.id === "lisio-shadow-env") {
      return undefined;
    }
    const { position } = getComputedStyle(current);
    if (position === "fixed" || position === "sticky") {
      return current;
    }
  }
  return undefined;
}

/** Bas de l'en-tête fixe le plus bas qui recouvre la ligne `y` de la fenêtre (0 sinon). */
function getFixedBottomAt(doc: Document, y: number): number {
  const width = doc.documentElement.clientWidth;
  const maxHeight =
    (doc.defaultView?.innerHeight ?? 0) * HEADER_MAX_HEIGHT_RATIO;
  const checked = new Set<Element>();
  let bottom = 0;
  for (const ratio of PROBE_X_RATIOS) {
    for (const hit of doc.elementsFromPoint(width * ratio, y)) {
      const fixed = findFixedAncestor(hit);
      if (fixed == undefined || checked.has(fixed)) {
        continue;
      }
      checked.add(fixed);
      const rect = fixed.getBoundingClientRect();
      if (
        rect.top <= y &&
        rect.bottom > y &&
        rect.width >= width * HEADER_MIN_WIDTH_RATIO &&
        rect.height <= maxHeight
      ) {
        bottom = Math.max(bottom, rect.bottom);
      }
    }
  }
  return bottom;
}

/**
 * Hauteur cachée en haut de la fenêtre par les en-têtes `fixed`/`sticky` de
 * la page (`scrollIntoView` ne la retire que si le site définit
 * `scroll-padding-top`, ce qui est rare).
 */
export function getFixedTopOffset(doc: Document = document): number {
  let offset = 0;
  for (let i = 0; i < MAX_STACKED_HEADERS; i++) {
    // Juste sous l'en-tête précédent : un menu fixe placé sous un bandeau fixe.
    const bottom = getFixedBottomAt(doc, offset + 1);
    if (bottom <= offset) {
      break;
    }
    offset = bottom;
  }
  return offset;
}

/**
 * Ancêtres qui défilent verticalement autour de l'élément, du plus proche au
 * plus lointain, la page exclue (ex. `#app { overflow-y: auto }` d'une SPA).
 */
function findVerticalScrollers(element: Element): Element[] {
  const doc = element.ownerDocument;
  const scrollers: Element[] = [];
  for (
    let parent = element.parentElement;
    parent != undefined &&
    parent !== doc.body &&
    parent !== doc.documentElement;
    parent = parent.parentElement
  ) {
    if (
      SCROLLABLE_OVERFLOWS.has(getComputedStyle(parent).overflowY) &&
      parent.scrollHeight > parent.clientHeight
    ) {
      scrollers.push(parent);
    }
  }
  return scrollers;
}

/**
 * L'élément, ou son plus proche ancêtre affiché. Un élément sans boîte
 * (diapositive de carrousel masquée, accordéon fermé) ou réduit à 1 px
 * (texte sr-only) ne peut pas être atteint : on vise ce qui l'entoure.
 */
export function findVisibleTarget(element: Element): Element | undefined {
  for (
    let current: Element | null = element;
    current != undefined;
    current = current.parentElement
  ) {
    const rect = current.getBoundingClientRect();
    if (rect.width > 1 && rect.height > 1) {
      return current;
    }
  }
  return undefined;
}

/**
 * Amène en haut de la zone visible (sous les en-têtes fixes) le point de
 * l'élément situé à `ratio` de sa hauteur (0 : son haut, 0,5 : son milieu…).
 * Verticalement seulement : contrairement à `scrollIntoView`, ne fait jamais
 * défiler un carrousel (`overflow: hidden`) horizontalement.
 */
export function scrollElementToTop(
  element: Element,
  ratio = 0,
  behavior: ScrollBehavior = "smooth",
) {
  const doc = element.ownerDocument;
  // L'élément est placé sous les en-têtes fixes, pas dessous.
  const headerBottom = getFixedTopOffset(doc);
  const rect = element.getBoundingClientRect();
  let top = rect.top + rect.height * ratio;
  for (const scroller of findVerticalScrollers(element)) {
    const alignTop = Math.max(
      scroller.getBoundingClientRect().top + scroller.clientTop,
      headerBottom,
    );
    scroller.scrollBy({ top: top - alignTop, behavior });
    // Une fois ce conteneur défilé, l'élément est à cette hauteur.
    top = alignTop;
  }
  doc.defaultView?.scrollBy({ top: top - headerBottom, behavior });
}

/**
 * Appelle `callback` à la fin du défilement (`scrollend` de la page ou d'un
 * conteneur), ou après `timeout` ms si le navigateur ne le gère pas (Safari).
 * @returns une fonction qui annule l'attente
 */
export function afterScrollEnd(
  view: Window,
  callback: () => void,
  timeout = SCROLL_END_TIMEOUT,
): () => void {
  const cancel = () => {
    clearTimeout(timer);
    // `scrollend` ne remonte pas : écouté en capture pour les conteneurs.
    view.removeEventListener("scrollend", done, true);
  };
  const done = () => {
    cancel();
    callback();
  };
  view.addEventListener("scrollend", done, true);
  const timer = setTimeout(done, timeout);
  return cancel;
}

/**
 * Bloc lu en haut de la page hôte (sous ses en-têtes fixes), pour ouvrir la
 * liseuse au même endroit : le plus petit élément source traversé par le haut
 * de la zone visible (un item de liste plutôt que toute la liste), sinon le
 * premier en dessous. `ratio` : position du haut de la zone visible dans ce
 * bloc (0 à 1). `undefined` si aucun élément source n'est affiché.
 * @param {Element[]} anchors - éléments source, indexés par leur ancre `a`
 */
export function findTopmostAnchor(
  anchors: Element[],
  doc: Document = document,
): { a: number; ratio: number } | undefined {
  const top = getFixedTopOffset(doc);
  const width = doc.documentElement.clientWidth;
  let crossing: { a: number; rect: DOMRect } | undefined;
  let below: { a: number; rect: DOMRect } | undefined;
  let last: { a: number; rect: DOMRect } | undefined;
  anchors.forEach((element, a) => {
    if (!element.isConnected) {
      return;
    }
    const rect = element.getBoundingClientRect();
    // Sans boîte (sr-only, masqué) ou hors de l'écran (diapositive de carrousel).
    if (
      rect.width <= 1 ||
      rect.height <= 1 ||
      rect.right <= 0 ||
      rect.left >= width
    ) {
      return;
    }
    if (last == undefined || rect.bottom > last.rect.bottom) {
      last = { a, rect };
    }
    if (rect.bottom <= top) {
      return;
    }
    if (rect.top <= top + 1) {
      if (crossing == undefined || rect.height < crossing.rect.height) {
        crossing = { a, rect };
      }
    } else if (below == undefined || rect.top < below.rect.top) {
      below = { a, rect };
    }
  });
  if (crossing != undefined) {
    const { a, rect } = crossing;
    return {
      a,
      ratio: Math.min(1, Math.max(0, (top - rect.top) / rect.height)),
    };
  }
  if (below != undefined) {
    return { a: below.a, ratio: 0 };
  }
  // Page défilée au-delà du contenu extrait (footer) : fin de la liseuse.
  return last == undefined ? undefined : { a: last.a, ratio: 1 };
}
