/**
 * Extend the base Dialog entity by defining a custom window to perform spell.
 * @extends {Dialog}
 */
import { RollDataAjustements } from "./rolldata-ajustements.js";
import { RdDUtility } from "./rdd-utility.js";
import { poesieCaseHumide, TMRUtility } from "./tmr-utility.js";
import { tmrConstants } from "./tmr-utility.js";
import { RdDResolutionTable } from "./rdd-resolution-table.js";
import { RdDTMRRencontreDialog } from "./rdd-tmr-rencontre-dialog.js";
import { TMRRencontres } from "./tmr-rencontres.js";
import { ChatUtility } from "./chat-utility.js";
import { RdDRoll } from "./rdd-roll.js";


/* -------------------------------------------- */
export class RdDTMRDialog extends Dialog {

  /* -------------------------------------------- */
  constructor(html, actor, tmrData, mode) {
    const dialogConf = {
      title: "Terres Médianes de Rêve",
      content: html,
      buttons: {
        closeButton: { label: "Fermer", callback: html => this.close(html) }
      },
      default: "closeButton"
    }

    const dialogOptions = {
      classes: ["tmrdialog"],
      width: 920, height: 980,
      'z-index': 20
    }
    super(dialogConf, dialogOptions);

    this.tmrdata = duplicate(tmrData);
    this.actor = actor;
    this.actor.tmrApp = this; // reference this app in the actor structure
    this.viewOnly = mode == "visu"
    this.fatigueParCase = this.viewOnly ? 0 : this.actor.getTMRFatigue();
    this.cumulFatigue = 0;
    this.rencontresExistantes = duplicate(this.actor.data.data.reve.rencontre.list);
    this.sortReserves = duplicate(this.actor.data.data.reve.reserve.list);
    this.casesSpeciales = this.actor.data.items.filter(item => item.type == 'casetmr');
    this.allTokens = [];
    this.rencontreState = 'aucune';
    this.pixiApp = new PIXI.Application({ width: 720, height: 860 });
    if (!this.viewOnly) {
      this.actor.setStatusDemiReve(true);
      this._tellToGM(this.actor.name + " monte dans les terres médianes (" + mode + ")");
    }
  }

  /* -------------------------------------------- */
  close() {
    this.actor.santeIncDec("fatigue", this.cumulFatigue).then(super.close()); // moving 1 cell costs 1 fatigue
    this.actor.tmrApp = undefined; // Cleanup reference
    this.actor.setStatusDemiReve(false);
    if (!this.viewOnly) {
      this._tellToGM(this.actor.name + " a quitté les terres médianes");
    }
  }

  /* -------------------------------------------- */
  displaySortReserve() {
    console.debug("displaySortReserve", this.sortReserves);
    for (let sort of this.sortReserves) {
      this._trackToken(this._tokenSortEnReserve(sort));
    }
  }

  /* -------------------------------------------- */
  displaySpecificCase() {
    for (let caseSpeciale of this.casesSpeciales) {
      console.log("SPEC CASE ", caseSpeciale);
      if (caseSpeciale.data.specific == 'trounoir') {
        this._trackToken(this._tokenTrouNoir(caseSpeciale.data.coord));
      } else if (caseSpeciale.data.specific == 'attache') {
        this._trackToken(this._tokenTerreAttache(caseSpeciale.data.coord));
      } else if (caseSpeciale.data.specific == 'debordement') {
        this._trackToken(this._tokenDebordement(caseSpeciale.data.coord));
      } else if (caseSpeciale.data.specific == 'maitrisee') {
        this._trackToken(this._tokenMaitrisee(caseSpeciale.data.coord));
      }
    }
  }

  /* -------------------------------------------- */
  displayPreviousRencontres() {
    console.debug("displayPreviousRencontres", this.rencontresExistantes);
    for (let rencontre of this.rencontresExistantes) {
      this._trackToken(this._tokenRencontre(rencontre));
    }
  }

  /* -------------------------------------------- */
  updatePreviousRencontres() {
    this._removeTokens(t => t.rencontre != undefined);
    this.rencontresExistantes = duplicate(this.actor.data.data.reve.rencontre.list);
    this.displayPreviousRencontres();
  }

  /* -------------------------------------------- */
  updateSortReserve() {
    this._removeTokens(t => t.sort != undefined);
    this.sortReserves = duplicate(this.actor.data.data.reve.reserve.list);
    this.displaySortReserve();
  }

  /* -------------------------------------------- */
  async derober() {
    await this.actor.addTMRRencontre(this.currentRencontre);
    console.log("-> derober", this.currentRencontre);
    this._tellToGM(this.actor.name + " s'est dérobé et quitte les TMR.");
    this.close();
  }
  /* -------------------------------------------- */
  async refouler() {
    this._tellToGM(this.actor.name + " a refoulé : " + this.currentRencontre.name);
    await this.actor.deleteTMRRencontreAtPosition(); // Remove the stored rencontre if necessary
    await this.actor.ajouterRefoulement(this.currentRencontre.refoulement ?? 1);
    this.updatePreviousRencontres();
    console.log("-> refouler", this.currentRencontre)
    this.updateValuesDisplay();
    this.nettoyerRencontre();
  }

  /* -------------------------------------------- */
  async ignorerRencontre() {
    this._tellToGM(this.actor.name + " a ignoré : " + this.currentRencontre.name);
    await this.actor.deleteTMRRencontreAtPosition(); // Remove the stored rencontre if necessary
    this.updatePreviousRencontres();
    this.updateValuesDisplay();
    this.nettoyerRencontre();
  }

  /* -------------------------------------------- */
  colorierZoneRencontre(locList) {
    this.currentRencontre.graphics = []; // Keep track of rectangles to delete it
    this.currentRencontre.locList = duplicate(locList); // And track of allowed location
    for (let loc of locList) {
      let rect = this._getCaseRectangleCoord(loc);
      var rectDraw = new PIXI.Graphics();
      rectDraw.beginFill(0xFFFF00, 0.3);
      // set the line style to have a width of 5 and set the color to red
      rectDraw.lineStyle(5, 0xFF0000);
      // draw a rectangle
      rectDraw.drawRect(rect.x, rect.y, rect.w, rect.h);
      this.pixiApp.stage.addChild(rectDraw);
      this.currentRencontre.graphics.push(rectDraw); // garder les objets pour gestion post-click
    }
  }

  /* -------------------------------------------- */
  // garder la trace de l'état en cours
  setStateRencontre(state) {
    this.rencontreState = state;
  }

  async choisirCasePortee(coord, portee) {
    // Récupère la liste des cases à portées
    let locList = TMRUtility.getTMRPortee(coord, portee);
    this.colorierZoneRencontre(locList);
  }

  async choisirCaseType(type) {
    const locList = TMRUtility.getListCoordTMR(type);
    this.colorierZoneRencontre(locList);
  }

  /* -------------------------------------------- */
  checkQuitterTMR() {

    if (this.actor.isDead()) {
      this._tellToGM("Vous êtes mort : vous quittez les Terres médianes !");
      this.close();
      return true;
    }
    const resteAvantInconscience = this.actor.getFatigueMax() - this.actor.getFatigueActuelle() - this.cumulFatigue;
    if (resteAvantInconscience <= 0) {
      this._tellToGM("Vous vous écroulez de fatigue : vous quittez les Terres médianes !");
      this.quitterLesTMRInconscient();
      return true;
    }
    if (this.actor.getReveActuel() == 0) {
      this._tellToGM("Vos Points de Rêve sont à 0 : vous quittez les Terres médianes !");
      this.quitterLesTMRInconscient();
      return true;
    }
    return false;
  }

  async quitterLesTMRInconscient() {
    if (this.currentRencontre?.isPersistant) {
      await this.refouler();
    }
    this.close();
  }

  /* -------------------------------------------- */
  async maitriser() {
    this.actor.deleteTMRRencontreAtPosition();
    this.updatePreviousRencontres();

    let rencontreData = {
      actor: this.actor,
      alias: this.actor.name,
      reveDepart: this.actor.getReveActuel(),
      competence: this.actor.getBestDraconic(),
      rencontre: this.currentRencontre,
      nbRounds: 1,
      canClose: false,
      tmr: TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord)
    }

    await this._tentativeMaitrise(rencontreData);
  }

  async _tentativeMaitrise(rencontreData) {
    console.log("-> matriser", rencontreData);

    rencontreData.reve = this.actor.getReveActuel();
    rencontreData.etat = this.actor.getEtatGeneral();

    RollDataAjustements.calcul(rencontreData, this.actor);

    rencontreData.rolled = await RdDResolutionTable.roll(rencontreData.reve, RollDataAjustements.sum(rencontreData.ajustements));

    let postProcess = await TMRRencontres.gererRencontre(this, rencontreData);

    ChatMessage.create({
      whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-rencontre-tmr.html`, rencontreData)
    });

    if (postProcess) {
      /** Gère les rencontres avec du post-processing (passeur, messagers, tourbillons, ...) */
      await postProcess(this, rencontreData);
    }
    else {
      this.currentRencontre = undefined;
    }

    this.updateValuesDisplay();
    if (this.checkQuitterTMR()) {
      return;
    }
    else if (rencontreData.rolled.isEchec && rencontreData.rencontre.isPersistant) {
      setTimeout(() => {
        rencontreData.nbRounds++;
        this.cumulFatigue += this.fatigueParCase;
        this._tentativeMaitrise(rencontreData);
        this._deleteTmrMessages(rencontreData.actor, rencontreData.nbRounds);
      }, 2000);
    }
  }

  _deleteTmrMessages(actor, nbRounds = -1) {
    setTimeout(() => {
      if (nbRounds < 0) {
        ChatUtility.removeChatMessageContaining(`<h4 data-categorie="tmr" data-actor-id="${actor._id}"`);
      }
      else {
        for (let i = 1; i < nbRounds; i++) {
          ChatUtility.removeChatMessageContaining(`<h4 data-categorie="tmr" data-actor-id="${actor._id}" data-rencontre-round="${i}">`);
        }
      }
    }, 500);
  }

  /* -------------------------------------------- */
  _tellToUser(message) {
    ChatMessage.create({ content: message, user: game.user._id, whisper: [game.user._id] });
  }

  /* -------------------------------------------- */
  _tellToGM(message) {
    ChatMessage.create({ content: message, user: game.user._id, whisper: ChatMessage.getWhisperRecipients("GM") });
  }

  /* -------------------------------------------- */
  async manageRencontre(tmr, postRencontre) {
    if (this.viewOnly) {
      return;
    }
    this.currentRencontre = undefined;
    let rencontre = await this._jetDeRencontre(tmr);

    if (rencontre) { // Manages it
      if (rencontre.rencontre) rencontre = rencontre.rencontre; // Manage stored rencontres
      console.log("manageRencontre", rencontre);
      this.currentRencontre = duplicate(rencontre);

      let dialog = new RdDTMRRencontreDialog("", this, this.currentRencontre, postRencontre);
      dialog.render(true);
    }
    else {
      postRencontre();
    }
  }

  /* -------------------------------------------- */
  async _jetDeRencontre(tmr) {
    let rencontre = this.rencontresExistantes.find(prev => prev.coord == tmr.coord);
    if (rencontre) {
      return rencontre;
    }
    let myRoll = new Roll("1d7").evaluate().total;
    if (TMRUtility.isForceRencontre() || myRoll== 7) {
      return await this.rencontreTMRRoll(tmr, this.actor.isRencontreSpeciale());
    }
    this._tellToUser(myRoll + ": Pas de rencontre en " + tmr.label + " (" + tmr.coord + ")");
  }

  
  /* -------------------------------------------- */
  async rencontreTMRRoll(tmr, isMauvaise = false) {
    let rencontre = TMRUtility.utiliseForceRencontre() ??
        isMauvaise ? await TMRRencontres.getMauvaiseRencontre()
        : await TMRRencontres.getRencontreAleatoire(tmr.type);
    rencontre.coord = tmr.coord;
    return rencontre;
  }

  /* -------------------------------------------- */
  updateValuesDisplay() {
    let ptsreve = document.getElementById("tmr-pointsreve-value");
    ptsreve.innerHTML = this.actor.data.data.reve.reve.value;

    let tmrpos = document.getElementById("tmr-pos");
    let tmr = TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord);
    tmrpos.innerHTML = this.actor.data.data.reve.tmrpos.coord + " (" + tmr.label + ")";

    let etat = document.getElementById("tmr-etatgeneral-value");
    etat.innerHTML = this.actor.getEtatGeneral();

    let refoulement = document.getElementById("tmr-refoulement-value");
    refoulement.innerHTML = this.actor.data.data.reve.refoulement.value;

    let fatigueItem = document.getElementById("tmr-fatigue-table");
    //console.log("Refresh : ", this.actor.data.data.sante.fatigue.value);
    fatigueItem.innerHTML = "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(this.actor.data.data.sante.fatigue.value, this.actor.data.data.sante.endurance.max).html() + "</table>";
  }

  /* -------------------------------------------- */
  async manageCaseSpeciale(tmr) {
    for (let caseTMR of this.casesSpeciales) {
      if (caseTMR.data.coord == tmr.coord) { // Match !
        if (caseTMR.data.specific == 'trounoir') {
          let newTMR = TMRUtility.getTMRAleatoire();
          let tmrPos = duplicate(this.actor.data.data.reve.tmrpos);
          tmrPos.coord = newTMR.coord;
          await this.actor.update({ "data.reve.tmrpos": tmrPos });
          ChatMessage.create({
            content: "Vous êtes rentré sur un Trou Noir : ré-insertion aléatoire.",
            whisper: ChatMessage.getWhisperRecipients(game.user.name)
          });
        }
      }
    }
  }

  /* -------------------------------------------- */
  async manageCaseHumide(tmr) {
    if (this.viewOnly || this.currentRencontre) {
      return;
    }
    if (this.isCaseHumide(tmr)) {
      let rollData = {
        actor: this.actor,
        competence: duplicate(this.actor.getBestDraconic()),
        tmr: tmr,
        canClose: false,
        diffLibre: -7,
        forceCarac: { "reveactuel": { label: "Rêve Actuel", value: this.actor.getReveActuel() } }
      }
      rollData.competence.data.defaut_carac = "reveactuel";

      await this._rollMaitriseCaseHumide(rollData);
    }
  }

  /* -------------------------------------------- */
  isCaseHumide(tmr) {
    if (this.isCaseMaitrisee(tmr.coord)) {
      ChatMessage.create({
        content: tmr.label + ": cette case humide est déja maitrisée grâce à votre Tête <strong>Quête des Eaux</strong>",
        whisper: ChatMessage.getWhisperRecipients(game.user.name)
      });
      return false;
    }
    if (this.actor.isCaseHumideAdditionelle(tmr)) {
      return true;
    }
    return tmr.type == "lac" || tmr.type == "fleuve" || tmr.type == "marais";
  }

  /* -------------------------------------------- */
  isCaseMaitrisee(coordTMR) {
    return this.casesSpeciales.find(it => it.data.coord = coordTMR && it.data.specific == 'maitrisee');
  }
  
  async _rollMaitriseCaseHumide(rollData) {
    this.minimize(); // Hide
    const dialog = await RdDRoll.create(this.actor, rollData,
      {
        html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-tmr-humide.html',
        options:{ height: 350 },
        close: html => { this.maximize(); } // Re-display TMR
      },
      {
        name: 'maitrise',
        label: 'Maîtriser le fleuve',
        callbacks: [
          this.actor.createCallbackExperience(),
          { action: r => this._maitriseCaseHumide(r) }
        ]
      }
    );
    dialog.render(true);
  }

  async _maitriseCaseHumide(rollData) {
    if (rollData.rolled.isETotal) {
      rollData.souffle = await this.actor.ajouterSouffle({ chat: false });
    }
    this.toclose = rollData.rolled.isEchec;
    if (rollData.rolled.isSuccess) {
      if (!rollData.previous && this.actor.isDoubleResistanceFleuve()) {
        ChatMessage.create({
          content: `Double résistance du fleuve: `,
          whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name)
        });
        rollData.previous = [rollData.rolled];
        await this._rollMaitriseCaseHumide(rollData);
        return;
      }
    }
    rollData.poesie = poesieCaseHumide[new Roll("1d" + poesieCaseHumide.length).evaluate().total - 1];
    const whisperTo = ChatUtility.getWhisperRecipientsAndGMs(game.user.name);
    const content = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fleuve-tmr.html`, rollData);
    ChatMessage.create({
      whisper: whisperTo,
      content: content
    });
    if (rollData.rolled.isEchec) {
      this.close();
    }

  }

  /* -------------------------------------------- */
  isReserveExtensible(coordTMR) {
    for (let caseTMR of this.casesSpeciales) {
      if (caseTMR.data.specific == 'reserve_extensible' && caseTMR.data.coord == coordTMR)
        return true;
    }
    return false;
  }

  /* -------------------------------------------- */
  async declencheSortEnReserve(coordTMR) {
    if (this.viewOnly) {
      return;
    }

    let sortReserveList = TMRUtility.getSortReserveList(this.sortReserves, coordTMR);
    if (sortReserveList.length > 0) {
      if (this.actor.isReserveEnSecurite() || this.isReserveExtensible(coordTMR)) {
        let msg = "Vous êtes sur une case avec un Sort en Réserve. Grâce à votre Tête <strong>Reserve en Sécurité</strong> ou <strong>Réserve Exensible</strong>, vous pouvez contrôler le déclenchement. Cliquez si vous souhaitez le déclencher : <ul>";
        for (let sortReserve of sortReserveList) {
          msg += "<li><a class='chat-card-button' id='sort-reserve' data-actor-id='" + this.actor._id + "' data-tmr-coord='" + coordTMR + "' data-sort-id='" + sortReserve.sort._id + "'>" + sortReserve.sort.name + "</a></li>";
        }
        msg += "</ol>";
        ChatMessage.create({
          content: msg,
          whisper: ChatMessage.getWhisperRecipients(game.user.name)
        });
      } else {
        await this.processSortReserve(sortReserveList[0]);
      }
    }
  }
  /* -------------------------------------------- */
  lancerSortEnReserve(coordTMR, sortId) {
    let sortReserveList = TMRUtility.getSortReserveList(this.sortReserves, coordTMR);
    let sortReserve = sortReserveList.find(sortReserve => sortReserve.sort._id == sortId);
    //console.log("SORT RESA", sortReserveList, coordTMR, sortId, sortReserve);
    if (sortReserve) {
      this.processSortReserve(sortReserve);
    } else {
      ChatMessage.create({
        content: "Une erreur est survenue : impossible de récupérer le sort en réserve demandé.",
        whisper: ChatMessage.getWhisperRecipients(game.user.name)
      });
    }
  }

  /* -------------------------------------------- */
  async processSortReserve(sortReserve) {
    await this.actor.deleteSortReserve(sortReserve);
    this.updateSortReserve();
    console.log("declencheSortEnReserve", sortReserve)
    const declenchementSort = "Vous avez déclenché le sort <strong>" + sortReserve.sort.name
      + "</strong> en réserve en " + sortReserve.coord + " (" + TMRUtility.getTMR(sortReserve.coord).label
      + ") avec " + sortReserve.sort.data.ptreve_reel + " points de Rêve";
    this._tellToGM(declenchementSort);
    this.close();
  }

  /* -------------------------------------------- */
  nettoyerRencontre() {
    if (!this.currentRencontre) return; // Sanity check
    if (this.currentRencontre.graphics) {
      for (let drawRect of this.currentRencontre.graphics) { // Suppression des dessins des zones possibles
        this.pixiApp.stage.removeChild(drawRect);
      }
    }
    this.currentRencontre = undefined; // Nettoyage de la structure
    this.rencontreState = 'aucune'; // Et de l'état
  }

  /* -------------------------------------------- */
  processClickPostRencontre(coord) {
    if (this.rencontreState == 'passeur' || this.rencontreState == 'messager' || this.rencontreState == 'changeur') {
      console.log("Searching", this.currentRencontre.locList, coord);
      let isInArea = this.currentRencontre.locList.find(locCoord => locCoord == coord);
      if (isInArea) { // OK !
        return (this.rencontreState == 'messager') ? 'messager' : 'saut';
      }
    }
    return "erreur";
  }

  /* -------------------------------------------- */
  isTerreAttache(coordTMR) {
    for (let caseTMR of this.casesSpeciales) {
      if (caseTMR.data.specific == 'attache' && caseTMR.data.coord == coordTMR) { // Match !
        return true;
      }
    }
    return false;
  }

  /* -------------------------------------------- */
  checkConnaissanceFleuve(currentTMR, nextTMR) {
    if (this.actor.isConnaissanceFleuve()) {
      //console.log(currentTMR, nextTMR );
      if (TMRUtility.getTMR(currentTMR).type == 'fleuve' && TMRUtility.getTMR(nextTMR).type == 'fleuve') {
        return true;
      }
    }
    return false;
  }

  /* -------------------------------------------- */
  async onClickTMR(event) {
    if (this.viewOnly) {
      return;
    }

    let origEvent = event.data.originalEvent;
    let tmrObject = event.target.tmrObject;

    let eventPos = RdDTMRDialog._computeEventPos(origEvent);
    await tmrObject._onClickTMRPos(eventPos); // Vérifier l'état des compteurs reve/fatigue/vie
  }

  async _onClickTMRPos(eventPos) {
    let currentPos = TMRUtility.convertToCellPos(this.actor.data.data.reve.tmrpos.coord);

    console.log("deplacerDemiReve >>>>", currentPos, eventPos);

    let targetCoordTMR = TMRUtility.convertToTMRCoord(eventPos);
    let currentCoordTMR = TMRUtility.convertToTMRCoord(currentPos);

    // Validation de la case de destination (gestion du cas des rencontres qui peuvent téléporter)
    let deplacementType = 'erreur';
    if (this.rencontreState == 'aucune') { // Pas de recontre en post-processing, donc deplacement normal
      if (!RdDTMRDialog._horsDePortee(currentPos, eventPos) || this.isTerreAttache(targetCoordTMR) || this.checkConnaissanceFleuve(currentCoordTMR, targetCoordTMR)) {
        deplacementType = 'normal';
      }
    } else {
      deplacementType = this.processClickPostRencontre(targetCoordTMR);
    }
    // Si le deplacement est valide
    if (deplacementType == 'normal' || deplacementType == 'saut') {
      await this._deplacerDemiReve(targetCoordTMR, deplacementType);

    } else if (deplacementType == 'messager') { // Dans ce cas, ouverture du lancement de sort sur la case visée
      /*
       TODO: si la case a un sort en réserve, lancer ce sort.
       Si la case est le demi-rêve, ne pas lancer de sort.
       Si un lancement de sort est en cours, trouver un moyen de réafficher cette fenêtre si on essaie de lancer un sort (ou bloquer le lancer de sort)
      */
      await this._messagerDemiReve(targetCoordTMR);

    } else {
      ui.notifications.error("Vous ne pouvez vous déplacer que sur des cases adjacentes à votre position ou valides dans le cas d'une rencontre");
      console.log("STATUS :", this.rencontreState, this.currentRencontre);
    }

    this.checkQuitterTMR();
  }

  async _messagerDemiReve(targetCoordTMR) {
    await this.actor.rollUnSort(targetCoordTMR);
    this.nettoyerRencontre();
  }

  async _deplacerDemiReve(targetCoord, deplacementType) {
    if (this.currentRencontre != 'normal') {
      this.nettoyerRencontre();
    }
    let tmr = TMRUtility.getTMR(targetCoord);

    await this.manageCaseSpeciale(tmr); // Gestion cases spéciales type Trou noir, etc

    console.log("deplacerDemiReve: TMR is", tmr, this);

    let tmrPos = duplicate(this.actor.data.data.reve.tmrpos);
    tmrPos.coord = targetCoord;
    await this.actor.update({ "data.reve.tmrpos": tmrPos });

    this._updateDemiReve();
    this.cumulFatigue += this.fatigueParCase;
    this.updateValuesDisplay();
    game.socket.emit("system.foundryvtt-reve-de-dragon", {
      msg: "msg_tmr_move", data: {
        actorId: this.actor.data._id,
        tmrPos: tmrPos
      }
    });

    if (deplacementType == 'normal') { // Pas de rencontres après un saut de type passeur/changeur/...
      await this.manageRencontre(tmr, () => this.postRencontre(tmr));
    }
    else {
      await this.postRencontre(tmr);
    }
  }

  async postRencontre(tmr) {
    await this.manageCaseHumide(tmr);
    await this.declencheSortEnReserve(tmr.coord);
    await this.actor.checkSoufflePeage(tmr);
  }

  /* -------------------------------------------- */
  async forceDemiRevePositionView(coordTMR) {
    this._updateDemiReve();
  }

  /* -------------------------------------------- */
  async forceDemiRevePosition(coordTMR) {
    await this.actor.updateCoordTMR(coordTMR);
    this._updateDemiReve();
    let tmr = TMRUtility.getTMR(coordTMR);
    this.manageCaseHumide(tmr);
    await this.declencheSortEnReserve(tmr.coord);
  }

  /* -------------------------------------------- */
  async activateListeners(html) {
    super.activateListeners(html);

    var row = document.getElementById("tmrrow1");
    var cell1 = row.insertCell(1);
    cell1.append(this.pixiApp.view);

    if (this.viewOnly) {
      html.find('#lancer-sort').remove();
    }
    else {
      // Roll Sort
      html.find('#lancer-sort').click((event) => {
        this.actor.rollUnSort(this.actor.data.data.reve.tmrpos.coord);
      });
    }

    // load the texture we need
    await this.pixiApp.loader
      .add('tmr', 'systems/foundryvtt-reve-de-dragon/styles/img/ui/tmp_main_r1.webp')
      .add('demi-reve', "icons/svg/sun.svg")
      .load((loader, resources) => {

        // This creates a texture from a TMR image
        const mytmr = new PIXI.Sprite(resources.tmr.texture);
        // Setup the position of the TMR
        mytmr.x = 0;
        mytmr.y = 0;
        mytmr.width = 720;
        mytmr.height = 860;
        // Rotate around the center
        mytmr.anchor.x = 0;
        mytmr.anchor.y = 0;
        mytmr.interactive = true;
        mytmr.buttonMode = true;
        mytmr.tmrObject = this;
        if (!this.viewOnly) {
          mytmr.on('pointerdown', this.onClickTMR);
        }
        this.pixiApp.stage.addChild(mytmr);

        this._addDemiReve();
        this.displayPreviousRencontres();
        this.displaySortReserve();
        this.displaySpecificCase();
      });

    if (this.viewOnly) {
      return;
    }

    // Gestion du cout de montée en points de rêve
    let reveCout = (this.tmrdata.isRapide && !this.actor.checkTeteDeplacementAccelere()) ? -2 : -1;
    this.cumulFatigue += this.fatigueParCase;
    reveCout -= this.actor.checkMonteeLaborieuse();
    await this.actor.reveActuelIncDec(reveCout);
    // Le reste...
    this.updateValuesDisplay();
    let tmr = TMRUtility.getTMR(this.actor.data.data.reve.tmrpos.coord);
    await this.manageRencontre(tmr, () => {
      this.postRencontre(tmr);
      this.actor.displayTMRQueueSouffleInformation();
    });
  }

  /* -------------------------------------------- */
  static _computeEventPos(origEvent) {
    let canvasRect = origEvent.target.getBoundingClientRect();
    let x = origEvent.clientX - canvasRect.left;
    let y = origEvent.clientY - canvasRect.top;
    let cellx = Math.floor(x / tmrConstants.cellw); //  [From 0 -> 12]
    y -= (cellx % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
    let celly = Math.floor(y / tmrConstants.cellh); //  [From 0 -> 14]
    return { x: cellx, y: celly };
  }

  /* -------------------------------------------- */
  static _horsDePortee(origin, target) {
    return Math.abs(target.x - origin.x) > 1
      || Math.abs(target.y - origin.y) > 1
      || (origin.y == 0 && target.y > origin.y && target.x != origin.x && origin.x % 2 == 0)
      || (target.y == 0 && target.y < origin.y && target.x != origin.x && origin.x % 2 == 1);
  }

  /* -------------------------------------------- */
  _tokenRencontre(rencontre) {
    let sprite = new PIXI.Graphics();
    sprite.beginFill(0x767610, 0.6);
    sprite.drawCircle(0, 0, 6);
    sprite.endFill();
    sprite.decallage = {
      x: (tmrConstants.cellw / 2) - 16,
      y: 16 - (tmrConstants.cellh / 2)
    };
    return { sprite: sprite, rencontre: rencontre, coordTMR: () => rencontre.coord };
  }

  /* -------------------------------------------- */
  _tokenTrouNoir(coord) {
    let sprite = new PIXI.Graphics();
    sprite.beginFill(0x050505, 0.8);
    sprite.drawCircle(0, 0, (tmrConstants.cellw / 2) - 2);
    sprite.endFill();
    sprite.decallage = {
      x: 0,
      y: 2
    }
    return { sprite: sprite, coordTMR: () => coord }
  }

  /* -------------------------------------------- */
  _tokenDebordement(coord) {
    let sprite = new PIXI.Graphics();
    sprite.beginFill(0x0101FE, 0.3);
    sprite.drawCircle(0, 0, (tmrConstants.cellw / 2) - 2);
    sprite.endFill();
    sprite.decallage = {
      x: 0,
      y: 2
    }
    return { sprite: sprite, coordTMR: () => coord }
  }

  /* -------------------------------------------- */
  _tokenMaitrisee(coord) {
    let sprite = new PIXI.Graphics();
    sprite.beginFill(0x1010F0, 0.8);
    sprite.drawCircle(0, 0, 6);
    sprite.endFill();
    sprite.decallage = {
      x: 16 - (tmrConstants.cellw / 2),
      y: 16 - (tmrConstants.cellh / 2)
    }
    return { sprite: sprite, coordTMR: () => coord }
  }

  /* -------------------------------------------- */
  _tokenTerreAttache(coord) {
    let sprite = new PIXI.Graphics();
    sprite.beginFill(0x10F010, 0.8);
    sprite.drawCircle(0, 0, 6);
    sprite.endFill();
    sprite.decallage = {
      x: 16 - (tmrConstants.cellw / 2),
      y: 16 - (tmrConstants.cellh / 2)
    }
    return { sprite: sprite, coordTMR: () => coord }
  }

  /* -------------------------------------------- */
  _tokenSortEnReserve(sort) {
    let sprite = new PIXI.Graphics();
    sprite.beginFill(0x101010, 0.8);
    sprite.drawCircle(0, 0, 6);
    sprite.endFill();
    sprite.decallage = {
      x: 16 - (tmrConstants.cellw / 2),
      y: 16 - (tmrConstants.cellh / 2)
    }
    return { sprite: sprite, sort: sort, coordTMR: () => sort.coord }
  }

  /* -------------------------------------------- */
  _tokenDemiReve() {
    let texture = PIXI.utils.TextureCache['demi-reve'];
    let sprite = new PIXI.Sprite(texture);
    sprite.width = tmrConstants.cellw * 0.7;
    sprite.height = tmrConstants.cellh * 0.7;
    sprite.anchor.set(0.5);
    sprite.tint = 0x00FFEE;
    return { sprite: sprite, actor: this.actor, coordTMR: () => this.actor.data.data.reve.tmrpos.coord }
  }

  /* -------------------------------------------- */
  _addDemiReve() {
    this.demiReve = this._tokenDemiReve();
    this._setTokenPosition(this.demiReve);
    this.pixiApp.stage.addChild(this.demiReve.sprite);
  }

  /* -------------------------------------------- */
  _updateDemiReve() {
    this._setTokenPosition(this.demiReve);
  }

  /* -------------------------------------------- */
  /** Retourne les coordonnées x, h, w, h du rectangle d'une case donnée */
  _getCaseRectangleCoord(coord) {
    let coordXY = TMRUtility.convertToCellPos(coord);
    let decallagePairImpair = (coordXY.x % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
    let x = tmrConstants.gridx + (coordXY.x * tmrConstants.cellw) - (tmrConstants.cellw / 2);
    let y = tmrConstants.gridy + (coordXY.y * tmrConstants.cellh) - (tmrConstants.cellh / 2) + decallagePairImpair;
    return { x: x, y: y, w: tmrConstants.cellw, h: tmrConstants.cellh }
  }

  /* -------------------------------------------- */
  _setTokenPosition(token) {
    let coordXY = TMRUtility.convertToCellPos(token.coordTMR());
    let decallagePairImpair = (coordXY.x % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
    let dx = (token.sprite.decallage == undefined) ? 0 : token.sprite.decallage.x;
    let dy = (token.sprite.decallage == undefined) ? 0 : token.sprite.decallage.y;
    token.sprite.x = tmrConstants.gridx + (coordXY.x * tmrConstants.cellw) + dx;
    token.sprite.y = tmrConstants.gridy + (coordXY.y * tmrConstants.cellh) + dy + decallagePairImpair;
  }

  /* -------------------------------------------- */
  _removeTokens(filter) {
    const tokensToRemove = this.allTokens.filter(filter);
    for (let token of tokensToRemove) {
      this.pixiApp.stage.removeChild(token.sprite);
    }
  }

  /* -------------------------------------------- */
  _trackToken(token) {
    this.allTokens.push(token)
    this._setTokenPosition(token);
    this.pixiApp.stage.addChild(token.sprite);
  }

}