import { ITEM_TYPES } from "../constants.js"
import { Grammar } from "../grammar.js"
import { ATTAQUE_TYPE, RdDItemArme } from "../item/arme.js"
import { RdDBonus } from "../rdd-bonus.js"
import { CARACS } from "../rdd-carac.js"
import { StatusEffects } from "../settings/status-effects.js"
import { DIFF_MODE, ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
import { PART_CARAC } from "./roll-part-carac.mjs"
import { PART_COMP } from "./roll-part-comp.mjs"
import { PART_DIFF } from "./roll-part-diff.mjs"
import { RollPartSelect } from "./roll-part-select.mjs"
import { PART_SIGN } from "./roll-part-sign.mjs"
import { ROLLDIALOG_SECTION } from "./roll-part.mjs"

export const PART_DEFENSE = 'defense'

export class RollPartDefense extends RollPartSelect {

  get code() { return PART_DEFENSE }
  get section() { return ROLLDIALOG_SECTION.CHOIX }
  visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_DEFENSE) }

  static getDiffAttaque(attackerRoll) {
    // TODO: rollDataV2?
    return attackerRoll.diffLibre;
  }

  loadRefs(rollData) {
    const refs = this.getRefs(rollData)
    const attaque = rollData.attaque
    const defenseur = rollData.active.actor
    refs.isDistance = [ATTAQUE_TYPE.TIR, ATTAQUE_TYPE.LANCER].find(it => it == attaque?.main)
    const esquives = refs.isDistance == ATTAQUE_TYPE.TIR ? [] : defenseur.getCompetencesEsquive()
      .map(it => RollPartDefense.$extractEsquive(it, defenseur))

    const parades = defenseur.items.filter(it => it.isParade() && (!refs.isDistance || it.isBouclier()))
      .map(it => RollPartDefense.$extractParade(it, attaque?.attaque.arme, defenseur))

    refs.defenses = [...esquives, ...parades].filter(it => it != undefined)
    this.$selectDefense(rollData)
  }

  static $extractEsquive(esquive, defenseur) {
    return {
      key: esquive.id,
      label: esquive.name,
      img: esquive.img,
      // TODO: carac pour créatures
      carac: defenseur.isPersonnage() ? CARACS.DEROBEE : esquive.name,
      comp: esquive
    }
  }

  static $extractParade(armeDefense, armeAttaque, defenseur) {
    const comp = (ITEM_TYPES.competencecreature == armeDefense.type)
      ? armeDefense
      : defenseur.getCompetence(armeDefense.system.competence)
    return {
      key: armeDefense.id,
      label: 'Parade ' + armeDefense.name,
      img: armeDefense.img,
      // TODO: carac pour créatures
      carac: defenseur.isPersonnage() ? CARACS.MELEE : comp.name,
      comp: comp,
      arme: armeDefense,
      forceRequise: armeDefense ? RdDItemArme.valeurMain(armeDefense.system.force ?? 0, RdDItemArme.getMainAttaque(comp)) : 0,
      typeParade: armeAttaque ? RdDItemArme.defenseArmeParade(armeDefense, armeAttaque) : 'norm'
    }
  }

  prepareContext(rollData) {
    const current = this.getCurrent(rollData)
    current.defenseur = StatusEffects.getActorEffetSurprise(rollData.active.actor, current.forceRequise)

    // current.dmg = this.$dmgRollV2(rollData, current)
  }

  getAjustements(rollData) {
    return []
  }

  choices(refs) { return refs.defenses }

  $selectDefense(rollData, key) {
    this.selectByKey(rollData, key)
  }

  async _onRender(rollDialog, context, options) {
    const selectDefense = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-defense"]`)

    selectDefense.addEventListener("change", e => {
      const selectOptions = e.currentTarget.options
      const index = selectOptions.selectedIndex
      this.$selectDefense(rollDialog.rollData, selectOptions[index]?.value)
      rollDialog.setModeTitle()
      rollDialog.render()
    })
  }

  impactOtherPart(part, rollData) {
    if (this.visible(rollData)) {
      const current = this.getCurrent(rollData)
      switch (part.code) {
        case PART_CARAC: return part.filterCaracs(rollData, [current.carac])
        case PART_COMP: return part.filterComps(rollData, [current.comp?.name])
        case PART_DIFF: return part.setDiff(rollData, this.getDiffDefense(rollData))
        case PART_SIGN: return part.setArme(rollData, current.forceRequise, this.isArmeDisparate(rollData))
      }
    }
    return undefined
  }

  isArmeDisparate(rollData) {
    const armeDefense = this.getCurrent(rollData).arme
    if (armeDefense) {
      const armeAttaque = rollData.attaque?.attaque.arme
      return RdDItemArme.defenseArmeParade(armeAttaque, armeDefense) == 'sign'
    }
    return false
  }

  getDiffDefense(rollData) {
    const current = this.getCurrent(rollData)
    const refs = this.getRefs(rollData)
    if (refs.isDistance) {
      // Déterminer la difficulté de parade
      return { diff: 0, mode: DIFF_MODE.LIBRE }
    }
    else {
      return { diff: rollData.attaque.diff, mode: DIFF_MODE.DEFENSE }
    }
  }
}