#ifndef MODEL_H
#define MODEL_H
#include "common.h"

#define MIN_BOARD_LEVEL 1
#define MAX_BOARD_LEVEL 2

// Constant character to represent the cross player, the round, none or both of
// them (this last one is usefull for tie game)
typedef enum {
  PLAYER_O = 'O',
  PLAYER_X = 'X',
  NOBODY = ' ',
  BOTH = '#'
} e_player;

// Constant defining the 9 possible positions in a tic tac toe, any of this
// position and none of this position
typedef enum {
  TOPLEFT,
  TOPCENTER,
  TOPRIGHT,
  MIDLEFT,
  MIDCENTER,
  MIDRIGHT,
  BOTTOMLEFT,
  BOTTOMCENTER,
  BOTTOMRIGHT,
  FREE,
  NONE
} e_location;

#define TICTACTOE_SIZE 9
#define TICTACTOE_WIDTH 3

// The tic tac toe structure
typedef struct {
  e_player *content;  // array of TICTACTOE_SIZE e_player defining content of
                      // each the TICTACTOE_SIZE cells of a tic tac toe defined
                      // from top left to bottom right
  e_player winner;  // player who have won the tic tac toe game; BOTH in case of
                    // a tie game
} s_tictactoe;

// A move structure
typedef struct {
  e_location inner_position;  // The position in the inner tic tac toe
  e_location outer_position;  // The position in the outer tic tact toe
  e_player player;            // The player who achieve the move
} s_move;

// A simple linked list of s_move
typedef struct list {
  s_move *last_move;
  struct list *next;
} list_element_s_move;

// The ultimate tic tac toe structure
typedef struct {
  uint inception_level;  // inception level of the ultimate tictactoe
  s_tictactoe *
      *inner_tictactoes;  // array of the TICTACTOE_SIZE inner tic tac
                          // toes defining content of each the
                          // TICTACTOE_SIZE cells of an ultimate tic tac
                          // toe defined from top left to bottom right
  s_tictactoe *
      outer_tictactoe;  // a tic tac toe representing the outer game which
                        // allows to store the winners of each inner tic tac toe
  list_element_s_move *history;  // full history of the played moves as a stack
                                 // of s_moves - LIFO ended by a NULL pointer.
} s_utictactoe;
/*
 * A uttt of inception-level 1 just correspond to the outer_tictactoe while
 * inner_tictactoes is NULL
 *
 * A uttt of inception-level 2 is an array of TICTACTOE_SIZE tictactoes from
 * TOP_LEFT to BOTTOM_RIGHT and outer_ticatactoe represent the overall game
 * Example of indices for a uttt of inception-level 1
 * 0|1|2
 * -----
 * 3|4|5
 * -----
 * 6|7|8
 */

/*!
 * This function allocates an s_move structure corresponding to an empty move
 * (free positions and nobody as player).
 *
 * \return a reference to the s_move memory space allocated, NULL in case of
 * allocation problem.
 */
s_move *create_empty_move();

/*!
 * This function allocates an s_tictactoe structure corresponding to an empty
 * tictactoe ready to be played.
 *
 * \return a reference to the s_tictactoe memory space allocated, NULL in case
 * of allocation problem.
 */
s_tictactoe *create_empty_tictactoe();

/*!
 * This function allocates an s_utictactoe structure corresponding to an empty
 * utictactoe of the corresponding inception_level and ready to be played
 * starting by PLAYER_X player.
 *
 * \return a reference to the s_utictactoe memory space allocated, NULL in case
 * of allocation problem.
 */
s_utictactoe *create_empty_utictactoe(uint inception_level);

/*!
 * This function free all the memory used by a given s_move which reference is
 * given.
 *
 * \param p_move a pointer on a s_move to be freed.
 */
void free_move(s_move *p_move);

/*!
 * This function free all the memory used by a given tictactoe structure which
 * reference is given.
 *
 * \param p_ttt a pointer on a s_tictactoe to be freed.
 */
void free_tictactoe(s_tictactoe *p_ttt);

/*!
 * This function free all the memory used by a given ultimate tictactoe
 * structure which reference is given.
 *
 * \param p_uttt a pointer on a s_utictactoe to be freed.
 */
void free_utictactoe(s_utictactoe *p_uttt);

/*!
 * This function determines the e_player which should be the next player to play
 * in the corresponding p_uttt.
 *
 * \param p_uttt a pointer on a s_utictactoe.
 * \return a e_player (PLAYER_X - if last player who played was PLAYER_O or its
 * the first move, PLAYER_O - if last player who played was PLAYER_X, or NOBODY
 * if no move can be done anymore or if there is a winner).
 */
e_player get_next_player_to_play(s_utictactoe *p_uttt);

/*!
 * This function determines the next outer position where the current player
 * should play its next move in the corresponding p_uttt.
 *
 * \param p_uttt a pointer on a s_utictactoe.
 * \return a e_location corresponding to the next outer position induced by the
 * last move
 * - set to FREE if the next move is free of constraints
 */
e_location get_next_outer_position(s_utictactoe *p_uttt);

/*!
 * This function evaluate if a move is valid in the corresponding p_uttt.
 * A move is valid if its player and the inner and outer positions are
 * consistent with the current s_utictactoe: correct unused position, not a
 * tictactoe with already a winner and the correct player. It returns a boolean
 * corresponding to the success of the move.
 *
 * \param p_uttt a pointer on a s_utictactoe.
 * \param a_move an s_move to be played.
 * \return YES if playing a_move was possible - NO if impossible.
 */
e_status is_move_valid(s_utictactoe *p_uttt, s_move *p_move);

/*!
 * This function set the winner of the corresponding p_ttt.
 *
 * \param p_ttt a pointer on a s_tictactoe whose winner field will be updated.
 */
void set_tictactoe_winner(s_tictactoe *p_ttt);

/*!
 * This function tries to play a given move in the corresponding p_uttt.
 * It plays the corresponding move if possible and returns a boolean
 * corresponding to the success of the move. The function should set the
 * possible winner.
 *
 * \param p_uttt a pointer on a s_utictactoe.
 * \param p_move an s_move to be played.
 * \return YES if playing a_move was possible - NO if impossible.
 */
e_status play_move(s_utictactoe *p_uttt, s_move *p_move);

/*Given usefull functions*/
void draw_utictactoe(s_utictactoe *p_uttt);
void draw_utictactoe_history(s_utictactoe *p_uttt);
#endif /* MODEL_H */