import { System } from '@serpentity/serpentity';

import WinnerNode from '../nodes/winner';
import PointsNode from '../nodes/points';

import Config from '../config';

/**
 * Handles finding the winner
 *
 * @extends {external:Serpentity.System}
 * @class DetectWinnerSystem
 * @param {object} config a configuration object to extend.
 */
export default class DetectWinnerSystem extends System {

  constructor(config = {}) {

    super();

    /**
     * The collection of points keepers
     *
     * @property {external:Serpentity.NodeCollection} pointsKeepers
     * @instance
     * @memberof DetectWinnerSystem
     */
    this.pointsKeepers = null;

    /**
     * The collection of winner keepers
     *
     * @property {external:Serpentity.NodeCollection} winnerKeepers
     * @instance
     * @memberof DetectWinnerSystem
     */
    this.winnerKeepers = null;
  }

  /**
   * Initializes system when added. Requests points and winner keepers
   *
   * @function added
   * @memberof DetectWinnerSystem
   * @instance
   * @param {external:Serpentity.Engine} engine the serpentity engine to
   * which we are getting added
   */
  added(engine) {

    this.pointsKeepers = engine.getNodes(PointsNode);
    this.winnerKeepers = engine.getNodes(WinnerNode);
  }

  /**
   * Clears system resources when removed.
   *
   * @function removed
   * @instance
   * @memberof DetectWinnerSystem
   */
  removed() {

    this.pointsKeepers = null;
    this.winnerKeepers = null;
  }

  /**
   * Runs on every update of the loop. Checks if someone won
   *
   * @function update
   * @instance
   * @param {Number} currentFrameDuration the duration of the current
   * frame
   * @memberof DetectWinnerSystem
   */
  update(currentFrameDuration) {

    let winner = null;

    for (const pointsKeeper of this.pointsKeepers) {
      for (const pointsCandidate of Object.keys(pointsKeeper.points)) {
        if (pointsKeeper.points[pointsCandidate] >= Config.maxPoints) {
          winner = pointsCandidate;
          break;
        }
      }
    }

    if (!winner) {
      return;
    }

    for (const winnerKeeper of this.winnerKeepers) {

      // Only one winner, another system should reset
      if (!winnerKeeper.winner.winner) {
        winnerKeeper.winner.winner = winner;
      }

    }
  }
}