#include "bordstand.h"

Bordstand::Bordstand() {
     unsigned i;
     bordGrootte = 3; 
     Vec<int> beginBord(bordGrootte);
     for (i = 0; i < bordGrootte; i++)
          beginBord[i] = 3;
     initialiseer(beginBord);
}

Bordstand::Bordstand(Vec<int> & beginBord) {
     bordGrootte = beginBord.size();
     initialiseer(beginBord);
}

void Bordstand::initialiseer(Vec<int> & beginBord) {
     unsigned i;

     diepte = 0;
     for (i = 0; i < bordGrootte; i++) {
          history[diepte][i] = beginBord[i];
          history[diepte][bordGrootte + 1 + i] = beginBord[i];
     }
     history[diepte][bordGrootte] = 0;
     history[diepte][2 * bordGrootte + 1] = 0;
     turnHistory[diepte] = 1;
}

bool Bordstand::geldigeZet(int veld) {
     return (veldInhoud(turnHistory(diepte), veld) > 0);
}

bool Bordstand::eindStand() {
     bool leeg1 = true, leeg2 = true;
     unsigned i;

     for (i = 1; i <= bordGrootte && (leeg1 || leeg2); i++) {
          if (veldInhoud(1, i) > 0)
               leeg1 = false;
          if (veldInhoud(2, i) > 0)
               leeg2 = false;
     }
     return (leeg1 || leeg2);
}

int Bordstand::grootte() {
     return bordGrootte;
}

int & Bordstand::veldInhoud(int speler, int veld) {
     return history(diepte)((speler-1)*(bordGrootte+1) + veld - 1);
}

int Bordstand::findRotatedIndex(unsigned startIndex, int offset) {
     return (startIndex + offset) % history(0).size();
}

bool Bordstand::indexIsBank(unsigned index) {
     return (index == bordGrootte || index == 2 * bordGrootte + 1);
}

int Bordstand::indexIsPlayer(unsigned index) {
     return 2 - (index <= bordGrootte);
}

int & Bordstand::bank(int speler) {
     return history(diepte)(speler*(bordGrootte+1)-1);
}

int Bordstand::score(int speler) {
     unsigned i;
     int score = bank(speler);

     for (i = 1; i <= bordGrootte; i++)
          score += veldInhoud(speler, i);

     return score;
}

void Bordstand::doeZet(int veld) {
     // Zet oud bord in stack
     history[diepte+1] = history(diepte);
     turnHistory[diepte+1] = turnHistory(diepte);
     diepte++;

     int i; // Teller
     int aantal = veldInhoud(turnHistory(diepte), veld);
     int tempResult = (turnHistory(diepte)-1)*(bordGrootte+1)
          + veld - 1;
     bool yourField = (indexIsPlayer(
          findRotatedIndex(tempResult, aantal)) == turnHistory(diepte));

     veldInhoud(turnHistory[diepte], veld) = 0;
     for (i = 1; i <= aantal; i++)
          history(diepte)(tempResult + i)++;

     if (yourField && !indexIsBank(findRotatedIndex(tempResult,
          aantal)) && history(diepte)(tempResult + aantal) == 1) {
          bank(turnHistory(diepte)) +=
               history(diepte)(history(0).size() - tempResult -
               aantal - 2) + 1;
          history(diepte)(history(0).size() - tempResult - aantal - 2) = 0;
          history(diepte)(tempResult + aantal) = 0;
     }

     if (!yourField || !indexIsBank(findRotatedIndex(tempResult, aantal))) {
          turnHistory(diepte) = 3 - turnHistory(diepte);
     }
}

void Bordstand::haalZetTerug() {
     diepte--;
}

int Bordstand::aantalZetten() {
     return diepte;
}

void Bordstand::printBord() {
     unsigned i; // Teller
     cout << " ";
     for (i = bordGrootte; i >= 1; i--)
          cout << veldInhoud(2, i);
     cout << endl << bank(2);
     for (i = 1; i <= bordGrootte; i++)
          cout << " ";
     cout << bank(1) << endl << " ";
     for (i = 1; i <= bordGrootte; i++)
          cout << veldInhoud(1, i);
     cout << endl;
}

void Bordstand::printGame() {
     unsigned tempDiepte = diepte;
     for (diepte=0; diepte <= tempDiepte; diepte++)
          printBord();
}

#include <iostream>
#include <ctime>
#include "bordstand.h"
using namespace std;

void haalLijstIntegers(Vec<int> & deVec) {
     unsigned i = 0;
     char character = cin.get();
     while (character >= '0' && character <= '9') {
          deVec[i] = character - '0';
          i++;
          character = cin.get();
     }
}

void bereken(Bordstand & hetBord, int& kortsteWinst, int& kortsteGelijk,
     int& langsteWinst, int& langsteGelijk) {
     int i;

     if (hetBord.eindStand()) { // Basisstap
          if(hetBord.score(1) == hetBord.score(2)) { // gelijkspel
               if (hetBord.aantalZetten() > langsteGelijk)
                    langsteGelijk = hetBord.aantalZetten();
               if (hetBord.aantalZetten() < kortsteGelijk)
                    kortsteGelijk = hetBord.aantalZetten();
          } else { // winst
               if (hetBord.aantalZetten() > langsteWinst)
                    langsteWinst = hetBord.aantalZetten();
               if (hetBord.aantalZetten() < kortsteWinst)
                    kortsteWinst = hetBord.aantalZetten();
          }
     } else { // Recursieve stap
          for (i = 1; i <= hetBord.grootte(); i++) {
               if (hetBord.geldigeZet(i)) {
                    hetBord.doeZet(i);
                    bereken(hetBord, kortsteWinst, kortsteGelijk,
                         langsteWinst, langsteGelijk);
                    hetBord.haalZetTerug();
               }
          }
     }
}

int main() {
     Vec<int> deStukken;
     int kortsteWinst = 9999;
     int kortsteGelijk = 9999;
     int langsteWinst = -1;
     int langsteGelijk = -1;
     
     cout << "Geef een lijst met getallen van het te testen bord. "
          << "Gebruik" << endl
          << "1-digit integers, niet gescheiden door spaties"
          << "(bv: '333')." << endl << endl << ": ";
     
     haalLijstIntegers(deStukken);
     
     cout << endl;
     
     Bordstand hetBord(deStukken);
     
     int seconden = time(NULL);

     bereken(hetBord, kortsteWinst, kortsteGelijk, langsteWinst,
          langsteGelijk);

     seconden = time(NULL) - seconden;

     cout << "Kortste winst:      " << kortsteWinst << endl;
     cout << "Kortste gelijkspel: " << kortsteGelijk << endl;
     cout << "Langste winst:      " << langsteWinst << endl;
     cout << "Langste gelijkspel: " << langsteGelijk << endl;
     cout << "Rekentijd:          " << seconden << (seconden >
          1 ? " seconden" : " seconde") << endl;
     
     return 0;
}