//
// Program: automa_1d.cxx
//
// Description: Studio dell'evoluzione di automa cellulare unidimensionale
//
// Author: A. Garfagnini
//
// Date: 18 Dicembre 2013
//

#include <iostream>
#include <iomanip>
#include <unistd.h>
#include <libgen.h>
#include <stdlib.h>
#include <cmath>
#include <vector>

#include "boost/random.hpp"

using namespace std;

void usage(const char * pname)
{
    cerr << "Usage: " << pname << " [options] " << endl;
    cerr << "\nEvolve un automa cellulare unidimensionale" << endl;
    cerr << "\nOptions:\n";
    cerr << " -l dim  : Dimensioni della catena (default = 80)\n";
    cerr << " -r num  : Regola da implementare [0 < num <= 256]\n";
    cerr << "             Default: regola 90\n";
    cerr << " -p value : Probabilita' per patern iniziale\n";
}

// - 
// Crea un array con le terne relative alla regola specificata dal
// parametro in input.
// 
int * init_regola(int numero)
{
    if (numero < 1 || numero > 256) {
        return NULL;
    }

    int * regola = new int[8];
    for (int j=0; j<8; j++) {
        regola[j] = (numero >> j) & 0x1;
    }

    return regola;
}

void print_regola(int numero)
{
    if (numero < 1 || numero > 256) {
        return;
    }
    cout << "Regola numero: " << numero << " -=->> ";
    for (int j=7; j>-1; j--) {
        for (int bit=3; bit>0; bit--) {
            int value = j >> (bit-1);
            cout << (value & 0x1) ? '1' : '0';
        }
        cout << " ";
    }
    cout << endl;
    char blank[4] = "   ";
    if (numero < 10) {
        blank[1] = '\0';
    } else if (numero < 100) {
        blank[2] = '\0';
    }
    cout << "       " << blank << "         -=->> ";
    for (int j=7; j>-1; j--) {
        int pattern = (numero >> j) & 0x1;
        cout << " " << pattern << "  ";
    }
    cout << endl;
}

void print_automata(int cell[], int L)
{

    for (int j=0; j<L; j++) {
        if (cell[j] == 1)
            cout << '*';
        else
            cout << ' ';
    }
    cout << endl;
}

void init_random_chain( int cell[], int L, double p)
{
    int seed = 1;
    boost::uniform_real<> uni(0.0, 1.0);
    boost::mt19937 rng;
    rng.seed(seed);
    boost::variate_generator < boost::mt19937 &,
                               boost::uniform_real<> > uni_one(rng, uni);

    for (int i=0; i<L; i++) {
        cell[i] = ( (uni_one() < p) ? 1 : 0 );
    }
}

void init_fixed_chain( int cell[], int L)
{
    // Inizializza catena:
    for (int i=0; i<L; i++) {
        cell[i] = 0;
    }
    cell[L/2] = 1;
}

int main(int argc, char * argv[])
{
    int opt;
    int regola = 90;
    int L = 80;
    double ini_prob = -1.0;

    // Handle command line options
    while((opt = getopt(argc, argv, "p:l:r:vh")) != -1) {

        switch (opt) {

        case 'r':
            regola = strtol(optarg, NULL, NULL);
            if (regola < 1 || regola > 256)  {
                cerr << "Codice regola arrato: '" << regola << "'\n";
                usage(basename(argv[0]));
                return 1;
            }
            break;

        case 'p':
            ini_prob = strtod(optarg, NULL);
            if (ini_prob < 0.0 || ini_prob > 1.0) {
                cerr << "Probabilita' iniziale errata: '" << ini_prob
                     << " p in [0,1]'\n";
                usage(basename(argv[0]));
                return 2;
            }
            break;

        case 'l':
            L = strtol(optarg, NULL, NULL);
            if (L<0) {
                cerr << "Dimensioni reticolo errate: \"" << L << "\"\n";
                usage(basename(argv[0]));
                return 1;
            }
            break;

        case 'h':
        case '?':
        default:
            usage(basename(argv[0]));
            return 1;
        }
    }

    cout << "Numero di iterazioni: ";
    int t_n;
    cin >> t_n;

    // Crea catena
    int * cell = new int[L];      // istante t
    int * new_cell = new int[L];  // istante t + 1

    if (ini_prob > 0.0) {
        init_random_chain(cell, L, ini_prob);
    } else {
        init_fixed_chain(cell, L);
    }

    print_regola(regola);

    // - Crea un array con la regola per evolvere il sistema
    int * a_regola = init_regola(regola);
    if (a_regola == NULL) {
        cerr << "Regola errata: \"" << regola << "\"\n";
        return 1;
    }

    print_automata(cell, L);

    // Evolvo il sistema
    while (t_n--) {

        // Calcolo nuova catena
        for (int j=0; j<L; j++) {

            int left = cell[(j-1+L)%L];
            int center = cell[j];
            int right = cell[(j+1)%L];

            int pattern = (left<<2) | (center<<1) | right;
            pattern &= 0x7;

            new_cell[j] = a_regola[pattern];

        }

        // Sovrascrivo la catena
        for (int j=0; j<L; j++) {
            cell[j] = new_cell[j];
        }

        print_automata(cell, L);
    }

    return 0;
}