/* -------------------------------------------- */  
import { SoSCombat } from "./sos-combat.js";
import { SoSDialogCombatActions } from "./sos-dialog-combat-actions.js";

/* -------------------------------------------- */  
const severity2malus = { "none": 0, "light": -1, "moderate": -2, "severe": -3, "critical": -4};
/* -------------------------------------------- */  
const severity2bonus = { "none": 0, "light": 1, "moderate": 2, "severe": 3, "critical": 4};

/* -------------------------------------------- */  
export class SoSUtility  {
  
  /* -------------------------------------------- */  
  static async preloadHandlebarsTemplates() {
    
    const templatePaths = [
      'systems/foundryvtt-shadows-over-sol/templates/actor-sheet.html',
      'systems/foundryvtt-shadows-over-sol/templates/editor-notes-gm.html',
      'systems/foundryvtt-shadows-over-sol/templates/stat-option-list.html',
      'systems/foundryvtt-shadows-over-sol/templates/stat-name-list.html',

      'systems/foundryvtt-shadows-over-sol/templates/item-sheet.html',
      'systems/foundryvtt-shadows-over-sol/templates/item-geneline-sheet.html',
      'systems/foundryvtt-shadows-over-sol/templates/item-subculture-sheet.html',
      'systems/foundryvtt-shadows-over-sol/templates/item-weapon-sheet.html',
      'systems/foundryvtt-shadows-over-sol/templates/item-commongear-sheet.html',

      'systems/foundryvtt-shadows-over-sol/templates/dialog-flip.html'
    ]
    return loadTemplates(templatePaths);    
  }

  /* -------------------------------------------- */
  static fillRange (start, end) {
    return Array(end - start + 1).fill().map((item, index) => start + index);
  }
  
  /* -------------------------------------------- */
  static onSocketMesssage( msg ) {
    if( !game.user.isGM ) return; // Only GM

    if (msg.name == 'msg_declare_actions' ) {
      let combat = game.combats.get( msg.data.combatId); // Get the associated  combat
      combat.setupActorActions( msg.data );
    } else if (msg.name == 'msg_close_action') {
      game.combat.closeAction( msg.data.uniqId );
    } else if (msg.name == 'msg_request_defense') {
      SoSUtility.applyDamage( msg.data );
    } else if (msg.name == 'msg_reaction_cover') {
      SoSUtility.reactionCover( msg.data.uniqId );
    } else if (msg.name == 'msg_reaction_melee') {
      SoSUtility.reactionMelee( msg.data.uniqId );
    } else if (msg.name == 'msg_reaction_hit') {
      SoSUtility.reactionHit( msg.data.uniqId );
    }
  }

  /* -------------------------------------------- */
  static data(it) {
    if (it instanceof Actor || it instanceof Item || it instanceof Combatant) {
      return it.data;
    }
    return it;
  }


  /* -------------------------------------------- */
  static templateData(it) {
    return SoSUtility.data(it)?.data ?? {}
  }

  /* -------------------------------------------- */
  static async loadCompendiumData(compendium) {
    const pack = game.packs.get(compendium);
    return await pack?.getDocuments() ?? [];
  }
  
  /* -------------------------------------------- */
  static async loadCompendium(compendium, filter = item => true) {
    let compendiumData = await SoSUtility.loadCompendiumData(compendium);
    return compendiumData.filter(filter);
  }
  
  /* -------------------------------------------- */
  static async loadCompendiumNames(compendium) {
    const pack = game.packs.get(compendium);
    let competences;
    await pack.getIndex().then(index => competences = index);
    return competences;
  }
  
  /* -------------------------------------------- */
  /*static async loadCompendium(compendium, filter = item => true) {
    let compendiumItems = await SoSUtility.loadCompendiumNames(compendium);

    const pack = game.packs.get(compendium);
    let list = [];
    for (let compendiumItem of compendiumItems) {
      await pack.getEntity(compendiumItem.id).then(it => {
        const item = it.data;
        if (filter(item)) {
          list.push(item);
        }
      });
    };
    return list;
  }*/
  
  /* -------------------------------------------- */
  static updateCombat(combat, round, diff, id) {
    combat.requestActions();
  }

  /* -------------------------------------------- */
  static async openDeclareActions( event) {
    event.preventDefault();
    let round = event.currentTarget.attributes['data-round'].value;
    let combatantId = event.currentTarget.attributes['data-combatant-id'].value;
    let combatId = event.currentTarget.attributes['data-combat-id'].value;
    let uniqId = event.currentTarget.attributes['data-uniq-id'].value;
    let d = await SoSDialogCombatActions.create( combatId, combatantId, round, uniqId );
    d.render(true);      
  }

  /* -------------------------------------------- */
  static getConsequenceMalus(severity) {
    return severity2malus[severity] ?? 0;
  }
  /* -------------------------------------------- */
  static getConsequenceBonus(severity) {
    return severity2bonus[severity] ?? 0;
  }
  
  /* -------------------------------------------- */
  static computeEncumbrance( items) {
    let trappings = items.filter( item => item.type == 'gear' || item.type == 'armor' || item.type == 'weapon' );
    let sumEnc = 0;
    for (let object of trappings) {
      if ( (!object.data.worn) && (!object.data.neg) && (!object.data.software) && (!object.data.implant) && (!object.data.containerid || object.data.containerid == "") ) {
        sumEnc += (object.big > 0) ? object.big : 1;
      }
    }
    return sumEnc;
  }

  /* -------------------------------------------- */
  static closeAction(event) {
    let uniqId = event.currentTarget.attributes['data-uniq-id'].value;

    if ( game.user.isGM ) {
      game.combat.closeAction( uniqId );
    } else {
      game.socket.emit("system.foundryvtt-shadows-over-sol", {
          name: "msg_close_action", data: { uniqId: uniqId}  } );
    }
  }

  /* -------------------------------------------- */
  static async registerChatCallbacks(html) {
    html.on("click", '#button-declare-actions', event => {
      SoSUtility.openDeclareActions( event );
    });
    html.on("click", '#button-end-action', event => {
      SoSUtility.closeAction( event );
    });    

    html.on("click", '#button-reaction-cover', event => {
      let uniqId = event.currentTarget.attributes['data-uniq-id'].value;
      if ( game.user.isGM ) {
        SoSUtility.reactionCover( uniqId );
      } else {
        game.socket.emit("system.foundryvtt-shadows-over-sol", { name: "msg_reaction_cover", data: { uniqId: uniqId}  } );
      }
    });    

    html.on("click", '#button-reaction-melee', event => {
      let uniqId = event.currentTarget.attributes['data-uniq-id'].value;
      if ( game.user.isGM ) {
        SoSUtility.reactionMelee( uniqId );
      } else {
        game.socket.emit("system.foundryvtt-shadows-over-sol", { name: "msg_reaction_melee", data: { uniqId: uniqId}  } );
      }
    });    
    html.on("click", '#button-reaction-hit', event => {
      let uniqId = event.currentTarget.attributes['data-uniq-id'].value;
      if ( game.user.isGM ) {
        SoSUtility.reactionHit( uniqId );
      } else {
        game.socket.emit("system.foundryvtt-shadows-over-sol", { name: "msg_reaction_hit", data: { uniqId: uniqId}  } );
      }
    });        
  }

  /* -------------------------------------------- */
  static getTarget() {
    if (game.user.targets && game.user.targets.size == 1) {
      for (let target of game.user.targets) {
        return target;
      }
    }
    return undefined;
  }

  /* -------------------------------------------- */
  static increaseConsequenceSeverity( severity ) {
    if ( severity == 'none') return 'light';
    if ( severity == 'light') return 'moderate';
    if ( severity == 'moderate') return 'severe';      
    if ( severity == 'severe') return 'critical';
    return 'critical';
  }

  /* -------------------------------------------- */
  static getConsequenceSeverityLevel( severity) {
    if ( severity == 'none')     return 0;
    if ( severity == 'light')    return 1;
    if ( severity == 'moderate') return 2;
    if ( severity == 'severe')   return 3;
    if ( severity == 'critical') return 4;
    return 0;
  }
  
  /* -------------------------------------------- */
  static increaseSeverity( severity ) {
    if ( severity == 'L') return 'M';
    if ( severity == 'M') return 'S';
    if ( severity == 'S') return 'C';
    if ( severity == 'C') return 'F';
  }

  /* -------------------------------------------- */
  static decreaseSeverity( severity ) {
    if ( severity == 'C') return 'S';
    if ( severity == 'S') return 'M';
    if ( severity == 'M') return 'L';
    if ( severity == 'L') return 'N';
  }

  /* -------------------------------------------- */
  static getSeverityLevel( severity) {
    if ( severity == 'C') return 4;
    if ( severity == 'S') return 3;
    if ( severity == 'M') return 2;
    if ( severity == 'L') return 1;
    return 0;
  }

  /* -------------------------------------------- */
  static async confirmDelete(actorSheet, li) {
    let itemId = li.data("item-id");
    let objet = actorSheet.actor.items.find(item => item._id == itemId);
    let msgTxt = "<p>Are you sure to delete this item ?";
    let buttons = {
      delete: {
          icon: '<i class="fas fa-check"></i>',
          label: "Yes, delete it",
          callback: () => {
            console.log("Delete : ", itemId);
            actorSheet.actor.deleteOwnedItem(itemId);
            li.slideUp(200, () => actorSheet.render(false));
          }
        },
        cancel: {
          icon: '<i class="fas fa-times"></i>',
          label: "Cancel"
        }
      }
      msgTxt += "</p>";
      let d = new Dialog({
        title: "Confirm deletion",
        content: msgTxt,
        buttons: buttons,
        default: "cancel"
      });
      d.render(true);
    }
  
  /* -------------------------------------------- */
  static async applyDamage( flipData ) {
    if (!this.registry) this.registry = {};

    if ( flipData.isReaction) { // Check again resut in case of reaction !
      flipData.magnitude = flipData.finalScore - flipData.tn; // Update magnitude
      if ( flipData.magnitude < 0 ) {
        let html = await renderTemplate('systems/foundryvtt-shadows-over-sol/templates/chat-reaction-result.html', flipData );
        ChatMessage.create( { content: html });    
        return;
      }
    }
    
    // DR management
    let armor = flipData.target.actor.data.items.find( item => item.type == 'armor' && item.data.worn);
    flipData.armorDR = armor ? armor.data.dr : 0;
    flipData.armorGel = armor ?armor.data.gel : 0;
    flipData.armorReflect = armor ? armor.data.reflect : 0;
    let dr = flipData.target.actor.data.data.scores.dr.value + flipData.armorDR;
    if (flipData.weapon.data.category == 'ballistic') {
      dr += flipData.armorGel; 
    }
    if (flipData.weapon.data.category == 'laser') {
      dr += flipData.armorReflect; 
    }

    let shock = flipData.target.actor.data.data.scores.shock.value || 1;
    let defenseCritical = flipData.target.actor.data.data.scores.defense.critical;
    flipData.damageStatus = 'apply_damage';

    flipData.targetShock = shock;
    flipData.targetDR    = dr;
    flipData.targetCritical = defenseCritical;
    // DR management
    if ( flipData.damageValue < dr) { 
      if (flipData.damageValue < dr / 2) {
        flipData.damageStatus = "no_damage";
        flipData.damageReason = "Damage are lesser than DR/2";
      } else {
        flipData.damageSeverity = this.decreaseSeverity(flipData.damageSeverity );
        if ( flipData.damageSeverity == 'N') {
          flipData.damageStatus = "no_damage";
          flipData.damageReason = "Severity decreased to nothing";
        } 
      }
    }
    
    // Shock management
    flipData.woundsList = [];
    flipData.nbStun = 0;
    if (  flipData.weapon.stun ) { // Stun weapon case
      if ( flipData.damageValue >= shock ) {
        flipData.nbStun = Math.floor(flipData.damageValue / shock);
      }
    } else {
      if ( flipData.damageValue >= shock ) {
        let incSeverity = Math.floor(flipData.damageValue / shock);
        for (let i=0; i<incSeverity; i++) {
          if ( flipData.damageSeverity == 'C') {
            flipData.woundsList.push( flipData.damageSeverity );
            flipData.damageSeverity = 'L';
          } else {
            flipData.nbStun++;
            flipData.damageSeverity = this.increaseSeverity( flipData.damageSeverity );
            flipData.damageReason = "Severity increased";
          }
        }
      }
    }
    flipData.woundsList.push( flipData.damageSeverity );
    flipData.nbWounds = flipData.woundsList.length;

    // Critical management
    flipData.isCritical = ( flipData.cardTotal >= defenseCritical);

    let html = await renderTemplate('systems/foundryvtt-shadows-over-sol/templates/chat-damage-target.html', flipData );
    ChatMessage.create( { content: html });

    // Is target able to dodge ??
    let defender = game.actors.get( flipData.target.actor._id);
    flipData.coverConsequence = defender.data.items.find( item => item.type == 'consequence' && item.name == 'Cover');
    flipData.APavailable = game.combat.getAPFromActor( defender.data._id );
    console.log("FLIPDATE : ", flipData);
    if ( !flipData.isReaction && flipData.APavailable > 0) {
      if ( (flipData.weapon.data.category == 'melee' ) || ( (flipData.weapon.data.category == 'laser' || flipData.weapon.data.category == 'ballistic') && 
        flipData.coverConsequence.data.severity != 'none') )  {
        flipData.coverSeverityLevel = this.getConsequenceSeverityLevel( flipData.coverConsequence.data.severity ) * 2;
        flipData.coverSeverityFlag  = (flipData.coverSeverityLevel > 0);
        flipData.isMelee = (flipData.weapon.data.category == 'melee' );
        let melee = defender.data.items.find( item => item.type == 'skill' && item.name == 'Melee');
        flipData.defenderMelee = melee.data.value;
        flipData.uniqId = randomID(16);
        this.registry[flipData.uniqId] = flipData;
        let html = await renderTemplate('systems/foundryvtt-shadows-over-sol/templates/chat-damage-request-dodge.html', flipData );
        ChatMessage.create( { content: html, whisper: ChatMessage.getWhisperRecipients(flipData.target.actor.name).concat(ChatMessage.getWhisperRecipients("GM")) } );
        return; // Wait message response
      }
    }
    flipData.isReaction = false;
    this.takeWounds( flipData);
  }

   /* -------------------------------------------- */
   static reactionCover( uniqId) {
    let flipData = this.registry[uniqId];
    flipData.tn += flipData.coverSeverityLevel;
    flipData.isReaction = true;
    game.combat.decreaseAPFromActor( flipData.target.actor._id );
    SoSUtility.applyDamage( flipData);
   }

  /* -------------------------------------------- */
  static reactionMelee( uniqId) {
    let flipData = this.registry[uniqId];
    flipData.tn += flipData.defenderMelee;
    flipData.isReaction = true;
    game.combat.decreaseAPFromActor( flipData.target.actor._id );
    SoSUtility.applyDamage( flipData);
  }

  /* -------------------------------------------- */
  static reactionHit( uniqId) {
    let flipData = this.registry[uniqId];
    flipData.isReaction = true;
    SoSUtility.takeWounds( flipData);
  }
  
   /* -------------------------------------------- */
   static takeWounds( flipData ) {
    let defender = game.actors.get( flipData.target.actor._id);
    defender.applyWounds( flipData );
  }

  /* -------------------------------------------- */
  static async processItemDropEvent(actorSheet, event) {
    let dragData = JSON.parse(event.dataTransfer.getData("text/plain"));
    let dropID = $(event.target).parents(".item").attr("data-item-id"); // Only relevant if container drop
    let objectID = dragData.id || dragData.data._id;
    //console.log("drag/drop", dragData, actorSheet.actor._id, dropID, objectID);
    if (dragData.type == 'Item' && dropID) {
      actorSheet.actor.addObjectToContainer(objectID, dropID );
    }
    return true;
  }

}