/*
    playAutomata.cpp
    CIS 250
    Dave Klick
    2015-01-31

    This program can be used to test out the class that
    implements the 2-D cellular automata assignment. It
    uses a slighlty modified version of the cont() function
    supplied as a resource for the CIS 250 class.

    This program requires that kishio.h, kishio.cpp, and
    automata.h be in the same directory for compiling.
*/

#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include "automata.h"
#include "kishio.h"
using std::cin;
using std::cout;
using std::string;
using std::vector;
using kishio::getChar;
using kishio::getInt;

int cont();

class Point {
public:
    int x, y;
    Point(const int n1, const int n2) : x(n1), y(n2) {}
};

class Pattern {
public:
    string name;
    vector<Point> coord;
};

int main(int argc, char* argv[]) {
    char again;                 // used to play a new 2-d automata pattern
    char quit;                  // used to keep playing an existing pattern
    int i, j, k;
    int choice;                 // keeps track of user menu item choice
    char buf[500];
    vector<string> data;        // pattern data supplied as strings
    vector<Pattern> pattern;    // pattern data parsed into Pattern objects
    vector<string> token;       // keeps track of tokens when parsing
                                // pattern data into a Pattern object
    vector<int> xy;             // stores coordinate data during parsing

    // Starting pattern data for 2-d cellular automata. This is used
    // like a DATA statement in old Basic programs. The alternative,
    // which would be much more flexible, would be to use a data file -
    // but fewer pieces was a higher priority for this assignment.
    data.push_back(string("block,1,1,1,2,2,1,2,2"));
    data.push_back(string("behive,1,2,1,3,2,1,2,4,3,2,3,3"));
    data.push_back(string("loaf,1,2,1,3,2,1,2,4,3,2,3,4,4,3"));
    data.push_back(string("boat,1,1,1,2,2,1,2,3,3,2"));
    data.push_back(string("blinker,2,1,2,2,2,3"));
    data.push_back(string("toad,2,2,2,3,2,4,3,1,3,2,3,3"));
    data.push_back(string("beacon,1,1,1,2,2,1,3,4,4,3,4,4"));
    data.push_back(string("pulsar,1,5,1,11,2,5,2,11,3,5,3,6,3,10,3,11,5,1,5,2,5,3,5,6,5,7,5,9,5,10,5,13,5,14,5,15,6,3,6,5,6,7,6,9,6,11,6,13,7,5,7,6,7,10,7,11,9,5,9,6,9,10,9,11,10,3,10,5,10,7,10,9,10,11,10,13,11,1,11,2,11,3,11,6,11,7,11,9,11,10,11,13,11,14,11,15,13,5,13,6,13,10,13,11,14,5,14,11,15,5,15,11,"));
    data.push_back(string("glider,1,2,2,3,3,1,3,2,3,3"));
    data.push_back(string("lwss,1,2,1,5,2,6,3,2,3,6,4,3,4,4,4,5,4,6"));
    data.push_back(string("r-pentomino,1,2,1,3,2,1,2,2,3,2"));
    data.push_back(string("diehard,1,7,2,1,2,2,3,2,3,6,3,7,3,8"));
    data.push_back(string("acorn,1,2,2,4,3,1,3,2,3,5,3,6,3,7"));
    data.push_back(string("gosper-glider-gun,1,25,2,23,2,25,3,13,3,14,3,21,3,22,3,35,3,36,4,12,4,16,4,21,4,22,4,35,4,36,5,1,5,2,5,11,5,17,5,21,5,22,6,1,6,2,6,11,6,15,6,17,6,18,6,23,6,25,7,11,7,17,7,25,8,12,8,16,9,13,9,14"));
    data.push_back(string("switch-engine-1,1,7,2,5,2,7,2,8,3,5,3,7,4,5,5,3,6,1,6,3"));
    data.push_back(string("switch-engine-2,1,1,1,2,1,3,1,5,2,1,3,4,3,5,4,2,4,3,4,5,5,1,5,3,5,5"));
    data.push_back(string("switch-engine-3,1,1,1,2,1,3,1,4,1,5,1,6,1,7,1,8,1,10,1,11,1,12,1,13,1,14,1,18,1,19,1,20,1,27,1,28,1,29,1,30,1,31,1,32,1,33,1,35,1,36,1,37,1,38,1,39"));

    // This section parses the strings of pattern data into
    // Pattern objects so they are easier to use.
    for (i=0; i<(int)(data.size()); i++) {
        // Break a string into tokens using "," as the delimiter
        token.clear();
        strncpy(buf, data[i].c_str(), 500);
        buf[499] = '\0';
        char* ptr = strtok(buf, ",");
        while (ptr != NULL) {
            token.push_back(string(ptr));
            ptr = strtok(NULL, ",");
        }

        // Check for and reject obvious errors.
        int numTokens = token.size();
        if (numTokens < 1) {
            cout << "Error: No name supplied for start pattern " << (i+1) << '\n';
        } else if (numTokens < 2) {
            cout << "Error: No coordinates supplied for start pattern " << (i+1) << '\n';
        } else if (numTokens % 2 != 1) {
            cout << "Error: Invalid number of values for coordinates for start pattern " << (i+1) << '\n';
        } else {
            // Now parse the tokenized coordinate values into int values.
            // The first token must be skipped since it is a pattern name.
            xy.clear();
            bool coordsValid = true;
            for (j=1; j<numTokens; j++) {
                char coordBuf[10];
                char* endptr;
                strncpy(coordBuf, token[j].c_str(), 10);
                coordBuf[9] = '\0';
                long value = strtol(coordBuf, &endptr, 10);
                if (strlen(coordBuf) == 0 || (unsigned)(endptr-coordBuf) < strlen(coordBuf)) {
                    cout << "Error: invalid coordinate for start pattern " << (i+1) << '\n';
                    coordsValid = false;
                    break;
                } else {
                    xy.push_back((int)value);
                }
            }

            // If the coordinates were all valid, create and store a
            // Pattern object to represent the current data string.
            if (coordsValid) {
                pattern.push_back(Pattern());
                pattern.back().name = token[0];
                for (k=0; k<(int)(xy.size()); k+=2) {
                    pattern.back().coord.push_back(Point(xy[k], xy[k+1]));
                }
            }
        }
    }

    // Finally we get to play the game. Create one.
    automata game;

    again = 'Y';    // again is used to play another game
    while (again == 'Y' || again == 'y') {
        // choice stores the pattern the user chooses to play
        choice = 0;

        // create a menu of pattern names
        cout << "Choose a pattern:\n";
        for (i=0; i<(int)(pattern.size()); i++) {
            cout << (i+1) << ". " << pattern[i].name << '\n';
        }
        // add "Quit" to the end of the menu
        cout << (pattern.size()+1) << ". Quit\n";

        // get user choice and exit if user chose to quit
        choice = getInt("Your choice: ", 1, pattern.size()+1);
        if (choice == (int) (pattern.size()+1)) break;

        // reset the 2-d automata to the pattern the user chose
        game.reset();
        int len = pattern[choice-1].coord.size();
        for (i=0; i<len; i++) {
            Point p = pattern[choice-1].coord[i];
            game.setCell(p.x, p.y);
        }

        // quit is used to break out of a running game
        quit = 'N';
        while (quit != 'Q' && quit != 'q') {
            // display the current generation of the automata
            cout << "Generation: " << game.getGeneration() << '\n';
            cout << game << '\n';
            quit = cont();
            // increment the automata to the next generation
            if (quit != 'Q' && quit != 'q') game.nextGeneration();
        }

        // see if the user wants to play another game
        cin.ignore(80, '\n');
        again = getChar("Play again (Y/N)? ", "YyNn");
    }

    return 0;
}

/*
    Modified version of cont() function supplied for CIS 250 class.
    This version sends back the int value of what was typed in to continue.
*/
int cont() {
   if (cin.rdbuf()->sungetc() != -1 && cin.get() != '\n') cin.ignore(80,'\n');
   cout << "Press enter to continue, Q to quit...";
   return cin.get();
}