/****************************************************************************
 **
 ** 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
     }
 }