import { LisioBooleanParameterNames } from "@lisio/lisio-profils";

import { LisioMutationObserverController } from "../../controllers/lisio-mutation-observer-controller";
import { LisioParamsController } from "../../controllers/lisio-params-controller";
import LisioDocumentLanguageController from "../../controllers/lisio-document-language-controller";
import LisioMessageReceivedName from "../../enums/lisio-message-received-name";
import LisioMessageManager from "../../managers/lisio-message-manager";
import { isNonTextElement } from "../../utils/lisio-readable-dom";
import LisioTextTreeWalker from "../../walkers/lisio-text-tree-walker";
import LisioAdapter from "../lisio-adapter";
import LisioListAdapter from "../lisio-list-adapter";
import { createLogger } from "../../utils/debug";

const log = createLogger("translation");

/** Attributs de langue que la traduction remplace sur les balises traduites */
const LANG_ATTRIBUTES = ["lang", "xml:lang", "dir"] as const;

interface TranslatorObject {
  tags: HTMLElement[];
  text?: string;
}

type NodeTree = (TextNodeTree | TagNodeTree)[];

interface TextNodeTree{
  type : "text";
  value : string;
}

interface TagNodeTree{
  type : "tag";
  tag: string;
  value : string;
  children : NodeTree;
}

/** Balises de phrasé : placées côte à côte, elles forment une même phrase */
const INLINE_TAGS = new Set([
  "A", "ABBR", "B", "BDI", "BDO", "BR", "CITE", "CODE", "DATA", "DFN", "EM", "FONT", "I", "IMG", "KBD",
  "MARK", "Q", "S", "SAMP", "SMALL", "SPAN", "STRONG", "SUB", "SUP", "TIME", "U", "VAR", "WBR",
]);

function isInlineElement(element: Element): boolean {
  return INLINE_TAGS.has(element.tagName) || element instanceof SVGElement || isNonTextElement(element);
}

/**
 * Class representing a translator translation adapter extending an adapter.\
 * It aims to represents the font style functionality of Lisio.\
 * A translator translation adapter is basically a functionality of Lisio which will change the translation of texts (translator API) in the main page.\
 */
class LisioTranslatorTranslationAdapter extends LisioAdapter<string> {
  private _entries: Map<Element, IntersectionObserverEntry> = new Map<
    Element,
    IntersectionObserverEntry
  >();
  private _intersect?: IntersectionObserver;
  private _listAdapter?: LisioListAdapter;
  /** Langue dans laquelle la page est (ou est en train d'être) traduite */
  private _currentLang?: string;
  private _mutationController: LisioMutationObserverController;
  private _originLang?: string;
  private _originalTitle?: string;
  private _paramsController: LisioParamsController;
  /** Balises dont la traduction est en cours, avec la langue demandée */
  private _pendingTags = new WeakMap<Element, string>();
  private _sanitizedTexts: TranslatorObject[] = [];
  private _translatedTitles: Map<string, string> = new Map<string, string>();
  private _translatorAPIBoundedResponseHandlers: Map<
    string,
    (
      texts: [
        {
          translatedText: string;
          translateLangDTO: {
            languageISO: string;
            languageDirection: string;
          };
          originTextDTO: {
            originText: string;
          };
        },
      ],
    ) => void
  > = new Map<
    string,
    (
      texts: [
        {
          translatedText: string;
          translateLangDTO: {
            languageISO: string;
            languageDirection: string;
          };
          originTextDTO: {
            originText: string;
          };
        },
      ],
    ) => void
  >();
  private _translatorAPITimeout?: ReturnType<typeof setTimeout>;

  constructor(
    mutationController: LisioMutationObserverController,
    paramsController: LisioParamsController,
  ) {
    super();
    this._mutationController = mutationController;
    this._paramsController = paramsController;
  }

  public set listAdapter(value: LisioListAdapter) {
    this._listAdapter = value;
  }

  /**
   * Public method implementing abstract method adapt of Adapter
   * @param {LisioTextTreeWalker} walker - A walker to explore the DOM
   * @param {string} value - Value of the functionality
   * @returns Returns nothing
   * @source
   */
  public adapt(walker: LisioTextTreeWalker, value: string): void {
    const languageController = LisioDocumentLanguageController.current;
    value = value.replace(/_/g, "-");
    // Langue relue tant que la page n'est pas traduite : elle peut changer sans rechargement (SPA).
    // Seule la langue principale est gardée (en-US → EN), c'est le code source attendu par l'API.
    // Une page sans attribut lang est considérée comme française
    if (this._originLang == undefined || this._currentLang == undefined) {
      this._originLang =
        document.documentElement.lang.toUpperCase().split(/[-_]/)[0] || "FR";
    }
    if (value != "default" && value.split("-")[0] != this._originLang) {
      // Changement de langue sur une page déjà traduite : le texte d'origine est remis avant d'être
      // ré-extrait, pour ne jamais envoyer à la traduction un texte déjà traduit
      if (this._currentLang != undefined && this._currentLang !== value) {
        this.restoreOriginTexts();
      }
      this._currentLang = value;
      languageController.applyTranslatedLanguage(value);
      this._intersect?.disconnect();
      this._intersect = new IntersectionObserver(
        this.translatorAPIIntersectionCallback.bind(this, value),
        {
          rootMargin: "0px",
          threshold: 0.9,
        },
      );
      if (this._paramsController.params.has(LisioBooleanParameterNames.LIST)) {
        this._listAdapter?.prepareForTranslatorTrans(value);
      }
      this.observeTags(walker, value);
      this.translateDocumentTitle(value);
    } else if (
      value == "default" ||
      (this._originLang != undefined &&
        value.split("-")[0] === this._originLang)
    ) {
      this.restoreOriginTexts();
    }
  }

  /**
   * Remet le texte d'origine dans toutes les balises traduites et oublie les traductions en cours
   */
  private restoreOriginTexts() {
    this._currentLang = undefined;
    this._sanitizedTexts = [];
    this._pendingTags = new WeakMap();
    if (this._translatorAPITimeout) {
      clearTimeout(this._translatorAPITimeout);
    }
    if (this._intersect != undefined) {
      this._intersect.disconnect();
      this._intersect = undefined;
    }
    // Seules les balises dont Lisio a modifié le texte ou la langue sont remises :
    // les lang/dir posés par le site lui-même ne sont pas touchés
    const tagsToTranslate = [...document.querySelectorAll(
      "[lisio-original-text], [lisio-original-lang-attrs]",
    )].filter(tag=>tag.closest('.notranslate, [translate="no"]') == undefined);

    for (const tagToTranslate of tagsToTranslate) {
      if (tagToTranslate.hasAttribute("lisio-original-text")) {
        if(tagToTranslate instanceof HTMLInputElement){
          tagToTranslate.value = tagToTranslate.getAttribute("lisio-original-text") || "";
        }else if(tagToTranslate instanceof HTMLElement){
          this.insertText(tagToTranslate, tagToTranslate.getAttribute("lisio-original-text") || "" );
        }
      }
      tagToTranslate.removeAttribute("lisio-already-trans-in");
      this.restoreLangAttributes(tagToTranslate);
    }
    for(const transTag of document.querySelectorAll<HTMLElement>("[data-lisio-trans-tag]")){
      delete transTag.dataset.lisioTransTag;
    }
    this.restoreDocumentTitle();
    LisioDocumentLanguageController.current.restoreOriginalLanguage();
    this._entries = new Map();
    LisioMessageManager.current.detachHandler(
      LisioMessageReceivedName.TRANSLATOR_API_TRANSLATE_RESPONSE,
    );
    this._translatorAPIBoundedResponseHandlers.clear();
  }

  /**
   * Garde, avant que la traduction ne les remplace, les attributs lang / xml:lang / dir d'origine
   * d'une balise (null s'ils étaient absents). Seule la première sauvegarde compte.
   */
  private saveLangAttributes(tag: Element) {
    if (tag.hasAttribute("lisio-original-lang-attrs")) {
      return;
    }
    tag.setAttribute(
      "lisio-original-lang-attrs",
      JSON.stringify(
        LANG_ATTRIBUTES.map((attribute) => tag.getAttribute(attribute)),
      ),
    );
  }

  /**
   * Remet les attributs lang / xml:lang / dir d'origine d'une balise, ou les retire s'ils
   * n'existaient pas avant la traduction
   */
  private restoreLangAttributes(tag: Element) {
    const saved = tag.getAttribute("lisio-original-lang-attrs");
    if (saved == undefined) {
      return;
    }
    const values = JSON.parse(saved) as (string | null)[];
    for (const [index, attribute] of LANG_ATTRIBUTES.entries()) {
      const value = values[index];
      if (value == undefined) {
        tag.removeAttribute(attribute);
      } else {
        tag.setAttribute(attribute, value);
      }
    }
    tag.removeAttribute("lisio-original-lang-attrs");
  }

  private getOriginalTitle(): string {
    if (this._originalTitle == undefined) {
      this._originalTitle = document.title;
    }
    return this._originalTitle;
  }

  private restoreDocumentTitle(): void {
    if (this._originalTitle != undefined) {
      document.title = this._originalTitle;
    }
  }

  private translateDocumentTitle(lang: string): void {
    const originalTitle = this.getOriginalTitle().trim();
    if (originalTitle === "") {
      return;
    }

    const cachedTitle = this._translatedTitles.get(lang);
    if (cachedTitle != undefined) {
      document.title = cachedTitle;
      return;
    }

    const keyHandler = `title-${(+new Date()).toString(36).slice(-8)}`;
    this._translatorAPIBoundedResponseHandlers.set(keyHandler, (texts) => {
      const translatedTitle = texts[0]?.translatedText?.trim();
      if (translatedTitle == undefined || translatedTitle === "") {
        return;
      }

      this._translatedTitles.set(lang, translatedTitle);
      if (this._currentLang === lang) {
        document.title = translatedTitle;
      }
    });
    LisioMessageManager.current.sendTranslatorAPITranslate(
      keyHandler,
      this._originLang == undefined ? "fr" : this._originLang,
      lang,
      [originalTitle],
    );
  }

  private insertText(tagToTranslate: HTMLElement, translatedText: string){
    // const hasChildrenWithText = Array.from(tagToTranslate.children).some(child=>child.textContent?.trim() != "");
    // if(hasChildrenWithText){
    //   tagToTranslate.innerHTML = textTranslated;
    // }else if(tagToTranslate.textContent != undefined){
    //   tagToTranslate.textContent = textTranslated;
    // }
    const translatedTag = document.createElement("lisio-tpm");
    translatedTag.innerHTML = translatedText;
    this.translateOriginTag(tagToTranslate, translatedTag);
  }

  /* OLD FUNCTION 
  private translateOriginTag(tagToTranslate: HTMLElement, translatedTag: HTMLElement){
    const originChildren = [...tagToTranslate.childNodes].filter(child=>(child.nodeType === 3 && child.textContent?.trim() != "") || child.nodeType === 1);
    const translatedChildren = [...translatedTag.childNodes].filter(child=>(child.nodeType === 3 && child.textContent?.trim() != "") || child.nodeType === 1);
    for(const [i, child] of translatedChildren.entries()){
      if(originChildren[i] == undefined || originChildren[i].nodeType != child.nodeType || (originChildren[i] instanceof HTMLElement && child instanceof HTMLElement && originChildren[i].dataset.lisioTransTag != child.id)){
        if(child.nodeType === 1 && child instanceof HTMLElement){
          const closestTag = originChildren.findIndex((originChild, index)=>index > i && originChild.nodeType === child.nodeType && originChild instanceof HTMLElement && originChild.dataset.lisioTransTag == child.id);
          if(closestTag === -1){
            const existingTag = tagToTranslate.querySelector(`[data-lisio-trans-tag="${child.id}"]`);
            if(existingTag != undefined){
              const newTag = document.createElement(existingTag.tagName);
              newTag.dataset.lisioTransTag = child.id;
              if(i >= originChildren.length -1){
                tagToTranslate.append(newTag);
              }else{
                tagToTranslate.insertBefore(newTag, originChildren[i]);
              }
              originChildren.splice(i, 0, newTag);
            }
          }else{
            tagToTranslate.insertBefore(originChildren[closestTag], originChildren[i]);
            const originChild = originChildren.splice(closestTag, 1);
            originChildren.splice(i, 0, originChild[0]);
          }
        }else if(child.nodeType === 3){
          const closestText = originChildren.findIndex(((originChild, index)=>index > i && originChild.nodeType === child.nodeType));
          if(closestText === -1){
            const newText = document.createTextNode("");
            if(i >= originChildren.length -1){
              tagToTranslate.append(newText);
            }else{
              tagToTranslate.insertBefore(newText, originChildren[i]);
            }
            originChildren.splice(i, 0, newText);
          }else{
            tagToTranslate.insertBefore(originChildren[closestText], originChildren[i]);
            const originChild = originChildren.splice(closestText, 1);
            originChildren.splice(i, 0, originChild[0]);
          }
        }
      }
    }
    for(const [i, child] of translatedChildren.entries()){
      if(child.nodeType === 3 && child instanceof Text){
          originChildren[i].textContent = child.textContent;
      }else if(child.nodeType === 1 && child instanceof HTMLElement){
          const nextTagToTranslate = tagToTranslate.querySelector(`[data-lisio-trans-tag="${child.id}"]:not([data-lisio-trans-tag-translated])`);
          if(nextTagToTranslate instanceof HTMLElement){
            nextTagToTranslate.dataset.lisioTransTagTranslated = "true";
            this.translateOriginTag(nextTagToTranslate, child);
          }
      }
    }
    for(const child of [...tagToTranslate.querySelectorAll<HTMLElement>(`[data-lisio-trans-tag-translated]`)]){
      delete child.dataset.lisioTransTagTranslated;
    }
    for(let i = 0; i < originChildren.length; i++){
      if(i >= translatedChildren.length){
        originChildren[i].remove();
        originChildren.splice(i, 1);
      }
    }
  }*/

  private translateOriginTag(tagToTranslate: HTMLElement, translatedTag: HTMLElement) {
    const originChildren = [...tagToTranslate.childNodes].filter(
      child => (child.nodeType === 3 && child.textContent?.trim() !== "") || child.nodeType === 1
    );
    // Les espaces seuls entre deux balises de la traduction sont gardés : ils séparent les mots
    const translatedChildren = [...translatedTag.childNodes].filter(
      child => (child.nodeType === 3 && child.textContent !== "") || child.nodeType === 1
    );

    const initialOriginChildren = [...originChildren];
    const newOriginChildren: Node[] = [];

    for (const transChild of this.flattenUnknownTags(translatedChildren)) {
      if (transChild.nodeType === 3) {
        const translatedText = transChild.textContent ?? "";
        if (translatedText.trim() === "") {
          newOriginChildren.push(document.createTextNode(translatedText));
          continue;
        }
        const originTextIdx = originChildren.findIndex(c => c.nodeType === 3);

        let textNode: Text;
        if (originTextIdx !== -1) {
          textNode = originChildren.splice(originTextIdx, 1)[0] as Text;
        } else {
          textNode = document.createTextNode("");
        }

        // La traduction perd les espaces en bordure du texte (« vos </span><span>projets ») :
        // ceux du texte d'origine sont remis pour ne pas coller les mots des balises voisines
        const originText = textNode.textContent ?? "";
        const leading = /^\s/.test(translatedText) ? "" : (/^\s*/.exec(originText)?.[0] ?? "");
        const trailing = /\s$/.test(translatedText) ? "" : (/\s*$/.exec(originText)?.[0] ?? "");
        textNode.textContent = leading + translatedText + trailing;
        newOriginChildren.push(textNode);

      } else if (transChild.nodeType === 1 && transChild instanceof HTMLElement) {
        const originElemIdx = originChildren.findIndex(
          c => c.nodeType === 1 && c instanceof HTMLElement && c.dataset.lisioTransTag === transChild.id
        );

        let elemNode: HTMLElement;
        if (originElemIdx !== -1) {
          elemNode = originChildren.splice(originElemIdx, 1)[0] as HTMLElement;
        } else {
          const deepMatch = tagToTranslate.querySelector(`[data-lisio-trans-tag="${transChild.id}"]`);
          if (deepMatch instanceof HTMLElement) {
            elemNode = deepMatch;
            const idx = originChildren.indexOf(elemNode);
            if (idx !== -1) originChildren.splice(idx, 1);
          } else {
            elemNode = document.createElement(transChild.tagName);
            elemNode.dataset.lisioTransTag = transChild.id;
          }
        }
        this.translateOriginTag(elemNode, transChild);
        newOriginChildren.push(elemNode);
      }
    }
    // Les balises sans texte (icônes <i>, <img>, <svg>…) que la traduction a perdues et les balises non envoyées
    // à la traduction (<style>, <script>…) sont conservées à leur position d'origine
    for (const leftover of originChildren) {
      if (leftover instanceof Element && (leftover.textContent?.trim() === "" || isNonTextElement(leftover))) {
        const index = Math.min(initialOriginChildren.indexOf(leftover), newOriginChildren.length);
        newOriginChildren.splice(index, 0, leftover);
      }
    }
    tagToTranslate.replaceChildren(...newOriginChildren);
  }

  /**
   * Remplace les balises sans id renvoyées par la traduction (ex. un <meta> ajouté) par leurs enfants,
   * pour ne jamais créer dans la page une balise qui n'existait pas dans le texte d'origine
   */
  private flattenUnknownTags(children: ChildNode[]): ChildNode[] {
    return children.flatMap(child =>
      child instanceof HTMLElement && !child.id
        ? this.flattenUnknownTags(
            [...child.childNodes].filter(
              sub => (sub.nodeType === 3 && sub.textContent?.trim() !== "") || sub.nodeType === 1
            )
          )
        : [child]
    );
  }
  
  private extractText(sanitizedTag: HTMLElement){
    // const hasChildrenWithText = Array.from(sanitizedTag.children).some(child=>child.textContent != undefined && child.textContent.trim() != "");
    // if(hasChildrenWithText){
      //   return sanitizedTag.innerHTML.trim().replace(/\s{2,}/g, " ");
      // }else if(sanitizedTag.textContent != undefined){
        //   return sanitizedTag.textContent.trim().replace(/\s{2,}/g, " ");
        // }else{
          //   return "";
          // }
    // Compteurs partagés par toute la récursion pour que chaque balise ait un id unique
    const ids = { tagId: 0, oId: 0 };
    const tree: NodeTree = [];
    const filteredChildren = [...sanitizedTag.childNodes].filter(child=>(child.nodeType === 3 && child.textContent?.trim() != "") || child.nodeType === 1)
    this.exploreChilds(tree, filteredChildren, ids);
    const extractedTag = document.createElement("lisio-tmp");
    this.nodeTreeToHTMLTag(extractedTag, tree);
    return extractedTag.innerHTML.trim().replace(/(<br\sid="o\d+">)(?!\n)/g, "$1\n").replace(/(\w+)<(?!\/)/g, "$1 <");
  }

    private nodeTreeToHTMLTag(tag: HTMLElement, tree: NodeTree){
      for(const node of tree){
          if(node.type === "text"){
              const textNode = document.createTextNode(node.value);
              tag.appendChild(textNode);
          }else if(node.type === "tag"){
              const tmpTag = document.createElement(node.tag);
              tmpTag.id = node.value;
              tag.appendChild(tmpTag);
              this.nodeTreeToHTMLTag(tmpTag, node.children);
          }   
      }
  }

  private exploreChilds(tree: NodeTree, children: ChildNode[], ids: { tagId: number; oId: number }){
    for(const child of children){
        if(child.nodeType === 3 && child instanceof Text){
          const value = child.textContent?.replace(/\s{2,}/g, " ") || "";
            tree.push({type: "text", value});
        }else if(child.nodeType === 1 && child instanceof HTMLElement && !isNonTextElement(child)){
            const childrenOfChild = [...child.childNodes].filter(child=>(child.nodeType === 3 && child.textContent?.trim() != "") || child.nodeType === 1);
            const subtree: NodeTree = [];
            const node = {type: "tag", tag: child.tagName, value: `x${ids.tagId}`, children: subtree} as TagNodeTree;
            if(child instanceof HTMLBRElement){
              node.value = `o${ids.oId}`;
              ids.oId++;
            }else{
              ids.tagId++;
            }
            tree.push(node);
            child.dataset.lisioTransTag = node.value;
            this.exploreChilds(subtree, childrenOfChild, ids);
        }
    }
  }

  /**
   * Remonte d'une balise de phrasé (<span>, <strong>…) à son parent quand celui-ci ne contient que du phrasé
   * réparti entre plusieurs balises (ex. un <h1> fait de 3 <span>) : la phrase est traduite en une fois,
   * avec son contexte, au lieu de morceau par morceau
   */
  private getTranslationUnit(tag: HTMLElement): HTMLElement {
    let unit = tag;
    let parent = unit.parentElement;
    while (
      parent != undefined &&
      parent !== document.body &&
      INLINE_TAGS.has(unit.tagName) &&
      [...parent.childNodes].some(
        (sibling) => sibling !== unit && !(sibling instanceof Element && isNonTextElement(sibling)) && sibling.textContent?.trim() !== ""
      ) &&
      [...parent.querySelectorAll("*")].every(isInlineElement) &&
      parent.querySelector('[translate="no"], .notranslate') == undefined
    ) {
      unit = parent;
      parent = unit.parentElement;
    }
    return unit;
  }

  public observeTags(walker: LisioTextTreeWalker, value: string) {
     const tags = Array.from(walker.tags.values()).filter(
      (tag) =>
        tag.hasAttribute("data-lisio-index") && tag.getAttribute("translate") != "no" && !tag.classList.contains("notranslate") && tag.closest<HTMLElement>('[translate="no"], .notranslate') == undefined
    ).map((tag) => this.getTranslationUnit(tag)).filter(
      // Une balise traduite avec sa balise parente contient déjà la traduction : son texte n'est pas celui d'origine
      (tag) => tag.dataset.lisioTransTag == undefined || tag.parentElement?.closest("[lisio-already-trans-in]") == undefined
    );
    const sanitizedTags = new Set(
      tags.concat(
        Array.from(
          document.querySelectorAll(
            'input[type="submit"], input[type="reset"]',
          ),
        ),
      ),
    );
    for (const sanitizedTag of sanitizedTags) {
      const alreadyTradLang = sanitizedTag.getAttribute(
        "lisio-already-trans-in",
      );
      const innerHTML = alreadyTradLang
        ? sanitizedTag.getAttribute("lisio-original-text")
        : sanitizedTag instanceof HTMLInputElement
          ? sanitizedTag.value.trim()
          : this.extractText(sanitizedTag);
      if (innerHTML != undefined && /[a-zA-Z]+/.test(innerHTML)) {
        // Une ré-application (mutations de la page pendant le chargement) ne renvoie pas une traduction déjà en cours
        if (alreadyTradLang != value && this._pendingTags.get(sanitizedTag) != value) {
          const find = this._sanitizedTexts.find(
            (obj) => obj.text === innerHTML,
          );
          if (find) {
            if (!find.tags.includes(sanitizedTag)) {
              find.tags.push(sanitizedTag);
            }
          } else {
            this._sanitizedTexts.push({
              text: innerHTML,
              tags: [sanitizedTag],
            });
          }
          if (sanitizedTag.localName === "option") {
            // Une <option> hors <select> (ex. dans un <datalist>) n'est pas affichée : rien à observer
            const select = sanitizedTag.closest("select");
            if (select != undefined) {
              this._intersect?.unobserve(select);
              this._intersect?.observe(select);
            }
          } else {
            this._intersect?.observe(sanitizedTag);
          }
        }
      }
    }

    LisioMessageManager.current.attachHandler(
      LisioMessageReceivedName.TRANSLATOR_API_TRANSLATE_RESPONSE,
      this.translatorAPIResponseHandler.bind(this),
    );
  }

  protected adaptFunction(element: HTMLElement, value: string): void {
    if (element instanceof HTMLInputElement) {
      element.value = value;
    } else {
      this.insertText(element, value);
    }
  }

  private translatorAPIIntersectionCallback(
    this: LisioTranslatorTranslationAdapter,
    lang: string,
    entries: IntersectionObserverEntry[],
  ) {
    if (this._translatorAPITimeout) {
      clearTimeout(this._translatorAPITimeout);
    }
    for (const entry of entries) {
      if (Math.round(entry.intersectionRatio) == 1) {
        this._entries.set(entry.target, entry);
      } else if (Math.round(entry.intersectionRatio) == 0) {
        this._entries.delete(entry.target);
      }
    }
    if (this._entries.size) {
      this._translatorAPITimeout = setTimeout(() => {
        let textsToSend: TranslatorObject[] = [];
        for (const entry of this._entries.values()) {
          // REMOVE CONDITION IF TO TRANSLATE LABEL WITH INPUT
          // const hasInput = entry.target.querySelector("input") != undefined;
          //if(!hasInput || (hasInput && Array.from(entry.target.childNodes).filter(node => node.nodeType === 3 && node.textContent?.trim() != "").length === 0)){
            // La cible elle-même (balise indexée ou parent regroupant des balises de phrasé)
            // ou les balises indexées qu'elle contient (<option> d'un <select>) : seules celles à traduire sont envoyées
            const tags = new Set<HTMLElement>(
              entry.target.querySelectorAll<HTMLElement>("[data-lisio-index]"),
            );
            if (entry.target instanceof HTMLElement) {
              tags.add(entry.target);
            }

            //const all = [];
            for (const tag of tags) {
              this._intersect?.unobserve(tag);
              const already = textsToSend.find((text) => text.tags.includes(tag));
              const toSend = this._sanitizedTexts.find((text) =>
                text.tags.includes(tag),
              );
              if (!already && toSend != undefined) {
                //all.push(this.sanitizedTexts.find(text => text.tags.includes(tag)));
                textsToSend.push(toSend);
              }
            }
          //}
          //textsToSend = this.textsToSend.concat(all);
        }
        //this.textsToSend = this.textsToSend.filter(textToSend => textToSend);
        textsToSend = textsToSend.filter((textToSend) => textToSend);
        this._entries.clear();
        if(textsToSend.length > 0){
          const pendingTags = textsToSend.flatMap((t) => t.tags);
          for (const tag of pendingTags) {
            this._pendingTags.set(tag, lang);
          }
          const keyHandler = (+new Date()).toString(36).slice(-8);
          LisioMessageManager.current.sendTranslatorAPITranslate(
            keyHandler,
            this._originLang == undefined ? "fr" : this._originLang,
            lang,
            textsToSend.map((t) => t.text).filter((text) => text != undefined),
          );
          this._translatorAPIBoundedResponseHandlers.set(
            keyHandler,
            (
              texts: [
                {
                  translatedText: string;
                  translateLangDTO: {
                    languageISO: string;
                    languageDirection: string;
                  };
                  originTextDTO: {
                    originText: string;
                  };
                },
              ],
            ) => {
              try {
                this.translatorAPIResponse(textsToSend, texts);
              } finally {
                for (const tag of pendingTags) {
                  this._pendingTags.delete(tag);
                }
              }
            },
          );
        }
      }, 250);
    }
  }

  private translatorAPIResponse(
    originTexts: TranslatorObject[],
    texts: [
      {
        translatedText: string;
        translateLangDTO: {
          languageISO: string;
          languageDirection: string;
        };
        originTextDTO: {
          originText: string;
        };
      },
    ],
  ) {
    const textObjs = texts;
    if (originTexts.length != textObjs.length) {
      throw new Error("not same size");
    }
    this._mutationController.disconnectObserver();
    for (const [index, textObj] of textObjs.entries()) {
      for (const tag of originTexts[index].tags) {
        this.adaptFunction(tag, textObj.translatedText);
        tag.setAttribute(
          "lisio-already-trans-in",
          textObj.translateLangDTO.languageISO,
        );
        if (!tag.getAttribute("lisio-original-text")) {
          tag.setAttribute(
            "lisio-original-text",
            textObj.originTextDTO.originText,
          );
        }
        this.saveLangAttributes(tag);
        tag.setAttribute("lang", textObj.translateLangDTO.languageISO);
        tag.setAttribute("xml:lang", textObj.translateLangDTO.languageISO);
        tag.setAttribute("dir", textObj.translateLangDTO.languageDirection);
        const closestUl = tag.closest("ul:not([dir])");
        if (closestUl != undefined) {
          this.saveLangAttributes(closestUl);
          closestUl.setAttribute(
            "dir",
            textObj.translateLangDTO.languageDirection,
          );
        }
      }
    }
  }

  private translatorAPIResponseHandler(
    this: LisioTranslatorTranslationAdapter,
    datas: string,
  ) {
    const {
      keyHandler,
      texts,
    }: {
      keyHandler: string;
      texts: [
        {
          translatedText: string;
          translateLangDTO: {
            languageISO: string;
            languageDirection: string;
          };
          originTextDTO: {
            originText: string;
          };
        },
      ];
    } = JSON.parse(datas);
    const handler = this._translatorAPIBoundedResponseHandlers.get(keyHandler);
    if (handler != undefined) {
      try {
        handler(texts);
      } catch (err) {
        log.log(err);
      } finally {
        this._translatorAPIBoundedResponseHandlers.delete(keyHandler);
        if (this._translatorAPIBoundedResponseHandlers.size === 0) {
          this._mutationController.connectObserver();
        }
      }
    }
  }
}

export default LisioTranslatorTranslationAdapter;
