/* ****************************************************************************
  This file is part of the game 'KJumpingCube'

  Copyright (C) 2012 by Ian Wadham <iandw.au@gmail.com>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

**************************************************************************** */
#ifndef AI_MAIN_H
#define AI_MAIN_H

#include <QList>
#include <QThread>
#include <QMutex>

#include <krandomsequence.h>

#include "ai_base.h"
#include "ai_box.h"

class ThreadedAI;

struct Move
{
   int index;
   int val;
};

/**
 * Class AI_Main computes a (good) possible move from a given position.
 *
 * It puts a value on every cube by looking at its neighbours and picks a
 * short list of likely cubes to move (it takes too long to check every
 * possible move).  It then simulates what would happen if you click on
 * these cubes.  This is all done recursively to a certain depth and the
 * position is valued.  The move that leads to the best position is chosen.
 *
 * @short The "computer player" of KJumpingCube.
 */

/**
 * Number of available skill-levels for computer players.  Must be consistent
 * with the Qt Designer form and the file "settings.ui" that it generates.
 */
const int nSkillLevels = 5;

/**
 * Extent of lookahead for each computer skill-level.  0 = perform moves and
 * evaluate the resulting positions, selecting the move with the best value
 * of those being considered.  n > 0 = perform n moves recursively, using
 * the MiniMax algorithm, then perform one more move and evaluate it, e.g.
 * depth 1 causes the computer to evaluate your responses to its moves.
 */
const int depths [nSkillLevels] = {0, 0, 1, 3, 5};

/**
 * The maximum number of moves considered at each level of lookahead.  This
 * limits the size of the move-tree and the amount of computation involved.
 * The most likely moves are chosen using values supplied by assessCube()
 * (see the AI_Kepler and AI_Newton classes for examples).
 */
const int maxBreadth = 4;

class AI_Main : public AI_Box
{
   // NOTE: Inheriting AI_Box gives AI_Main direct access to AI_Box's protected
   //       data arrays.  Speed of computation is essential here.
   Q_OBJECT
public:
   /**
   * The constructor for the KJumpingCube AI (or "computer player").
   */
   explicit AI_Main (QObject * parent, int side);
   virtual ~AI_Main();

   /**
   * Compute a good move for a player from a given position, providing either
   * a computer-player move or a hint for a human player.  The main calculation
   * is threaded and returns its result via signal "done (int index)".
   *
   * @param player  Player for whom a move is to be computed.
   * @param box     The player's position before the move.
   */
   void getMove (const Player player, const AI_Box * box);

   int computeMove();		// The threaded part of the move calculation.

   // QMutex endMutex;		// Use when stopping the threaded calculation?

   /**
    *  Stop the AI, but not till the end of the current cycle.  The AI will
    *  then return the best move found so far, via signal "done (int index)".
    */
   void stop();

   /**
    * Set skill and AI players according to current preferences or settings.
    */
   void setSkill (int skill1, bool kepler1, bool newton1,
                  int skill2, bool kepler2, bool newton2);

signals:
   /**
    * Signal the best move found after the AI search finishes or is stopped.
    *
    * @param index    The index, within the cube box, of the cube to move.
    */
   void done (int index);

private:
   ThreadedAI * m_thread;	// A thread to run computeMove() and tryMoves().

   Player     m_player;		// The player whose best move is to be found.

   int *      m_randomSeq;	// A random order for trying out moves.

   /**
   * Recursively check and evaluate moves available at a given position, using
   * the MiniMax algorithm.  The AI_Box instance (m_box) is used to store
   * positions and make moves that follow the KJumpingCube rules.  Instances of
   * AI_Base (such as m_AI_Kepler or m_AI_Newton) are used to assess possible
   * moves and the resulting positions.
   *
   * @param player  Player for whom moves are being evaluated.
   * @param level   Current level of recursion (i.e. level in move-tree).
   *
   * @return        The best move found and the value of the position reached.
   */
   Move tryMoves (Player player, int level);

   /**
   * Check a position to find moves that are likely to give good results.
   * Return at most maxBreadth moves, to reduce computation time in tryMoves().
   *
   * @param c2m       The array in which likely moves will be stored.
   * @param player    The player who is to move.
   * @param owners    The owner of each cube in the box.
   * @param values    The value of each cube in the box.
   * @param maxValues The maximum value of each cube in the box.
   *
   * @return          The number of likely moves found.
   */
   int findCubesToMove (Move * c2m, const Player player, const Player * owners,
                                    const int * values, const int * maxValues);

   /**
    * Make sure a cube box of the correct size is available as a workspace.
    *
    * @param side    The number of rows/columns in the cube box.
    */
   void checkWorkspace (const int side);

   AI_Base * m_AI_Kepler;	// Pointer to a Kepler-style player.
   AI_Base * m_AI_Newton;	// Pointer to a Newton-style player.

   AI_Base * m_ai [3];		// Pointers to AI players 1 and 2 (but not 0).
   int m_ai_skill [3];		// Skills of AI players 1 and 2 (but not 0).
   int m_ai_maxLevel [3];	// Lookahead of AI players 1 and 2 (but not 0).

   AI_Base * m_currentAI;	// Pointer to AI for current player.
   int  m_skill;		// Skill of the current player's AI.
   int  m_maxLevel;		// Maximum search depth for current player.

   int  m_currentLevel;		// Current search depth (or lookahead).

   bool m_stopped;		// True if the AI has to be stopped.

   KRandomSequence m_random;	// Random number generator.

#if AILog > 0
public:
   // Statistics-gathering procedures.
   // -------------------------------
   void startStats();
   void postMove (Player player, int index, int side);
   void dumpStats();
#endif

private:
   // Statistical data and methods.
   // -----------------------------
   struct SearchStats {
      int n_moves;
   };

   struct MoveStats {
      Player player;
      int moveNo;
      int x;
      int y;
      int value;
      int n_simulate;
      int n_assess;
      int nLikelyMoves;
      Move * likelyMoves;
      QList<SearchStats *> * searchStats;
   };

   int m_currentMoveNo;
#if AILog > 0
   MoveStats * m_currentMove;
   QList<MoveStats *> m_moveStats;

   int n_simulate;		// Number of moves simulated in the search.
   int n_assess;		// Number of positions assessed in the search.

   void boxPrint (int side, int * owners, int * values);

   QString tag (int level);
   void initStats (int player);
   void saveStats (Move & move);
   void saveLikelyMoves (int nMoves, Move * moves);
#endif
};

#endif //AI_MAIN_H
