#include "CA.h"

#include "itoa.h"

#include <sstream>

#include <pthread.h>

#include <GL/freeglut.h>

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <sys/types.h>

#ifdef HAVE_SYS_FILE_H

# include <sys/file.h>

#endif

#include <sys/stat.h>

#ifdef HAVE_UNISTD_H

# include <unistd.h>

#endif

#include <fcntl.h>

#include <stdio.h>

#include <errno.h>

#if defined (HAVE_STRING_H)

# include <string.h>

#else

# include <strings.h>

#endif

#ifdef HAVE_STDLIB_H

# include <stdlib.h>

#endif

#ifdef READLINE_LIBRARY

# include "readline.h"

# include "history.h"

#else

# include <readline/readline.h>

# include <readline/history.h>

#endif

const int DEFAULT_DMX = 50;

const int DEFAULT_DMY = 50;

#define FRAME_TITLE "Simulation Platform"

CA* automata = new CA(DEFAULT_DMX,DEFAULT_DMY);

int payoff_matrix[2][2] = {{1,5},{0,3}};//dd,dc,cd,cc

bool stop = true;

pthread_mutex_t command_mutex = PTHREAD_MUTEX_INITIALIZER;

//ofstream data_file("data.dat");

struct SimulationInfo {

};

SimulationInfo sim_info = { DEFAULT_DMY,DEFAULT_DMY,13,50,1,0,true,0 };

struct GLWindowInfo {

int wdmx, wdmy, wposx, wposy, xmin, xmax, ymin, ymax, dmx, dmy, off;

};

GLWindowInfo wndw = {800,400,400,400,-100,100,-100,100,200,200,10};

string arr2str(int* arr, int N) {

}

string int2str(const int& x) {

// isstringstream iss

}

void drawLine (float x1, float y1, float x2, float y2) {

}

void drawBorder (void) {

}

void drawText (double x, double y, const char s[]) {

}

void drawGrid(int id=0) {

}

int timer = 1;

double avg_fitness[2] = {0.0,0.0};

int cell_bin[2][2] = {{0,0},{0,0}};

double coherence[2] = {0.0,0.0};

void drawRect(const int& x0, const int& y0, const int& w, const int& h) {

}

void drawMonitor() {

}

void Display() {

}

int interval = 50;

void timerFunc(int val) {

glutPostRedisplay();

glutTimerFunc(interval, timerFunc, 1);

}

void Reshape (int w, int h) {

}

void Keyboard (unsigned char key, int x, int y) {

}

void Mouse (int button, int state, int x, int y) {

}

void glutInit(int argc, char** argv) {

}

////////////////////////////////////////////////////////////////////////////////////////////

static char *progname = NULL;

static bool done = false;

int comHelp PARAMS((char *));

int comQuit PARAMS((char *));

int comStop PARAMS((char *));

int comStart PARAMS((char *));

int comRandomnizeStates PARAMS((char *));

int comRandomnizeModes PARAMS((char *));

int comRandomnizeGenome PARAMS((char *));

int comRandomnizeStrategies PARAMS((char *));

int comPayoffMatrix PARAMS((char *));

int comMutate PARAMS((char *));

int comBreakWires PARAMS((char *));

int comNoise PARAMS((char *));

int comDim PARAMS((char *));

int comMatrix PARAMS((char *));

int comTimerSpeed PARAMS((char *));

struct COMMAND {

};

COMMAND commands[] = {

{ (char*)"help", comHelp,

(char*)"Help. Type 'name' to get help on a specific command."},

{ (char*)"quit", comQuit,

(char*)"Exit the program"},

{ (char*)"stop", comStop,

(char*)"Stop the simulation. Use 'start' to continue the simulation."},

{ (char*)"start", comStart,

(char*)"Start the simulation. Use 'stop' to pause the simulation."},

{ (char*)"rnd-states", comRandomnizeStates,

(char*)"Randomnize all cell-states.\n\tThe command takes the percentage of defective cells as argument, remaining cells will be set to cooperate."},

{ (char*)"rnd-mode", comRandomnizeModes,

(char*)"Randomnize all cell-modes.\n\tThe command takes the percentage of vacant cells as argument, remaining cells will be set to operational."},

{ (char*)"rnd-genome", comRandomnizeGenome,

(char*)"Randomnize the genome. Takes no arguments. Sets each bit in the genome to 1 or 0 with 5 percent chance."},

{ (char*)"rnd-strategies", comRandomnizeStrategies,

(char*)"Randomnize all cell strategies. Randomnizes the genome of a cell according to certain strategies.\n\tThe command takes the number of defectors as argument, remaining cells will be set to be a cooperator.\n\tFor example, 'rnd-strategies 25' sets 25 percent of all cells to be a defector and 75 percent to be cooperator."},

{ (char*)"payoff-matrix", comPayoffMatrix,

(char*)"Set the payoff matrix. Takes the rewards for combinations of two actions as arguments.\n\tIn total there are four possible scenarios, DD,DC,CD,DD, arguments are applied in respective order.\n\tFor example, 'payoff-matrix 1 5 0 3' defines the payoff-matrix for the prisoners dilemma. "},

{ (char*)"mutate", comMutate,

(char*)"Set the mutation rate. Takes one value from 0 to 1000 as argument.\n\tDuring normal simulations a rate of 1 is gangbaar."},

{ (char*)"damage", comBreakWires,

(char*)"Apply damage to the wires which cells use to communicate actions.\n\tTakes one arguments which determines the percentage percentage of broken wires.\n\tFor example, 'damage 50' breaks 50% of all wires."},

{ (char*)"noise", comNoise,

(char*)"When a wire is damaged, the noise setting determines the percentage of information that is transferred incorrectly. For example 'noise 1' transfers 99% of all information correctly."},

{ (char*)"grid-size", comDim,

(char*)"Specify x and y dimensions of the grid.\n\tFor example: 'grid-size 50 50' defines a grid of 50x50 cells." },

{ (char*)"timer-speed", comTimerSpeed,

(char*)"Under construction."},

{ (char*)NULL, (rl_icpfunc_t *)NULL, (char*)NULL }

};

int comPayoffMatrix (char* arg) {

}

int comStop (char* arg) {

}

int comStart (char* arg) {

stop = false;

return 0;

}

int comMutate (char* arg) {

}

int comBreakWires(char* arg) {

}

int comNoise(char* arg) {

}

int comDim(char* arg) {

}

int comRandomnizeStates(char* arg) {

}

int comRandomnizeModes(char* arg) {

}

int comRandomnizeGenome(char* arg) {

}

int comRandomnizeStrategies(char* arg) {

}

int comHelp (char* arg) {

}

int comTimerSpeed(char* arg) {

}

int comQuit (char* arg) {

done = 1;

return (0);

}

char* dupstr (char* s) {

char *r;

r = new char[strlen(s)+1];

strcpy (r, s);

return (r);

}

char* command_generator (const char* text, int state) {

static int list_index, len;

char *name;

if (!state) {

list_index = 0;

len = strlen (text);

}

while (name = commands[list_index].name) {

list_index++;

if (strncmp (name, text, len) == 0)

return (dupstr(name));

}

return ((char *)NULL);

}

char** fileman_completion (const char* text, int start, int end) {

char **matches;

matches = (char **)NULL;

if (start == 0)

matches = rl_completion_matches (text, command_generator);

return (matches);

}

void initialize_readline () {

rl_readline_name = "ca";

rl_attempted_completion_function = fileman_completion;

}

char* stripwhite (char* string) {

register char *s, *t;

for (s = string; whitespace (*s); s++);

if (*s == 0)

return (s);

t = s + strlen (s) - 1;

while (t > s && whitespace (*t))

t--;

*++t = '\0';

return s;

}

COMMAND* find_command (char* name) {

register int i;

for (i = 0; commands[i].name; i++)

if (strcmp (name, commands[i].name) == 0)

return (&commands[i]);

return ((COMMAND *)NULL);

}

int execute_line (char* line) {

}

void* commandThread(void* arg) {

char *line, *s;

initialize_readline();

for ( ; done == 0; ) {

line = readline ("# ");

if (!line)

break;

s = stripwhite (line);

if (*s) {

add_history (s);

execute_line (s);

}

delete (line);

}

return NULL;

}

/////////////////////////////////////////////////////////////////////////////////////////////////

void printBool(bool* arr, int N) {

}

inline int twoDec(bool* arr, const int& wrap) {

}

void simulate() {

}

int main1(int argc, char** argv) {

cout << endl << "main1" << endl;

return 0;

}

int main2(int argc, char** argv) {

}

int main(int argc, char** argv) {

}

/*

class Wire {

protected:

int wid;

bool signal;

Action* data;

public:

Wire();

~Wire();

void writeData(Action* a);

void readData(Action* a);

const bool& gtSignal() const;

void stSignal(const bool& s);

void print() const;

};

Wire::Wire() {

wid=wid_counter++;

signal = 0;

data = new Action;

}

Wire::~Wire() {

delete data;

}

void Wire::writeData(Action* a) {

*data = *a;

stSignal(true);

}

void Wire::readData(Action* a) {

*a = *data;

stSignal(false);

}

const bool& Wire::gtSignal() const {

return signal;

}

void Wire::stSignal(const bool& s) {

signal = s;

}