//-----------------------------------------------------------------------------
// a2d.cpp
// 23apr2007/sklar
//-----------------------------------------------------------------------------

#include <iostream>
#include <time.h>
#include <stdlib.h>
using namespace std;


// declare constants
const int MAX_X = 15;
const int MAX_Y = 10;
const char QUIT = 'Q';
const char INVALID_COMMAND = '0'; 

// declare global variables
char grid[MAX_Y][MAX_X];

// declare function prototypes
void initGrid();
void displayGrid();
void displayGridWithWalls();
void initRobot( int &rx, int &ry, int &heading );
void updateRobotInGrid( int rx, int ry, int heading );
void moveForward( int &rx, int &ry, int heading );
void moveBackward( int &rx, int &ry, int heading );
void turnLeft( int rx, int ry, int &heading );
void turnRight( int rx, int ry, int &heading );
void moveRobot( char cmd, int &rx, int &ry, int &heading );
char parseline( string s );


//-----------------------------------------------------------------------------
// initGrid() function
// this function initializes the grid
//-----------------------------------------------------------------------------
void initGrid() {
  int x, y;
  for ( y=0; y<MAX_Y; y++ ) {
    for ( x=0; x<MAX_X; x++ ) {
      grid[y][x] = '.';
    }
  }
} // end of initGrid()


//-----------------------------------------------------------------------------
// displayGrid() function
// this function displays the grid on the screen
//-----------------------------------------------------------------------------
void displayGrid() {
  int x, y;
  for ( y=0; y<MAX_Y; y++ ) {
    for ( x=0; x<MAX_X; x++ ) {
      cout << grid[y][x];
    }
    cout << endl;
  }
} // end of displayGrid()


//-----------------------------------------------------------------------------
// displayGridWithWalls () function
// this function displays the grid on the screen, with a border around the grid
//-----------------------------------------------------------------------------
void displayGridWithWalls() {
  int x, y;
  // outer border (top horizontal line)
  cout << "+";
  for ( x=0; x<MAX_X; x++ ) {
    cout << "-";
  }
  cout << "+\n";
  // interior lines
  for ( y=0; y<MAX_Y; y++ ) {
    cout << "|";
    for ( x=0; x<MAX_X; x++ ) {
      cout << grid[y][x];
    }
    cout << "|\n";
  }
  // outer border (bottom horizontal line)
  cout << "+";
  for ( x=0; x<MAX_X; x++ ) {
    cout << "-";
  }
  cout << "+\n";
} // end of displayGridWithWalls()


//-----------------------------------------------------------------------------
// initRobot()
// this function initializes the robot to a random location in the grid.
//-----------------------------------------------------------------------------
void initRobot( int &rx, int &ry, int &heading ) {
  rx = rand() % MAX_X;
  ry = rand() % MAX_Y;
  heading = rand() % 4;
} // end of initRobot()


//-----------------------------------------------------------------------------
// resetRobotInGrid()
//-----------------------------------------------------------------------------
void resetRobotInGrid( int rx, int ry ) {
  grid[ry][rx] = '.';
} // end of resetRobotInGrid()


//-----------------------------------------------------------------------------
// updateRobotInGrid()
//-----------------------------------------------------------------------------
void updateRobotInGrid( int rx, int ry, int heading ) {
  char robotChar;
  switch ( heading ) {
  case 0: // north
    robotChar = '^';
    break;
  case 1: // west
    robotChar = '<';
    break;
  case 2: // south
    robotChar = 'v';
    break;
  case 3: // east
    robotChar = '>';
    break;
  } // end of switch heading
  grid[ry][rx] = robotChar;
} // end of updateRobotInGrid()


//-----------------------------------------------------------------------------
// moveForward()
//-----------------------------------------------------------------------------
void moveForward( int &rx, int &ry, int heading ) {
  switch ( heading ) {
  case 0: // north
    if ( ry > 0 ) {
      ry--;
    }
    break;
  case 1: // west
    if ( rx > 0 ) {
      rx--;
    }
    break;
  case 2: // south
    if ( ry < MAX_Y-1 ) {
      ry++;
    }
    break;
  case 3: // east
    if ( rx < MAX_X-1 ) {
      rx++;
    }
    break;
  } // end of switch heading
} // end of moveForward()


//-----------------------------------------------------------------------------
// moveBackward()
//-----------------------------------------------------------------------------
void moveBackward( int &rx, int &ry, int heading ) {
  switch ( heading ) {
  case 0: // north
    if ( ry < MAX_Y-1 ) {
      ry++;
    }
    break;
  case 1: // west
    if ( rx < MAX_X-1 ) {
      rx++;
    }
    break;
  case 2: // south
    if ( ry > 0 ) {
      ry--;
    }
    break;
  case 3: // east
    if ( rx > 0 ) {
      rx--;
    }
    break;
  } // end of switch heading
} // end of moveBackward()


//-----------------------------------------------------------------------------
// turnLeft()
//-----------------------------------------------------------------------------
void turnLeft( int rx, int ry, int &heading ) {
  switch ( heading ) {
  case 0: // north
    heading = 1;
    break;
  case 1: // west
    heading = 2;
    break;
  case 2: // south
    heading = 3;
    break;
  case 3: // east
    heading = 0;
    break;
  } // end of switch heading
} // end of turnLeft()


//-----------------------------------------------------------------------------
// turnRight()
//-----------------------------------------------------------------------------
void turnRight( int rx, int ry, int &heading ) {
  switch ( heading ) {
  case 0: // north
    heading = 3;
    break;
  case 1: // west
    heading = 0;
    break;
  case 2: // south
    heading = 1;
    break;
  case 3: // east
    heading = 2;
    break;
  } // end of switch heading
} // end of turnRight()


//-----------------------------------------------------------------------------
// moveRobot()
//-----------------------------------------------------------------------------
void moveRobot( char cmd, int &rx, int &ry, int &heading ) {
  switch( cmd ) {
  case 'F': // forward
    moveForward( rx, ry, heading );
    break;
  case 'B': // backward
    moveBackward( rx, ry, heading );
    break;
  case 'L': // turn left
    turnLeft( rx, ry, heading );
    break;
  case 'R': // turn right
    turnRight( rx, ry, heading );
    break;
  } // end of switch cmd
} // end of moveRobot()


//-----------------------------------------------------------------------------
// parseline()
//-----------------------------------------------------------------------------
char parseline( string s ) {
  int i;
  // convert input line to lowercase
  for ( i=0; i<s.length(); i++ ) {
    s[i] = tolower( s.at( i ));
  } // end for i
  // look for a known command in "s"
  if (( s == "f" ) || ( s.find( "forward", 0 ) != string::npos )) {
    return( 'F' );
  }
  else if (( s == "b" ) || ( s.find( "backward", 0 ) != string::npos )) {
    return( 'B' );
  }
  else if (( s == "l" ) || ( s.find( "left", 0 ) != string::npos )) {
    return( 'L' );
  }
  else if (( s == "r" ) || ( s.find( "right", 0 ) != string::npos )) {
    return( 'R' );
  }
  else if (( s == "q" ) || ( s.find( "quit", 0 ) != string::npos )) {
    return( QUIT );
  }
  else {
    return( INVALID_COMMAND );
  }
} // end of parseline()


//-----------------------------------------------------------------------------
// main() function
//-----------------------------------------------------------------------------
int main() {

  // declare local variables
  int rx, ry; // (x,y) position of robot in the grid
  int heading; // robot's heading in grid (0=north, 1=west, 2=south, 3=east)
  bool more = true;
  string s;
  char cmd;

  // initialize random seed
  srand( time( NULL ));

  // initialize grid
  initGrid();

  // display (empty) grid
  cout << "here is the grid without any walls:\n";
  displayGrid();

  cout << "\n\nhere is the grid with walls:\n";
  displayGridWithWalls();

  // initialize robot's location
  initRobot( rx, ry, heading );
  updateRobotInGrid( rx, ry, heading );
  cout << "\n\nhere is the grid with walls and a robot:\n";
  displayGridWithWalls();

  // move the robot around according to the user's commands
  while ( more ) {
    cout << "What would you like the robot to do? ";
    getline( cin, s );
    cmd = parseline( s );
    if ( cmd == QUIT ) {
      more = false;
    }
    else if ( cmd == INVALID_COMMAND ) {
      cout << "I didn't understand that command. Please try again.\n";
    }
    else {
      resetRobotInGrid( rx, ry );
      moveRobot( cmd, rx, ry, heading );
      updateRobotInGrid( rx, ry, heading );
      cout << "\n\nhere is the robot now:\n";
      displayGridWithWalls();
    }
  } // end while more

} // end of main()