class Attack {

  constructor(data) {

    // si aucun argument n'est passé, data sera indéfiné, donc si on fait data['quelque_chose'] le script renverra une erreur,
    // pour empêcher cette erreur, on remplace data par {} donc le cas où data n'est pas défini
    data = data || {};

    // data.spriteSheets est un tableau qui contient le nom des assets
    this.spriteSheetsData = data.spriteSheets || [];

    // on organise ça dans un objet pour faciliter l'accès
    this.spriteSheets = {};
    for (var i = 0; i < this.spriteSheetsData.length; i++) {
      this.spriteSheets[this.spriteSheetsData[i]] = null;
    }

    // les dégats de l'attaque
    this.damage = typeof data.damage !== 'undefined' ? data.damage : 4;

    // tous les "events"
    this.oncreate = typeof data.oncreate === 'function' ? data.oncreate : function(){};
    this.onstart = typeof data.onstart === 'function' ? data.onstart.bind({parent:this,caller:'onstart'}) : function(){};
    this.onend = typeof data.onend === 'function' ? data.onend.bind({parent:this,caller:'onend'}) : function(){};
    this.ondraw = typeof data.ondraw === 'function' ? data.ondraw.bind({parent:this,caller:'ondraw'}) : function(){};
    this.onupdate = typeof data.onupdate === 'function' ? data.onupdate : function(){};

    // l'état local de l'attaque
    this.state = 'onstart';

    // on stocke les données temporaires de l'état ici
    this.stateData = {};

    // on propose à l'utilisateur de mettre ces variables dedans (ce qui est conseillé pour éviter de réécrire des variables existantes)
    this.data = {};

  }

  /**
  * reset: permet de reset l'attaque
  */
  reset() {
    this.state = 'onstart'; // on revient à l'état initiale de l'attaque
    this.stateData = {};
    this.oncreate();
  }

  /**
  * init: permet d'initialiser l'attaque
  * @param game {Game} : un instancier de la classe Game
  */
  init(game) {

    // on stocke les variables dont on aura besoin
    this.game = game;
    this.assetManager = this.game.assetManager;
    this.area = this.game.area;
    this.player = this.game.player;

    // on "reset" l'attaque
    this.oncreate();

  }

  /**
  * run: permet de faire "tourner l'attaque", cette fonction est exécuté à 60FPS
  */
  run() {

    // on récupère le scope actuel, le "this" correspond à notre objet attaque (construit avec new Attack())
    var _this = this;

    // on ecécute la fonction "onstart", "ondraw", ou "onend" (à 60FPS)
    this[this.state](function(__this){

      // ici le "__this", correspond au scope lorsque qu'on ".bind" les 3 fonctions,
      // donc le "__this" contient ceci : {parent:_this,caller:...} (le "_this" est le même que celui juste au-dessus)
      // ainsi, comme leur variable "caller" porte leur nom, on est en mesure de savoir quelle fonction est appelée

      // l'objectif ici, c'est de faire en sorte que cette fonction ne soit appelé seulement une fois
      // (je rappele qu'on est dans une fonction qui est exécuté une centaine de fois par seconde)

      // si "_this.stateData[__this.caller]" est défini, c'est que la fonction a déjà été appelé à l'état "__this.caller"
      if (typeof _this.stateData[__this.caller] !== 'undefined') return;

      // si on arrive là, c'est la fonction next n'a jamais été appelé à cet état de l'attaque, donc on fais en sorte,
      // que ce soit le 1er appelle mais aussi surtout le dernier appelle
      _this.stateData[__this.caller] = true;

      // on passe à la fonction suivante
      if (_this.state == 'onstart') {
        _this.state = 'ondraw';
      } else if (_this.state == 'ondraw') {
        _this.state = 'onend';
      } else if (_this.state == 'onend') {
        _this.reset(); // reset attack
      }

    });
  }

  draw() {
    if (typeof this.ondraw === 'function') this.ondraw();
  }

  update() {
    if (typeof this.onupdate === 'function') this.onupdate();
  }

}