import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE } from "../constants.js";
import { ITEM_TYPES } from "../constants.js";
import { RdDItemBlessure } from "../item/blessure.js";
import { Misc } from "../misc.js";
import { RdDCarac } from "../rdd-carac.js";
import { RdDEncaisser } from "../rdd-roll-encaisser.js";
import { STATUSES } from "../settings/status-effects.js";
import { RdDBaseActorReve } from "./base-actor-reve.js";

export class RdDEntite extends RdDBaseActorReve {

  static get defaultIcon() {
    return "systems/foundryvtt-reve-de-dragon/icons/entites/darquoine.webp";
  }

  canReceive(item) {
    return item.type == ITEM_TYPES.competencecreature
  }

  isEntite() { return true }
  isEntiteNonIncarnee() { return this.system.definition.typeentite == ENTITE_NONINCARNE }
  isEntiteIncarnee() { return !this.isEntiteNonIncarnee() }
  isEntiteBlurette() { return this.system.definition.typeentite == ENTITE_BLURETTE }

  getReveActuel() {
    return Misc.toInt(this.system.carac.reve?.value)
  }

  getCarac() {
    const carac = super.getCarac()
    delete carac.niveau
    return carac
  }

  getNiveau() {
    const reve = this.getReve()
    return RdDCarac.getCaracDerivee(reve).niveau
  }
  getForce() { return this.getReve() }
  getAgilite() { return this.getReve() }
  getChance() { return this.getReve() }
  getEnduranceMax() { return Math.max(1, this.getTaille() + this.getReve()) }

  async remiseANeuf() {
    if (!this.isEntiteNonIncarnee()) {
      await this.update({ 'system.sante.endurance.value': this.system.sante.endurance.max })
    }
    await this.removeEffects(e => true)
  }

  isDead() {
    return this.isEntiteNonIncarnee() ? false : this.system.sante.endurance.value <= 0
  }

  async santeIncDec(name, inc, isCritique = false) {
    if (name == 'endurance' && !this.isEntiteNonIncarnee()) {
      const oldValue = this.system.sante.endurance.value;
      const endurance = Math.max(0,
        Math.min(oldValue + inc,
          this.system.sante.endurance.max));
      await this.update({ "system.sante.endurance.value": endurance })
      await this.setEffect(STATUSES.StatusComma, endurance <= 0);
      return {
        perte: oldValue - endurance,
        newValue: endurance
      }
    }
    return {}
  }

  async encaisser() {
    if (this.isEntiteNonIncarnee()) {
      return
    }
    await RdDEncaisser.encaisser(this)
  }

  isEffectAllowed(effectId) {
    return [STATUSES.StatusComma].includes(effectId);
  }

  async onAppliquerJetEncaissement(encaissement, attackerToken) {
    if (this.isEntiteNonIncarnee()) {
      return
    }
    encaissement.isEntiteIncarnee = true
    const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance);
    foundry.utils.mergeObject(encaissement, { resteEndurance: perteEndurance.newValue, endurance: perteEndurance.perte })
  }

  isEntiteAccordee(attacker) {
    if (this.isEntiteIncarnee()) {
      let resonnance = this.system.sante.resonnance
      return (resonnance.actors.find(it => it == attacker.id))
    }
    return true
  }

  listActionsPossessions() {
    if (this.isEntiteNonIncarnee()) {
      return this.itemTypes[ITEM_TYPES.competencecreature]
        .filter(it => it.system.ispossession)
        .map(it => it.attaqueCreature())
        .filter(it => it != undefined)
    }
    return super.listActionsPossessions()
  }
  /* -------------------------------------------- */
  async setEntiteReveAccordee(actor) {
    if (this.isEntiteIncarnee()) {
      if (this.system.sante.resonnance.actors.find(it => it == actor.id)) {
        // déjà accordé
        return
      }
      await this.update({ "system.sante.resonnance.actors": [...this.system.sante.resonnance.actors, actor.id] })
    }
    else {
      super.setEntiteReveAccordee(actor)
    }
  }

  mapCarac(caracCode) {
    switch (caracCode) {
      case 'taille':
      case 'reve':
        return caracCode
    }
    return 'reve'
  }

}
