/******************************
 * This file holds game states.
 ******************************/

/** [GAME STATE]
 *
 * ..squareOne...	= gameName
 * ..../...\.....
 * ...a.....b.... = gameMode
 * .....\./......
 * ......|.......
 * ...../.\......
 * .plus...minus. = gameOperation
 * .....\./......
 * ......|.......
 * ....1,2,3..... = gameDifficulty
 *
 * Character : tractor
 * Theme : farm
 * Concept : Player associates 'blocks carried by the tractor' and 'floor spaces to be filled by them'
 * Represent fractions as : blocks/rectangles
 *
 * Game modes can be :
 *
 *   a : Player can select # of 'floor blocks' (hole in the ground)
 *       Selects size of hole to be made in the ground (to fill with the blocks in front of the truck)
 *   b : Player can select # of 'stacked blocks' (in front of the truck)
 *       Selects number of blocks in front of the truck (to fill the hole on the ground)
 *
 * Operations can be :
 *
 *   plus : addition of fractions
 *     Represented by : tractor going to the right (floor positions 0..8)
 *   minus : subtraction of fractions
 *     Represented by: tractor going to the left (floor positions 8..0)
 *
 * @namespace
 */
const squareOne = {
  default: undefined,

  control: undefined,
  animation: undefined,

  tractor: undefined,
  stck: undefined,
  floor: undefined,

  help: undefined,
  message: undefined,
  continue: undefined,

  /**
   * Main code
   */
  create: function () {
    this.continue = {
      modal: undefined,
      button: undefined,
      text: undefined,
    };
    this.control = {
      direc: gameOperation == 'minus' ? -1 : 1, // Will be multiplied to values to easily change tractor direction when needed
      divisorsList: '', // Hold the divisors for each fraction on stacked blocks (created for postScore())
      lineWidth: 4,

      hasClicked: false, // Checks if player 'clicked' on a block
      checkAnswer: false, // When true allows game to run 'check answer' code in update
      isCorrect: false, // Checks player 'answer'

      count: 0, // An 'x' position counter used in the tractor animation
    };
    this.animation = {
      animateTractor: false, // When true allows game to run 'tractor animation' code in update (turns animation of the moving tractor ON/OFF)
      animateEnding: false, // When true allows game to run 'tractor ending animation' code in update (turns 'ending' animation of the moving tractor ON/OFF)
      speed: 2 * this.control.direc, // X distance in which the tractor moves in each iteration of the animation
    };
    const truckWidth = 201;
    this.default = {
      width: 172, // Base block width,
      height: 70, // Base block height
      x0:
        gameOperation == 'minus'
          ? context.canvas.width - truckWidth
          : truckWidth, // Initial 'x' coordinate for the tractor and stacked blocks
      y0: context.canvas.height - game.image['floor_grass'].width * 1.5,
    };
    const divisor = gameDifficulty == 3 ? 4 : gameDifficulty; // Make sure valid divisors are 1, 2 and 4 (not 3)

    renderBackground();

    // FOR MOODLE
    if (moodle) {
      navigation.add.right(['audio']);
    } else {
      navigation.add.left(['back', 'menu', 'show_answer'], 'customMenu');
      navigation.add.right(['audio']);
    }

    this.stack = {
      list: [],
      selectedIndex: undefined,
      correctIndex: undefined, // (gameMode 'b') index of the CORRECT 'stacked' block

      curIndex: 0, // (needs to be 0)

      curBlockEndX: undefined,
    };
    this.floor = {
      list: [],
      selectedIndex: undefined,
      correctIndex: undefined, // (gameMode 'a') index of the CORRECT 'floor' block

      curIndex: -1, // (needs to be -1)

      selectedX: undefined,
      correctX: undefined, // 'x' coordinate of CORRECT 'floor' block
      correctXA: undefined, // Temporary variable
      correctXB: undefined, // Temporary variable
    };

    let lineColor = undefined;
    let fillColor = undefined;
    if (gameOperation === 'minus') {
      lineColor = colors.red;
      fillColor = colors.redLight;
    } else {
      lineColor = colors.green;
      fillColor = colors.greenLight;
    }

    this.restart = this.utils.renderStackedBlocks(
      this.control.direc,
      lineColor,
      fillColor,
      this.control.lineWidth,
      divisor
    );
    this.utils.renderFloorBlocks(
      this.control.direc,
      lineColor,
      this.control.lineWidth,
      divisor
    );
    this.utils.renderCharacters();
    this.utils.renderUI(this.control.direc);

    if (!this.restart) {
      game.timer.start(); // Set a timer for the current level (used in postScore())
      game.event.add('click', this.events.onInputDown);
      game.event.add('mousemove', this.events.onInputOver);
    }
  },

  /**
   * Game loop
   */
  update: function () {
    // Starts tractor animation
    if (self.animation.animateTruck) {
      self.utils.animateTruck();
    }

    // Check answer after animation ends
    if (self.control.checkAnswer) {
      self.utils.checkAnswer();
    }

    // Starts tractor moving animation
    if (self.animation.animateEnding) {
      self.utils.animateEnding();
    }

    game.render.all();
  },

  utils: {
    // RENDER
    /**
     * Create stacked blocks for the level in create()
     *
     * @returns {boolean}
     */
    renderStackedBlocks: function (
      direc,
      lineColor,
      fillColor,
      lineWidth,
      divisor
    ) {
      let restart = false;
      let hasBaseDifficulty = false; // Will be true after next for loop if level has at least one '1/difficulty' fraction (if false, restart)

      const max = gameMode == 'b' ? 10 : curMapPosition + 4; // Maximum number of stacked blocks for the level
      const total = game.math.randomInRange(curMapPosition + 2, max); // Current number of stacked blocks for the level

      self.floor.correctXA = self.default.x0 + self.default.width * direc;
      for (let i = 0; i < total; i++) {
        let curFractionItems = undefined;
        let font = undefined;

        let curDivisor = game.math.randomInRange(1, gameDifficulty); // Set divisor for fraction
        if (curDivisor === gameDifficulty) hasBaseDifficulty = true;
        if (curDivisor === 3) curDivisor = 4; // Make sure valid divisors are 1, 2 and 4 (not 3)

        const curBlockWidth = self.default.width / curDivisor; // Current width is a fraction of the default
        self.control.divisorsList += curDivisor + ','; // List of divisors (for postScore())
        self.floor.correctXA += curBlockWidth * direc;

        const curBlock = game.add.geom.rect(
          self.default.x0,
          self.default.y0 - i * self.default.height,
          curBlockWidth,
          self.default.height,
          lineColor,
          lineWidth,
          fillColor,
          1
        );
        curBlock.anchor(gameOperation === 'minus' ? 1 : 0, 1);
        curBlock.blockValue = divisor / curDivisor;

        // If game mode is (b), adding events to stacked blocks
        if (gameMode == 'b') {
          curBlock.alpha = 0.5;
          curBlock.blockIndex = i;
        }

        self.stack.list.push(curBlock);

        // If 'show fractions' is turned on, create labels that display the fractions on the side of each block
        if (showFractions) {
          const x = self.default.x0 + (curBlockWidth + 40) * direc;
          const y = self.default.height;

          if (curDivisor === 1) {
            font = textStyles.h2_;
            curFractionItems = [
              {
                x: x,
                y: self.default.y0 - i * y - 20,
                text: gameOperation === 'minus' ? '-1' : '1',
              },
            ];
          } else {
            font = textStyles.p_;
            curFractionItems = [
              {
                x: x,
                y: self.default.y0 - i * y - 10,
                text: curDivisor,
              },
              {
                x: x,
                y: self.default.y0 - i * y - 40,
                text: '1',
              },
              {
                x: x,
                y: self.default.y0 - i * y - 37,
                text: '__',
              },
              {
                x: x - 25,
                y: self.default.y0 - i * y - 27,
                text: gameOperation === 'minus' ? '-' : '',
              },
            ];
          }
          font = { ...font, font: 'bold ' + font.font, fill: lineColor };

          const fractionPartsList = [];
          for (let cur in curFractionItems) {
            fractionPartsList.push(
              game.add.text(
                curFractionItems[cur].x,
                curFractionItems[cur].y,
                curFractionItems[cur].text,
                font
              )
            );
          }

          curBlock.fraction = { labels: fractionPartsList };
        }
      }

      // Computer generated correct stack index
      if (gameMode === 'a') self.stack.selectedIndex = total - 1;

      // Will be used as a counter in update, adding in the width of each stacked block to check if the end matches the floor selected position
      // initial value is end of current block
      self.stack.curBlockEndX =
        self.default.x0 + self.stack.list[0].width * direc;

      // Check for errors (level too easy for its difficulty or end position out of bounds)
      if (
        !hasBaseDifficulty ||
        (gameOperation == 'plus' &&
          (self.floor.correctXA < self.default.x0 + self.default.width ||
            self.floor.correctXA > self.default.x0 + 8 * self.default.width)) ||
        (gameOperation == 'minus' &&
          (self.floor.correctXA < self.default.x0 - 8 * self.default.width ||
            self.floor.correctXA > self.default.x0 - self.default.width))
      ) {
        restart = true; // If any error is found restart the level
      }

      if (isDebugMode)
        console.log(
          'Stacked blocks: ' +
            total +
            ' (min: ' +
            (curMapPosition + 2) +
            ', max: ' +
            max +
            ')'
        );

      return restart;
    },
    /**
     * Create floor blocks for the level in create()
     */
    renderFloorBlocks: function (direc, lineColor, lineWidth, divisor) {
      let total = 8 * divisor; // Number of floor blocks

      const blockWidth = self.default.width / divisor; // Width of each floor block

      // If game is type (b), selectiong a random floor x position
      if (gameMode == 'b') {
        self.stack.correctIndex = game.math.randomInRange(
          0,
          self.stack.list.length - 1
        ); // Correct stacked index

        self.floor.correctXB = self.default.x0 + self.default.width * direc;

        for (let i = 0; i <= self.stack.correctIndex; i++) {
          self.floor.correctXB += self.stack.list[i].width * direc; // Equivalent x position on the floor
        }
      }

      let flag = true;

      for (let i = 0; i < total; i++) {
        const curX =
          self.default.x0 + (self.default.width + i * blockWidth) * direc;

        if (flag && gameMode == 'a') {
          if (
            (gameOperation == 'plus' && curX >= self.floor.correctXA) ||
            (gameOperation == 'minus' && curX <= self.floor.correctXA)
          ) {
            self.floor.correctIndex = i - 1; // Set index of correct floor block
            flag = false;
          }
        }

        if (gameMode == 'b') {
          if (
            (gameOperation == 'plus' && curX >= self.floor.correctXB) ||
            (gameOperation == 'minus' && curX <= self.floor.correctXB)
          ) {
            total = i;
            break;
          }
        }

        // Create floor block
        const curBlock = game.add.geom.rect(
          curX,
          self.default.y0,
          blockWidth,
          self.default.height - 20,
          lineColor,
          lineWidth,
          colors.blueBgInsideLevel,
          1
        );
        const anchor = gameOperation == 'minus' ? 1 : 0;
        curBlock.anchor(anchor, 0);
        curBlock.blockValue = 1;

        // If game is type (a), adding events to floor blocks
        if (gameMode == 'a') {
          curBlock.alpha = 0.5;
          curBlock.blockIndex = i;
        }

        // Add current label to group of labels
        self.floor.list.push(curBlock);
      }

      // Computer generated correct floor index
      if (gameMode === 'b') self.floor.selectedIndex = total - 1;

      if (gameMode == 'a') self.floor.correctX = self.floor.correctXA;
      else if (gameMode == 'b') self.floor.correctX = self.floor.correctXB;

      // Creates labels on the floor to display the numbers
      for (let i = 0; i <= 8; i++) {
        const x = self.default.x0 + (i + 1) * self.default.width * direc;
        const y = self.default.y0 + self.default.height + 45;
        game.add.geom
          .circle(x, y, 60, undefined, 0, colors.white, 0.8)
          .anchor(0, 0.25);
        game.add.text(
          gameOperation === 'minus' ? x - 2 : x,
          y,
          gameOperation === 'minus' ? -i : i,
          {
            ...textStyles.h3_,
            font: 'bold ' + textStyles.h3_.font,
            fill: lineColor,
          }
        );
      }
    },
    renderCharacters: function () {
      self.tractor = game.add.sprite(
        self.default.x0,
        self.default.y0,
        'tractor',
        0,
        1
      );

      if (gameOperation == 'plus') {
        self.tractor.anchor(1, 1);
        self.tractor.animation = ['move', [0, 1, 2, 3, 4], 4];
      } else {
        self.tractor.anchor(0, 1);
        self.tractor.animation = ['move', [5, 6, 7, 8, 9], 4];
        self.tractor.curFrame = 5;
      }
    },
    renderUI: function (direc) {
      // Help pointer
      self.help = game.add.image(0, 0, 'pointer', 1.7, 0);

      if (gameMode === 'b') self.help.anchor(0.25, 0.7);
      else self.help.anchor(0.2, 0);

      // Selection Arrow
      if (gameMode == 'a') {
        self.arrow = game.add.image(
          self.default.x0 + self.default.width * direc,
          self.default.y0,
          'arrow_down',
          1.5
        );
        self.arrow.anchor(0.5, 1);
        self.arrow.alpha = 0.5;
      }

      // Intro text
      const correctMessage =
        gameMode === 'a'
          ? game.lang.squareOne_intro_a
          : game.lang.squareOne_intro_b;
      const treatedMessage = correctMessage.split('\\n');
      self.message = [];
      self.message.push(
        game.add.text(
          context.canvas.width / 2,
          170,
          treatedMessage[0],
          textStyles.h1_
        )
      );
      self.message.push(
        game.add.text(
          context.canvas.width / 2,
          220,
          treatedMessage[1],
          textStyles.h1_
        )
      );

      // continue button
      self.continue.modal = game.add.geom.rect(
        0,
        0,
        context.canvas.width,
        context.canvas.height,
        undefined,
        0,
        colors.white,
        0
      );
      self.continue.button = game.add.geom.rect(
        context.canvas.width / 2,
        context.canvas.height / 2 + 200,
        300,
        100,
        undefined,
        0,
        colors.green,
        0
      );
      self.continue.button.anchor(0.5, 0.5);
      self.continue.text = game.add.text(
        context.canvas.width / 2,
        context.canvas.height / 2 + 16 + 200,
        game.lang.continue,
        textStyles.btn
      );
      self.continue.text.alpha = 0;
    },

    // UPDATE
    animateTruck: () => {
      const stack = self.stack;
      const floor = self.floor;

      // Move
      self.tractor.x += self.animation.speed;
      stack.list.forEach((block) => (block.x += self.animation.speed));

      // If the current block is 1/n (not 1/1) we need to consider the
      // extra space the truck needs to pass after the blocks falls but
      // before reaching the next block
      const curBlockExtra =
        (self.default.width - stack.list[stack.curIndex].width) *
        self.control.direc;

      const hasPassedCurBlock =
        (gameOperation == 'plus' &&
          stack.list[0].x >= stack.curBlockEndX + curBlockExtra) ||
        (gameOperation == 'minus' &&
          stack.list[0].x <= stack.curBlockEndX + curBlockExtra);
      if (hasPassedCurBlock) {
        const endAnimation = self.utils.lowerBlocksHandler(stack, floor);

        if (!endAnimation) {
          self.animation.animateTruck = false;
          self.control.checkAnswer = true;
        }
      }
    },
    lowerBlocksHandler: (stack, floor) => {
      floor.curIndex += stack.list[stack.curIndex].blockValue;

      const tooManyStackBlocks = floor.curIndex > floor.selectedIndex;
      if (tooManyStackBlocks) {
        return false;
      }

      // fill floor
      for (let i = 0; i <= floor.curIndex; i++) {
        floor.list[i].alpha = 0.5;
      }
      // lower blocks
      stack.list.forEach((block) => {
        block.y += self.default.height;
      });
      // hide current block
      stack.list[stack.curIndex].alpha = 0;

      const isLastFloorBlock = floor.curIndex === floor.selectedIndex;
      const notEnoughStackBlocks = stack.curIndex === stack.list.length - 1;

      if (isLastFloorBlock || notEnoughStackBlocks) {
        return false;
      }

      // update stack blocks
      stack.curIndex++;
      stack.curBlockEndX +=
        stack.list[stack.curIndex].width * self.control.direc;

      return true;
    },
    checkAnswer: () => {
      game.timer.stop();

      game.animation.stop(self.tractor.animation[0]);

      self.control.isCorrect =
        gameMode === 'a'
          ? self.floor.selectedIndex === self.floor.correctIndex
          : self.stack.selectedIndex === self.stack.correctIndex;

      // Give feedback to player and turns on sprite animation
      if (self.control.isCorrect) {
        game.animation.play(self.tractor.animation[0]);
        game.add
          .image(
            context.canvas.width / 2,
            context.canvas.height / 2,
            'answer_correct'
          )
          .anchor(0.5, 0.5);
        if (audioStatus) game.audio.okSound.play();

        completedLevels++; // Increases number os finished levels
        if (isDebugMode) console.log('Completed Levels: ' + completedLevels);
      } else {
        game.add
          .image(
            context.canvas.width / 2,
            context.canvas.height / 2,
            'answer_wrong'
          )
          .anchor(0.5, 0.5);
        if (audioStatus) game.audio.errorSound.play();
      }

      self.fetch.postScore();

      // AFTER CHECK ANSWER
      self.control.checkAnswer = false;
      self.animation.animateEnding = true;
    },
    animateEnding: () => {
      // ANIMATE ENDING

      self.control.count++;

      // If CORRECT ANSWER runs final tractor animation (else tractor desn't move, just wait)
      if (self.control.isCorrect) self.tractor.x += self.animation.speed;

      // WHEN REACHED END POSITION calls map state
      if (self.count >= 140) {
        // If CORRECT ANSWER, player goes to next level in map
        if (self.control.isCorrect) canGoToNextMapPosition = true;
        else canGoToNextMapPosition = false;

        game.state.start('map');
      }
    },

    // INFORMATION
    /**
     * Display correct answer
     */
    showAnswer: function () {
      if (!self.control.hasClicked) {
        // On gameMode (a)
        if (gameMode == 'a') {
          const aux = self.floor.list[0];
          self.help.x =
            self.floor.correctX - (aux.width / 2) * self.control.direc;
          self.help.y = self.default.y0;
          // On gameMode (b)
        } else {
          const aux = self.stack.list[self.stack.correctIndex];
          self.help.x = aux.x + (aux.width / 2) * self.control.direc;
          self.help.y = aux.y;
        }

        self.help.alpha = 0.7;
      }
    },
    showEndInfo: function () {
      let color;
      //let text;
      if (self.control.isCorrect) {
        color = colors.green;
        //text = game.lang.continue;
      } else {
        color = colors.red;
        //text = game.lang.retry;
      }
      self.continue.modal.alpha = 0.25;
      // self.continue.text.name = text;
      self.continue.text.alpha = 1;
      self.continue.button.fillColor = color;
      self.continue.button.alpha = 1;
    },

    // HANDLERS
    /**
     * Function called by self.events.onInputDown() when player clicks on a valid rectangle.
     */
    clickSquareHandler: function (clickedIndex, curSet) {
      if (!self.control.hasClicked && !self.animation.animateEnding) {
        document.body.style.cursor = 'auto';
        // Play beep sound
        if (audioStatus) game.audio.popSound.play();

        // Hide labels
        if (showFractions) {
          self.stack.list.forEach((block) => {
            block.fraction.labels.forEach((lbl) => {
              lbl.alpha = 0;
            });
          });
        }
        // Hide solution pointer
        if (self.help != undefined) self.help.alpha = 0;
        // Hide unselected blocks
        for (let i = curSet.list.length - 1; i > clickedIndex; i--) {
          curSet.list[i].alpha = 0;
        }

        // Save selected index
        curSet.selectedIndex = clickedIndex;

        if (gameMode == 'a') {
          self.arrow.alpha = 1;
        } else {
          // update list size
          self.stack.list.length = curSet.selectedIndex + 1;
        }

        self.floor.selectedX =
          self.floor.list[self.floor.selectedIndex].x +
          self.floor.list[0].width * self.control.direc;

        // Turn tractor animation on
        game.animation.play(self.tractor.animation[0]);
        self.animation.animateTruck = true;
        self.control.hasClicked = true;
      }
    },
    /**
     * Function called by self.events.onInputOver() when cursor is over a valid rectangle
     *
     * @param {object} cur rectangle the cursor is over
     */
    overSquareHandler: function (cur) {
      if (!self.control.hasClicked) {
        document.body.style.cursor = 'pointer';

        // On gameMode (a)
        if (gameMode == 'a') {
          for (let i in self.floor.list) {
            self.floor.list[i].alpha = i <= cur.blockIndex ? 1 : 0.5;
          }

          // Saves the index of the selected 'floor' block
          self.floor.selectedIndex = cur.blockIndex;

          // On gameMode (b)
        } else {
          for (let i in self.stack.list) {
            self.stack.list[i].alpha = i <= cur.blockIndex ? 0.5 : 0.2;
          }

          // Saves the index of the selected 'stack' block
          self.stack.selectedIndex = cur.blockIndex;
        }
      }
    },
    /**
     * Function called by self.events.onInputOver() when cursos is out of a valid rectangle
     */
    outSquareHandler: function () {
      if (!self.control.hasClicked) {
        document.body.style.cursor = 'auto';

        // On game mode (a)
        if (gameMode == 'a') {
          for (let i in self.floor.list) {
            self.floor.list[i].alpha = 0.5; // Back to normal
          }

          self.floor.selectedIndex = undefined;
          // On game mode (b)
        } else {
          for (let i in self.stack.list) {
            self.stack.list[i].alpha = 0.5; // Back to normal
          }

          self.stack.selectedIndex = undefined;
        }
      }
    },
  },

  events: {
    /**
     * Called by mouse click event
     *
     * @param {object} mouseEvent contains the mouse click coordinates
     */
    onInputDown: function (mouseEvent) {
      const x = game.math.getMouse(mouseEvent).x;
      const y = game.math.getMouse(mouseEvent).y;

      const curSet = gameMode == 'a' ? self.floor : self.stack;

      for (let i in curSet.list) {
        if (game.math.isOverIcon(x, y, curSet.list[i])) {
          self.utils.clickSquareHandler(+i, curSet);
          break;
        }
      }

      navigation.onInputDown(x, y);

      game.render.all();
    },

    /**
     * Called by mouse move event
     *
     * @param {object} mouseEvent contains the mouse move coordinates
     */
    onInputOver: function (mouseEvent) {
      const x = game.math.getMouse(mouseEvent).x;
      const y = game.math.getMouse(mouseEvent).y;
      let flagA = false;
      let flagB = false;

      if (gameMode == 'a') {
        // Make arrow follow mouse
        if (!self.control.hasClicked && !self.animation.animateEnding) {
          if (
            game.math.distanceToPointer(self.arrow.x, x, self.arrow.y, y) > 8
          ) {
            self.arrow.x = x < 250 ? 250 : x; // Limits the arrow left position to 250
          }
        }

        self.floor.list.forEach((cur) => {
          if (game.math.isOverIcon(x, y, cur)) {
            flagA = true;
            self.utils.overSquareHandler(cur);
          }
        });

        if (!flagA) self.utils.outSquareHandler('a');
      }

      if (gameMode == 'b') {
        self.stack.list.forEach((cur) => {
          if (game.math.isOverIcon(x, y, cur)) {
            flagB = true;
            self.utils.overSquareHandler(cur);
          }
        });

        if (!flagB) self.utils.outSquareHandler('b');
      }

      navigation.onInputOver(x, y);

      game.render.all();
    },
  },

  fetch: {
    /**
     * Saves players data after level ends - to be sent to database <br>
     *
     * Attention: the 'line_' prefix data table must be compatible to data table fields (MySQL server)
     *
     * @see /php/save.php
     */
    postScore: function () {
      // Creates string that is going to be sent to db
      const data =
        '&line_game=' +
        gameShape +
        '&line_mode=' +
        gameMode +
        '&line_oper=' +
        gameOperation +
        '&line_leve=' +
        gameDifficulty +
        '&line_posi=' +
        curMapPosition +
        '&line_resu=' +
        self.control.isCorrect +
        '&line_time=' +
        game.timer.elapsed +
        '&line_deta=' +
        'numBlocks:' +
        self.stack.list.length +
        ', valBlocks: ' +
        self.control.divisorsList + // Ends in ','
        ' blockIndex: ' +
        self.stack.selectedIndex +
        ', floorIndex: ' +
        self.floor.selectedIndex;

      // FOR MOODLE
      sendToDatabase(data);
    },
  },
};