/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
#include <stdio.h>
#include <cstdlib>
#include<string.h>
//---------------------------------------------------
// Purpose:     Header file for the Tic4 class
//
// Author:      John Gauch - Created class definition.
//              Kendall Clancy - Completed implementation.
//---------------------------------------------------

#include <iostream>
using namespace std;

#ifndef TIC4
#define TIC4

// Global constants
const int SIZE = 4;

// Class definition
class Tic4
{
   public:
      // Constructor and destructor
      Tic4();
      ~Tic4();

      // Public methods
      void ClearBoard();
      bool SetBoard(const int row, const int col, const char player);
      bool GetBoard(const int row, const int col, char & player);
      //bool GetBoard2(const int row, const int col, char & player);
      bool CheckWin(const char player);
      void PrintBoard();
      bool IsFull();
      bool SimpleAI(char & player);
      bool RandomAI(char & player);
      bool CleverAI(char & player);
      bool FancyAI(char & player);

   private:
     // Private variables
     char board[SIZE][SIZE];
     int board_count;
};
#endif

//---------------------------------------------------
// Purpose:     Implementation of the Tic4 class
//
// Author:      John Gauch - Created skeleton program.
//              YOUR NAME - Completed implementation.
//---------------------------------------------------

//#include "tic4.h"

//---------------------------------------------------
// Constructor function
//---------------------------------------------------
Tic4::Tic4()
{
   ClearBoard();
}

//---------------------------------------------------
// Destructor function
//---------------------------------------------------
Tic4::~Tic4()
{
   // Intentionally empty
}

//---------------------------------------------------
// Clear the Tic4 board
//---------------------------------------------------
void Tic4::ClearBoard()
{
   // Initialize Tic4 board
   for (int c = 0; c < SIZE; c++)
   for (int r = 0; r < SIZE; r++)
      board[r][c] = ' ';
   board_count = 0;
}

//---------------------------------------------------
// Set value of board at location [row][column]
//---------------------------------------------------
bool Tic4::SetBoard(int row, int col, char player)
{
   // Error checking
   if ((row < 0) || (row >= SIZE) ||
       (col < 0) || (col >= SIZE) ||
       (board[row][col] != ' '))
      return false;

   // Set value of board
   board[row][col] = player;
   board_count++;
   return true;
}

//---------------------------------------------------
// Get value of board at location [row][column]
//---------------------------------------------------
bool Tic4::GetBoard(const int row, const int col, char & player)
{
   // Error checking
   if ((row < 0) || (row >= SIZE) ||
       (col < 0) || (col >= SIZE))
      return false;

   // Get value of board
   player = board[row][col];
   return true;
}
/*
bool Tic4::GetBoard2(const int row, const int col, char & player)
{
int newrow = row;
int newcol = col;
char testingvalue = 'F';
testingvalue = board[newrow,newcol];
int resultz = strcmp(" ", testingvalue);
   if (resultz == 0)
   {
    return true;
   }
   return false;
}
*/
//---------------------------------------------------
// Check to see if player has won the game
//---------------------------------------------------
bool Tic4::CheckWin(const char player)
{
   // Check all the rows
   for (int r = 0; r < SIZE; r++)
   {
      // Count player pieces
      int count = 0;
      for (int c = 0; c < SIZE; c++)
         if (board[r][c] == player)
            count++;
      if (count == SIZE)
         return true;
   }

   // Check all the cols
   for (int c = 0; c < SIZE; c++)
   {
      // Count player pieces
      int count = 0;
      for (int r = 0; r < SIZE; r++)
         if (board[r][c] == player)
            count++;
      if (count == SIZE)
         return true;
   }

   // Check first diagonal
   int count = 0;
   for (int r = 0; r < SIZE; r++)
   {
      int c = r;
      if (board[r][c] == player)
         count++;
   }
   if (count == SIZE)
      return true;

   // Check second diagonal
   count = 0;
   for (int r = 0; r < SIZE; r++)
   {
      int c = SIZE-1-r;
      if (board[r][c] == player)
         count++;
   }
   if (count == SIZE)
      return true;

   // The player did not win
   return false;
}

//---------------------------------------------------
// Print the Tic4 board
//---------------------------------------------------
void Tic4::PrintBoard()
{
   // Draw column numbers
   cout << "\n     ";
   for (int c = 0; c < SIZE; c++)
      cout << c << "   ";
   cout << "\n";
 //cout << "The size is " << SIZE << endl;
   // Print the Tic4 board
   for (int r = 0; r < SIZE; r++)
   {
      // Draw dashed line
      cout << "   +";
      for (int c = 0; c < SIZE; c++)
         cout << "---+";
      cout << "\n";

      // Draw board contents
      cout << " " << r << " | ";
      for (int c = 0; c < SIZE; c++)
         cout << board[r][c] << " | ";
      cout << "\n";
   }

   // Draw dashed line
   cout << "   +";
   for (int c = 0; c < SIZE; c++)
      cout << "---+";
   cout << "\n\n";
}

//---------------------------------------------------
// Check if board is full
//---------------------------------------------------
bool Tic4::IsFull()
{
   return (board_count == SIZE * SIZE);
}

//#include "tic4.h"

//-------------------------------------------------------------------- AI CODE
bool Tic4::SimpleAI(char & player)
{
cout << "Called SimpleAI" << endl;
Tic4 bob;

    bool Truth {false};
    int counter = 0;
    for(int row = 0; row < 4; row++)
    {

        for(int column = 0; column < 4; column++)
        {
        Truth = GetBoard(row, column, player);
        counter++;
        if (Truth == true)
        {
        bob.SetBoard(row,column,player);
        return true;
        }

        }
    }

 //bob.SetBoard(row, column, player);
   if (counter >=15 && Truth == false)
   {
    return false;
   }
 return true;
}

bool Tic4::RandomAI(char & player)
{
cout << "Called RandomAI" << endl;
Tic4 bob;
int rand();
 int randomnumber;
 int randomnumber2;
 int counter = 0;
 bool Truth {false};

 while(counter <= 50)
 {
 randomnumber = rand()%4;
 randomnumber2 = rand()%4;
 Truth = GetBoard(randomnumber, randomnumber2, player);
 if(Truth == true)
 {
  bob.SetBoard(randomnumber,randomnumber2,player);
  return true;
 } //end if
 }//end while

 if(counter >= 50 && Truth == false)
 {
     cout << "This method assumes the board is full" << endl;
    return false;
 }
 //bob.SetBoard(row, column, playerTurn);
 return true;
}

bool Tic4::CleverAI(char & player) //search the 2 diagonals, else, search the non-diagonals.
//non-diagonals are SimpleAI so I can just call that if the diagonals don't work out
{
    cout << "Called CleverAI" << endl;
Tic4 bob;
bool Truth {false};
//check the first diagonal
 for (int r = 0; r < SIZE; r++)
   {
      int c = r;
      Truth = GetBoard(r,c,player);
      if(Truth == true)
      {
        bob.SetBoard(r,c,player);
        return true;
      }
   }


   // Check second diagonal

   for (int row = 0; row < SIZE; row++)
   {
      int col = SIZE-1-row;
      Truth = GetBoard(row,col,player);
      if(Truth == true)
      {
        bob.SetBoard(row,col,player);
        return true;
      }

   }
   int counter = 0;
   if (Truth == false)
   {

    for(int rowz = 0; rowz < 4; rowz++)
    {

        for(int column = 0; column < 4; column++)
        {
        Truth = GetBoard(rowz, column, player);
        counter++;
        if (Truth == true)
        {
        bob.SetBoard(rowz,column,player);
        return true;
        }

        }
    }

 //bob.SetBoard(row, column, player);
   if (counter >=15 && Truth == false)
   {
    return false;
   }

   }
 return true;
}

bool Tic4::FancyAI(char & player)
{
Tic4 bob;
 //will call simple random or clever at random
 cout << "called FancyAI" << endl;
 bool Truth {false};
 int rand();
 int randomnumber;
 randomnumber = rand()%3 + 1;
 cout << "The random number is " << randomnumber << endl;
 randomnumber = 1; // TESTINGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
  if(randomnumber == 1)
    {
    Truth = SimpleAI(player);
    }

  if(randomnumber == 2)
    {
    Truth = RandomAI(player);
    }

   if(randomnumber == 3)
    {
    Truth = CleverAI(player);
    }
 if(Truth == true)
 {
 return true;
 }
 if(Truth == false)
 {
 return false;
 }
}

//---------------------------------------------------------------------------

//---------------------------------------------------
// Main program to play Tic4 game
//---------------------------------------------------
int main()
{
cout << "Hello user. Please input answers like so: 2,1" << endl;
cout << "Do not enter any other way, and do not try put the same answer twice or go where someone else has gone " << endl;
bool player1win = false;
bool player2win = false;
bool BoardFull = false;
char Player1 = 'X';
char Player2 = 'O';
char str[] = "2 2";
//cout << str ;
string message1 = "Enter X move: ";
string message2 = "Enter O move: ";
string Answer = "";
char player = 'X';
bool GoodAnswer = true;
int row = 0;
int column = 0;
bool currentwin = false;

   Tic4 bob;

cout << "Welcome to 4x4 tic-tac-toe";
int turn_counter = 1;
bool Truth {false};
while(currentwin == false && BoardFull == false)
{
    bob.PrintBoard();
    //cout << "player turn = " << turn_counter%2 << " welp" << endl;
     if(turn_counter%2==0)
    {
    player = 'O';
    }
    else
	{
	player = 'X';
	}

    currentwin = bob.CheckWin(player); //this doesn't work well
    if (currentwin == false)
    {
    cout << "No one has won the game yet" << endl;
    }
    BoardFull = bob.IsFull();
    if(turn_counter%2==0)
    {
    player = 'O';
	//cout << message2; //edit code here to call the fancy AI
	cout << "Now it's the AI turn" << endl;
    Truth = bob.FancyAI(player);
    if(Truth == false)
    {
    cout << "The board is full and it's a tie" << endl;
    return 0;
    }

    }//end turn counter if
	else
	{
	player = 'X';
	//if(turn_counter%2 == 0) // --------------------------------------created for test
	//{
	//cout << "THE TURN COUNTER IS CORRECT BUT WTF LOL" << endl;
	//}
	cout << message1 ;
	cin >> Answer;
	//turn_counter++; // ---------------------------------------------------------- created this line for test
	//cout << "THE TURN COUNTER IS NOW " << turn_counter << endl; //same
	}
  turn_counter++;



  cout << endl;
 ;
  int i;
   for(i=0;i<sizeof(Answer);i++)
   {
      str[i] = Answer[i];
   }
   //cout << "This is what you just entered " << str << endl;
  row = (int)str[0] - 48;
  column = (int)str[2] - 48;

  bob.SetBoard(row, column, player);
}
if(currentwin == true)
{
    if(player == 'O')
    {
    cout << "Player O Wins!";
    }
    else
    {
    cout <<"Player X Wins!";
    }
}
if(BoardFull == true && currentwin == false)
{
cout << "It's a draw!";
}
   return 0;
}