import { ATTAQUE_TYPE, EMPOIGNADE, PUGILAT, RdDItemArme } from "./item/arme.js";
import { ITEM_TYPES } from "./constants.js";

export class RdDHotbar {

  static async createItemMacro(item, slot, armeCompetence = undefined) {
    const itemName = item.name;
    let macroName = itemName + RdDHotbar.$macroNameSuffix(armeCompetence);
    let command = `game.system.rdd.RdDHotbar.rollMacro("${itemName}", "${item.type}", "${armeCompetence}");`
    let macro = game.macros.contents.find(m => (m.name === itemName) && (m.command === command));
    if (!macro) {
      macro = await Macro.create({
        name: macroName,
        type: "script",
        img: item.img,
        command: command
      }, { displaySheet: false })
    }
    await game.user.assignHotbarMacro(macro, slot);
  }

  static $macroNameSuffix(maniement) {
    switch (maniement) {
      case ATTAQUE_TYPE.UNE_MAIN:
      case ATTAQUE_TYPE.DEUX_MAINS:
      case ATTAQUE_TYPE.LANCER:
      case ATTAQUE_TYPE.TIR:
        return ' ' + maniement
      case 'tir': return ' (tir)';
      case 'lancer': return ' (lancer)';
      case PUGILAT: return ' (pugilat)';
      case EMPOIGNADE: return ' (empoignade)';
    }
    return ''
  }

  static async addToHotbar(item, slot) {
    switch (item?.type ?? '') {
      case ITEM_TYPES.arme:
        {
          // Les armes peuvent avoir plusieurs usages
          if (item.system.competence != '') {
            if (item.system.unemain) {
              await this.createItemMacro(item, slot++, ATTAQUE_TYPE.UNE_MAIN)
            }
            if (item.system.deuxmains) {
              await this.createItemMacro(item, slot++, ATTAQUE_TYPE.DEUX_MAINS)
            }
          }
          if (item.system.lancer != '') {
            await this.createItemMacro(item, slot++, ATTAQUE_TYPE.LANCER)
          }
          if (item.system.tir != '') {
            await this.createItemMacro(item, slot++, ATTAQUE_TYPE.TIR)
          }
        }
        return
      case ITEM_TYPES.competencecreature:
        const categorie = item.getCategorieAttaque() ?? 'competence';
        await this.createItemMacro(item, slot, categorie)
        return
      default:
      case ITEM_TYPES.competence:
        await this.createItemMacro(item, slot++, 'competence')
        if (item.isCorpsACorps()) {
          await this.createItemMacro(item, slot++, PUGILAT)
          await this.createItemMacro(item, slot++, EMPOIGNADE)
        }
        else if (item.isCompetenceArme()) {
          ui.notifications.info(`${item.name} est une compétence d'arme, la macro n'est pas liée à un arme.<br>
          Créez la macro depuis l'arme ou l'onglet combat pour garder les automatisations de combat.`);
        }
        return
    }
  }

  /**
   * Create a macro when dropping an entity on the hotbar
   * Item      - open roll dialog for item
   * Actor     - open actor sheet
   * Journal   - open journal sheet
   */
  static initHooks() {
    Hooks.on('hotbarDrop', (bar, documentData, slot) => {

      // Create item macro if rollable item - weapon, spell, prayer, trait, or skill
      if (documentData.type == 'Item') {
        const item = fromUuidSync(documentData.uuid) ?? this.actor.items.get(documentData.uuid)
        console.log('DROP', documentData, item)
        switch (item?.type) {
          case ITEM_TYPES.arme:
          case ITEM_TYPES.competence:
          case ITEM_TYPES.competencecreature:
            this.addToHotbar(item, slot)
            return false
        }
      }

      return true
    })
  }

  /** Roll macro */
  static rollMacro(itemName, itemType, maniement = 'competence') {
    const speaker = ChatMessage.getSpeaker();
    let actor;
    if (speaker.token) actor = game.actors.tokens[speaker.token];
    if (!actor) actor = game.actors.get(speaker.actor);
    if (!actor) {
      return ui.notifications.warn(`Impossible de trouver le personnage concerné`);
    }
    let item = actor?.items.find(it => it.name === itemName && it.type == itemType) ?? undefined;
    if (!item) {
      return ui.notifications.warn(`Impossible de trouver l'objet de cette macro`);
    }

    // Trigger the item roll
    switch (item.type) {
      case ITEM_TYPES.arme:
        return actor.rollArme(item, maniement);
      case ITEM_TYPES.competence:
        if (item.isCorpsACorps()) {
          switch (maniement) {
            case PUGILAT:
              return actor.rollArme(RdDItemArme.pugilat(actor));
            case EMPOIGNADE:
              return actor.rollArme(RdDItemArme.empoignade(actor));
          }
        }
        return actor.rollCompetence(item);
      case ITEM_TYPES.competencecreature:
        return item.system.iscombat
          ? actor.rollArme(item, maniement)
          : actor.rollCompetence(item);

    }
  }

}
