/****************************************************************************
  **
  ** Copyright (C) 2017 The Qt Company Ltd.
  ** Contact: https://www.qt.io/licensing/
  **
  ** This file is part of the QtSensors module of the Qt Toolkit.
  **
  ** $QT_BEGIN_LICENSE:BSD$
  ** Commercial License Usage
  ** Licensees holding valid commercial Qt licenses may use this file in
  ** accordance with the commercial license agreement provided with the
  ** Software or, alternatively, in accordance with the terms contained in
  ** a written agreement between you and The Qt Company. For licensing terms
  ** and conditions see https://www.qt.io/terms-conditions. For further
  ** information use the contact form at https://www.qt.io/contact-us.
  **
  ** BSD License Usage
  ** Alternatively, you may use this file under the terms of the BSD license
  ** as follows:
  **
  ** "Redistribution and use in source and binary forms, with or without
  ** modification, are permitted provided that the following conditions are
  ** met:
  **   * Redistributions of source code must retain the above copyright
  **     notice, this list of conditions and the following disclaimer.
  **   * Redistributions in binary form must reproduce the above copyright
  **     notice, this list of conditions and the following disclaimer in
  **     the documentation and/or other materials provided with the
  **     distribution.
  **   * Neither the name of The Qt Company Ltd nor the names of its
  **     contributors may be used to endorse or promote products derived
  **     from this software without specific prior written permission.
  **
  **
  ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
  **
  ** $QT_END_LICENSE$
  **
  ****************************************************************************/

  /* Layout
                                  mainWnd
                                 /
  ------------------------------/ gameRect
  |                              /
  |-----------------------------/
  ||---------------------------|
  ||||M|                      ||
  |||   \                     ||
  |||    mouseCtrl            ||
  |||                         ||
  |||                         ||
  |||     Labyrinth           ||
  |||                         ||
  |||                         ||
  |||        cheeseSquare     ||
  |||                     \   ||
  |||                      |C|||
  ||---------------------------|
  |-----------------------------
  |
  |-----------------------------
  ||             ||            |
  |-----------------------------
  |       \          \
  |        \          timePlayingLabel
  |         newGameButton
  ------------------------------

  */
  //Import the declarative plugins
  import QtQuick 2.0
  import "components"

  import QtSensors 5.0

  //Import the javascript functions for this game
  import "lib.js" as Lib

  ApplicationWindow {
      id: mainWnd

      property Mouse mouseCtrl;
      property LabyrinthSquare cheeseSquare;
      property Congratulation congratulation;

      Rectangle {
          id: gameRect
          x: (mainWnd.width - width) / 2
          y: 5
          width: Lib.dimension * Lib.cellDimension
          height: Lib.dimension * Lib.cellDimension
          color: "transparent"
          border.width: 2

          //timer for starting the labyrinth game
          Timer {
              id: startTimer
              interval: 50; running: true; repeat: false
              onTriggered: {

                  //reset game time
                  timePlayingLabel.text = "--";
                  Lib.sec = 0.0;
                  Lib.createLabyrinth();

                  //create labyrinth elements (only at the first time)
                  var needloadcomponent = false;
                  if (Lib.objectArray === null) {
                      needloadcomponent = true;
                      Lib.objectArray = new Array(Lib.dimension * Lib.dimension);
                  }
                  var idx = 0;
                  for (var y = 0; y < Lib.dimension; y++ ) {
                      for (var x = 0; x < Lib.dimension; x++ ) {
                          var component = null;

                          //create labyrinth components (only at the first time)
                          if (needloadcomponent) {
                              component = Qt.createComponent("LabyrinthSquare.qml");
                              if (component.status == Component.Ready) {
                                  var square = component.createObject(parent);
                                  square.x = x * square.width;
                                  square.y = y * square.height;
                                  square.val = Lib.labyrinth[x][y];
                                  square.updateImage();
                                  Lib.objectArray[idx] = square;
                                  if (x == (Lib.dimension - 1) && y == (Lib.dimension - 1)) {
                                      cheeseSquare = square;
                                      var component1 = Qt.createComponent("Congratulation.qml");
                                      if (component1.status == Component.Ready) {
                                          congratulation = component1.createObject(parent);
                                          congratulation.visible = false;
                                      }
                                  }
                              }
                          }
                          else{
                              Lib.objectArray[idx].val = Lib.labyrinth[x][y];
                              Lib.objectArray[idx].updateImage();
                              if (x == (Lib.dimension - 1) && y == (Lib.dimension - 1)) {
                                  cheeseSquare = Lib.objectArray[idx];
                                  congratulation.visible = false;
                              }
                          }
                          idx++;
                      }
                  }

                  //Lib.printLab(); //this is for debug. Labyrinth will be printed out in the console

                  //Create the mouse control  (only at the first time)
                  if (mouseCtrl === null) {
                      var component = Qt.createComponent("Mouse.qml");
                      if (component.status == Component.Ready) {
                          mouseCtrl = component.createObject(parent);
                      }
                  }
                  mouseCtrl.x = 0;
                  mouseCtrl.y = 0;
                  newGameButton.enabled = true;

                  //Start the Tilt reader timer
                  tiltTimer.running = true;
              }
          }
      }

      TiltSensor {
          id: tiltSensor
          active: true
      }

      //Timer to read out the x and y rotation of the TiltSensor
      Timer {
          id: tiltTimer
          interval: 50; running: false; repeat: true

          onTriggered: {
              if (!tiltSensor.enabled)
                  tiltSensor.active = true;

              if (mouseCtrl === null)
                  return;

              //check if already solved
              if (Lib.won !== true) {
                  Lib.sec += 0.05;
                  timePlayingLabel.text = Math.floor(Lib.sec) + " seconds";

                  //check if we can move the mouse
                  var xval = -1;
                  var yval = -1;

                  var xstep = 0;
                  xstep = tiltSensor.reading.yRotation * 0.1 //acceleration

                  var ystep = 0;
                  ystep = tiltSensor.reading.xRotation * 0.1 //acceleration
                  if (xstep < 1 && xstep > 0)
                      xstep = 0
                  else if (xstep > -1 && xstep < 0)
                      xstep = 0

                  if (ystep < 1 && ystep > 0)
                      ystep = 0;
                  else if (ystep > -1 && ystep < 0)
                      ystep = 0;

                  if ((xstep < 0 && mouseCtrl.x > 0
                       && Lib.canMove(mouseCtrl.x + xstep,mouseCtrl.y))) {
                      xval = mouseCtrl.x + xstep;

                  } else if (xstep > 0 && mouseCtrl.x < (Lib.cellDimension * (Lib.dimension - 1))
                      && Lib.canMove(mouseCtrl.x + xstep,mouseCtrl.y)) {
                      xval = mouseCtrl.x + xstep;
                  } else
                      xval = mouseCtrl.x;

                  if (ystep < 0 && mouseCtrl.y > 0
                       && Lib.canMove(mouseCtrl.x, mouseCtrl.y + ystep)) {
                      yval = mouseCtrl.y + ystep;
                  } else if (ystep > 0 && (mouseCtrl.y < (Lib.cellDimension * (Lib.dimension - 1)))
                           && Lib.canMove(mouseCtrl.x, mouseCtrl.y + ystep)) {
                      yval = mouseCtrl.y + ystep;
                  } else
                      yval = mouseCtrl.y

                  mouseCtrl.move(xval, yval);

              } else {
                  //game won, stop the tilt meter
                  mainWnd.cheeseSquare.val = 4;
                  mainWnd.cheeseSquare.updateImage();
                  mainWnd.congratulation.visible = true;
                  newGameButton.enabled = true;
                  tiltTimer.running = false;
              }
          }
      }

      //Button to start a new Game
      Button{
          id: newGameButton
          anchors.left: gameRect.left
          anchors.top: gameRect.bottom
          anchors.topMargin: 5
          height: 30
          width: 100
          text: "new game"
          enabled: false;
          onClicked: {
              newGameButton.enabled = false;
              startTimer.start();
          }
      }
      Button{
          id: calibrateButton
          anchors.left: gameRect.left
          anchors.top: newGameButton.bottom
          anchors.topMargin: 5
          height: 30
          width: 100
          text: "calibrate"
          onClicked: {
              tiltSensor.calibrate();
          }
      }

      //Label to print out the game time
      Text{
          id: timePlayingLabel
          anchors.right: gameRect.right
          anchors.top: gameRect.bottom
          anchors.topMargin: 5
      }
  }