#include "tic_tac_toe.hpp"

#pragma once
 
#include <vector>
#include <string>

class Tic_Tac_Toe
{
  public:
    Tic_Tac_Toe();                    /* Constructor */
    void Clear_Game();                /* Turn the current board into an empty board */
    char Game_State() const;          /* Return the state of the game:
                                           'B' = beginning of game
                                           'X' = X's turn
                                           'O' = O's turn
                                           'x' = Game is over and X has won.
                                           'o' = Game is over and O has won.
                                           'd' = Game is over and it's a draw. */

    char Make_Move(char xo, size_t row, size_t col);  /* This does the move.  
                                                         xo must be 'X' or 'O'.
                                                         Returns 'E' on an error.
                                                         Otherwise it returns resulting game state. */

    void Print() const;                         /* Prints the board. */
    std::string Board_String() const;           /* Returns a 9-character string of X's, O's and -'s */
    void Stats(std::vector <int> &xod) const;   /* Sets xod to a three element vector: 
                                                   X wins, O wins, draws */

  protected:
    std::vector <std::string> Board;    /* The board */
    char State;                         /* Game state -- same values as Game_State() above */
    std::vector <int> X_O_D;            /* The three stats */
    int Open_Squares;                   /* The number of open squares on the board. */
};

/* This implementation file simply has dummy methods for every method in the class.
   It allows me to write a testing program and have it compile.  Then, I'll start
   to implement the methods. */

#include "tic_tac_toe.hpp"
using namespace std;

Tic_Tac_Toe::Tic_Tac_Toe() {}

void Tic_Tac_Toe::Clear_Game() {}

void Tic_Tac_Toe::Print() const {}

char Tic_Tac_Toe::Game_State() const { return '-'; }

string Tic_Tac_Toe::Board_String() const { return "-"; }

void Tic_Tac_Toe::Stats(vector <int> &xod) const 
{ 
  xod.resize(3, 0); 
}

char Tic_Tac_Toe::Make_Move(char xo, size_t row, size_t col) 
{ 
  (void) xo;        // These statements shut the compiler up about not using the parameters.
  (void) row;
  (void) col;
  return 'E'; 
}

#include "tic_tac_toe.hpp"
#include <iostream>
#include <sstream>
#include <vector>
#include <cstdio>
#include <string>
using namespace std;

/* It's good to put this in a procedure at the beginning of your file -- that
   way you know where it is for reference, while you're writing the program. */

void print_commands()
{
  cout << "usage: ttt_tester -- commands on stdin." << endl;
  cout << endl;
  cout << "commands:" << endl;
  cout << "  C            - Clear game state." << endl;
  cout << "  GS           - Print the game state char." << endl;
  cout << "  P            - Print the board." << endl;
  cout << "  BS           - Print the Board String." << endl;
  cout << "  S            - Print stats." << endl;
  cout << "  M X/O R C    - Move X or O to space at row R, col C." << endl;
  cout << "  Q            - Quit." << endl;
  cout << "  ?            - Print commands." << endl;
}


int main()
{
  string s, line;         // I use these to read a line of text and turn it into a 
  vector <string> sv;     // vector of strings (which is in sv).
  istringstream ss;

  Tic_Tac_Toe ttt;        // Here's my tic-tac-toe game.
  vector <int> stats;     // This is for when I call ttt.Stats()

  int row, col;           // These are for the ttt.Make_Move(xo, row, col) call.
  char xo;

  while (1) {
 
    /* Print a prompt, and read in a line. */

    cout << "TTT> ";
    cout.flush();
    if (!getline(cin, line)) return 0;

    /* Use a stringstream to turn the line into a vector of words. */

    sv.clear();
    ss.clear();
    ss.str(line);
    while (ss >> s) sv.push_back(s);

    /* Ignore blank lines and lines that start with the pound sign. */

    if (sv.size() == 0 || sv[0][0] == '#') {

    /* Handle the simple commands: */

    } else if (sv[0] == "P") {
      ttt.Print();
    } else if (sv[0] == "C") {
      ttt.Clear_Game();
    } else if (sv[0] == "GS") {
      printf("%c\n", ttt.Game_State());
    } else if (sv[0] == "BS") {
      printf("%s\n", ttt.Board_String().c_str());

    /* Stats */

    } else if (sv[0] == "S") {
      ttt.Stats(stats);
      printf("X Wins: %4d\n", stats[0]);
      printf("O Wins: %4d\n", stats[1]);
      printf("Draws:  %4d\n", stats[2]);

    /* Make a move.  
       You'll note that I'm not using a stringstream for row/col.  This code
       is simpler, and since row and col have to be between 0 and 2, it works
       just fine.  You'll note that I'm not doing much error-checking here.
       That will be handled in Make_Move() which returns 'E' if it is called
       incorrectly.  */

    } else if (sv[0] == "M") {
      if (sv.size() != 4) {
        printf("Usage M X/O row col\n");
      } else {
        xo = sv[1][0];
        row = sv[2][0] - '0';
        col = sv[3][0] - '0';
        printf("Result of move: %c\n", ttt.Make_Move(xo, row, col));
      }

    /* Quit, print commands or a bad command. */

    } else if (sv[0] == "Q") {
      return 0;
    } else if (sv[0] == "?") {
      print_commands();
    } else {
      printf("Unknown command %s\n", sv[0].c_str());
    }
  }
}

/* In this program, I implement the easy methods, which is all of the methods besides Make_Move() */

#include "tic_tac_toe.hpp"
#include <iostream>
using namespace std;

/* The constructor calls Clear_Game() to set up the empty board.
   It also creates the X_O_D vector and sets its entries to zero. */

Tic_Tac_Toe::Tic_Tac_Toe() 
{
  Clear_Game();
  X_O_D.resize(3, 0);
}

/* Clear_Game() creates an empty board with all dashes.  It sets the game state
   to 'B', for "Beginning", and sets the number of open squares to 9, since 
   all of the squares are empty. */

void Tic_Tac_Toe::Clear_Game() 
{
  State = 'B';
  Board.clear();
  Board.push_back("---");
  Board.push_back("---");
  Board.push_back("---");
  Open_Squares = 9;
}

/* Print() is simple, printing out the Board, one row per line. */

void Tic_Tac_Toe::Print() const 
{
  size_t i;

  for (i = 0; i < Board.size(); i++) cout << Board[i] << endl;
}

/* Game_State() is also simple, simply returning the State variable. */

char Tic_Tac_Toe::Game_State() const 
{
  return State; 
}

/* Board_String() concatenates the three rows of the Board together to make a single
   string without any newlines. */

string Tic_Tac_Toe::Board_String() const 
{ 
  string rv;

  rv = Board[0] + Board[1] + Board[2];
  return rv;
}

/* State() just copies X_O_D to its argument, which is a reference parameter. */

void Tic_Tac_Toe::Stats(vector <int> &xod) const 
{ 
  xod = X_O_D;
}

/* Make_Move() is still unwritten. */

char Tic_Tac_Toe::Make_Move(char xo, size_t row, size_t col) 
{
  (void) xo;
  (void) row;
  (void) col;
  return '.'; 
}

/* Make_Move() goes through the following steps:

   - Error check the arguments
   - Update the Board and Open_Squares
   - Test to see if whoever called Make_Move() has now won the game.  If so,
     update the stats and set the State to 'x' or 'o'.
   - Otherwise, test to see if the game is a Draw, and set its state to 'D'.
   - Finally, if the game isn't over, set the game state to 'X' or 'O' 
     to indicate whose turn it is. */

char Tic_Tac_Toe::Make_Move(char xo, size_t row, size_t col) 
{
  bool win;                  // This is used to record whether the caller has won the game.
 
  /* Error Check */

  if (xo != 'X' && xo != 'O') return 'E';
  if (xo == 'X' && State != 'B' && State != 'X') return 'E';
  if (xo == 'O' && State != 'B' && State != 'O') return 'E';
  if (row >= 3) return 'E';
  if (col >= 3) return 'E';
  if (Board[row][col] != '-') return 'E';

  /* Update the Board and decrement the number of open squares */

  Board[row][col] = xo;
  Open_Squares--;

  /* Test to see if whoever calls Make_Move has won.  The tests go in the following order:
       - Check to see if the move completed a row.
       - Check to see if the move completed a column.
       - Check to see if the move completed the \ diagonal
       - Check to see if the move completed the / diagonal */

  if (Board[row][0] == Board[row][1] && Board[row][0] == Board[row][2]) {
    win = true;
  } else if (Board[0][col] == Board[1][col] && Board[0][col] == Board[2][col]) {
    win = true;
  } else if (row == col && Board[0][0] == Board[1][1] && Board[0][0] == Board[2][2]) {
    win = true;
  } else if (row+col == 2 && Board[0][2] == Board[1][1] && Board[2][0] == Board[1][1]) {
    win = true;
  } else {
    win = false;
  }

  /* If the player won the game, update the stats and state accordingly. */

  if (win) {
    if (xo == 'X') {
      State = 'x';
      X_O_D[0]++;
    } else if (xo == 'O') {
      State = 'o';
      X_O_D[1]++;
    }

  /* Otherwise, if the game is a draw, then update the stats and state accordingly. */

  } else if (Open_Squares == 0) {
    State = 'D';
    X_O_D[2]++;

  /* Otherwise, set the State to whoever's turn it is. */

  } else if (xo == 'X') {
    State = 'O';
  } else {
    State = 'X';
  }

  /* Finally, return the state. */

  return State;
}

# This plays the game where X wins on the left-to-right diagonal:
M X 1 1
BS
M O 0 1
BS
M X 2 2
BS
M O 0 0
BS
M X 0 2
BS
M O 1 2
BS
M X 2 0
BS
GS
P

/* This program runs a more natural command-line version of tic-tac-toe than
   src/ttt_tester.cpp.  Note how it makes use of the game state to help it
   play the game. */

#include "tic_tac_toe.hpp"
#include <iostream>
#include <cstdio>
#include <sstream>
#include <vector>
#include <string>
using namespace std;

int main()
{
  Tic_Tac_Toe ttt;                  // The game player
  vector <int> stats;               // This is for reading the stats
  size_t row, col;                  // These are entered on standard input for Make_Move()
  char start;                       // 'X' or 'O' for who starts the game
  char turn;                        // 'X' or 'O' for whose turn it is
  char state;                       // The game state.
  
  /* Set it up so that 'X' plays the first game.  
     We will alternate this between games. */

  start = 'X';

  while (1) {
 
    /* Get the game state, and print the board. */

    state = ttt.Game_State();
    cout << endl;
    ttt.Print();
    cout << endl;

    /* If we're playing the game, then figure out whose turn it is,
       and then get the player's move from standard input. */

    if (state == 'B' || state == 'X' || state == 'O') {
      turn = (state == 'B') ? start : state;
      cout << turn  << "'s Move: ";
      cout.flush();
      if (!(cin >> row >> col)) return 0;

      /* If the move is illegal, then we print an error message.
         Then, regardless of whether the move was legal or illegal,
         we're simply going to go to the top of the while loop.
         If there was an error, we'll simply repeat this code.
         Otherwise, the game will move on. */

      if (ttt.Make_Move(turn, row, col) == 'E') {
        cout << endl << "Bad input -- try again, please." << endl;
      }
        
    /* Otherwise, the game is over.  We're going to do the following things:
        - Print the winner (or whether it's a draw).
        - Print the stats.
        - Start a new game
        - Set the starting player to the other player. */

    } else {
      if (state == 'D') {
        printf("Draw\n");
      } else {
        printf("%c Wins!\n", state + ('A' - 'a'));   // This converts the lower-case to upper-case.
      }

      ttt.Stats(stats);
      printf("Stats: X:%d O:%d D:%d\n", stats[0], stats[1], stats[2]);

      ttt.Clear_Game();
      start = (start == 'X') ? 'O' : 'X';
    }
  }
}

/* This program allows us to do a scientific experiment on tic-tac-toe.  The hypothesis is that
   if you start the game in the middle square, and then play the game randomly, you will do 
   betting than simply playing randomly. 

   The program is a nice demonstration of how our Tic_Tac_Toe class can serve multiple
   goals (playing the game interactively, and doing a scientific experiment. */

#include "tic_tac_toe.hpp"
#include "MOA.hpp"
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <cstdio>
using namespace std;

/* On the command line, we're going to read a number of iterations and a seed
   for a random number generator (this is why we included "MOA.hpp" above). */

int main(int argc, char **argv)
{
  Tic_Tac_Toe ttt;                     // The game player
  vector <int> stats;                  // For the final Stats() call
  MOA rng;                             // Random number generator
  istringstream ss;                    // For parsing the command line arguments

  size_t iterations;                   // The number of games to play
  size_t seed;                         // Seed for the random number generator
  size_t games_played;                 // Keeping track of the number of games played
  char start;                          // Who starts the game
  char turn;                           // Whose turn it is
  char state;                          // The game state
  string bs;                           // The board string, which helps do the random choosing
  vector <size_t> legal_moves_r;       // Legal moves -- the row numbers
  vector <size_t> legal_moves_c;       // Legal moves -- the column numbers
  
  size_t i;

  /* Parse and error check the command line */

  try {
    if (argc != 3) throw((string) "usage: bin/ttt_random iterations seed");
    ss.clear(); ss.str(argv[1]); if (!(ss >> iterations)) throw((string) "Bad iterations");
    ss.clear(); ss.str(argv[2]); if (!(ss >> seed)) throw((string) "Bad seed");
  } catch (string s) {
    cout << s << endl;
    return 1;
  }

  /* Initialize everything */

  rng.Seed(seed);
  start = 'X';
  games_played = 0;
  
  /* Keep going until you complete enough games.
     You only increment games_played when a game is over. */

  while (games_played < iterations) {
 
    // printf("%s\n", ttt.Board_String().c_str());     This is useful for debugging.

    /* If the game isn't over, then determine whose turn it is, and then
       determine the legal moves that can be made.  Choose one of them randomly.
       When it's X's turn and it's the beginning of a game, set it up so that
       the only legal move is to use the center square. */

    state = ttt.Game_State();
    if (state == 'B' || state == 'X' || state == 'O') {
      turn = (state == 'B') ? start : state;
      legal_moves_r.clear();
      legal_moves_c.clear();

      /* This is how to handle when the game is starting and it's X's turn. */

      if (state == 'B' && turn == 'X') {
        legal_moves_r.push_back(1);
        legal_moves_c.push_back(1);

      /* Otherwise, use the dashes in the board string to determine the legal moves. */

      } else {
        bs = ttt.Board_String();
        for (i = 0; i < bs.size(); i++) {
          if (bs[i] == '-') {
            legal_moves_r.push_back(i/3);
            legal_moves_c.push_back(i%3);
          }
        }
      }

      /* Choose a random legal move and make it. */

      i = rng.Random_Integer()%legal_moves_r.size();
      ttt.Make_Move(turn, legal_moves_r[i], legal_moves_c[i]);

    /* Otherwise, the game is over.  Update the games played, and set the
       starting player to the other player. */

    } else {
      games_played++;
      ttt.Clear_Game();
      start = (start == 'X') ? 'O' : 'X';
    }
  }

  /* At the end, print the stats. */

  ttt.Stats(stats);
  printf("Stats: X:%d O:%d D:%d\n", stats[0], stats[1], stats[2]);
  return 0;
}