import { TYPES } from "../item.js";
import { TMRUtility } from "../tmr-utility.js";
import { PixiTMR } from "./pixi-tmr.js";

const registeredEffects = [
]

/**
 * Définition des informations d'une "draconique" (queue, ombre, tête, souffle) qui influence les TMR
 */
export class Draconique {
  static init() {
  }

  static isCaseTMR(item) { return item.type == TYPES.casetmr; }
  static isQueueDragon(item) { return item.isQueueDragon(); }
  static isSouffleDragon(item) { return item.type == TYPES.souffle; }
  static isTeteDragon(item) { return item.type == TYPES.tete; }
  static isQueueSouffle(item) { return Draconique.isQueueDragon(item) || Draconique.isSouffleDragon(item); }

  static register(draconique) {
    registeredEffects[draconique.code()] = draconique;
    if (draconique.img()) {
      PixiTMR.register(draconique.code(), draconique.img())
    }
    return draconique;
  }

  static all() {
    return Object.values(registeredEffects);
  }

  static get(code) {
    return registeredEffects[code];
  }

  tmrLabel(linkData) { return TMRUtility.getTMRLabel(linkData.system.coord); }

  /**
   * @param item un Item quelconque
   * @returns true si l'item correspond
   */
  match(item) {
    return Draconique.isQueueDragon(item) || Draconique.isSouffleDragon(item) || Draconique.isTeteDragon(item);
  }

  /**
   * @returns un message à afficher si la draconique doit être gérée manuellement.
   */
  manualMessage() {
    return false;
  }

  /**
   * Méthode responsable de gérer une draconique (par exemple, ajouter des casetmr pour la fermeture des cités).
   * @param actor auquel la draconique est ajoutée
   */
  async onActorCreateOwned(actor, item) {
    return false;
  }

  async onActorDeleteOwned(actor, item) {
    this.deleteCasesTmr(actor, item);
    return false;
  }

  async onActorDeleteCaseTmr(actor, casetmr) {
    return false;
  }
  /**
   * @return le code interne utilisé pour les casetmr correpondant
   */
  code() { return undefined }

  /**
   * @param {*} linkData données associées au token pixi (une casetmr, un sort en réserve, une rencontre en attente)
   * @returns un tooltip à afficher au dessus du token
   */
  tooltip(linkData) { return undefined }

  /**
   * @param {*} img l'url du fichier image à utiliser pour le token. Si indéfini (et si createSprite n'est pas surchargé),
   *  un disque est utilisé.
  */
  img() { return undefined }

  /**
   * factory d'élément graphique PIXI correspondant à l'objet draconique
   * @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
  */
  token(pixiTMR, linkData, coordTMR, type = undefined) {
    const tooltip = this.tooltip(linkData);
    const token = {
      sprite: this.createSprite(pixiTMR),
      coordTMR: coordTMR,
      tooltip: tooltip
    };
    token[type ?? this.code()] = linkData;
    return token;
  }

  /**
   * factory d'élément graphique PIXI correpsondant à l'objet draconique
   * @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
   */
  createSprite(pixiTMR) {
    if (this.img()) {
      return pixiTMR.sprite(this.code())
    }
    else {
      return pixiTMR.circle()
    }
  }

  /**
   * 
   * @param {*} item un item à tester
   * @param {*} coord les coordonnées d'une case. Si undefined toute case du type correspondra, 
   */
  isCase(item, coord = undefined) {
    return Draconique.isCaseTMR(item) && item.system.specific == this.code() && (coord ? item.system.coord == coord : true);
  }

  find(list, coord = undefined) {
    return list.find(c => this.isCase(c, coord));
  }

  async createCaseTmr(actor, label, tmr, sourceId = undefined) {
    const casetmrData = {
      name: label,
      type: 'casetmr',
      img: this.img(),
      system: { coord: tmr.coord, specific: this.code(), sourceid: sourceId }
    };
    await actor.createEmbeddedDocuments('Item', [casetmrData]);
  }

  async deleteCasesTmr(actor, draconique) {
    let caseTmrs = actor.items.filter(it => this.isCaseForSource(it, draconique));
    await actor.deleteEmbeddedDocuments('Item', caseTmrs.map(it => it.id));
  }

  isCaseForSource(item, draconique) {
    return Draconique.isCaseTMR(item) && item.system.specific == this.code() && item.system.sourceid == draconique.id;
  }

  async onVisiteSupprimer(actor, tmr, onRemoveToken) {
    let existants = actor.items.filter(it => this.isCase(it, tmr.coord));
    await actor.deleteEmbeddedDocuments('Item', existants.map(it => it.id));
    for (let casetmr of existants) {
      onRemoveToken(tmr, casetmr);
    }
  }
}