#ifndef HATPUZZLE_H
#define HATPUZZLE_H

#include <string>
#include <vector>
#include <iostream>

using namespace std;

typedef enum Guess_enum {
    GuessBlue = 0,
    GuessRed = 1,
    GuessNone
} Guess;

ostream& operator<< (ostream& o, Guess g) {
    if (g == GuessNone) {
        return (o << 'N');
    } else if (g == GuessBlue) {
        return (o << 'B');
    } else if (g == GuessRed) {
        return (o << 'R');
    } else {
        return (o << '?');
    }
}
ostream& operator<< (ostream& o, const vector<Guess>& g) {
    for (vector<Guess>::const_iterator it = g.begin(); it != g.end(); ++it) {
        o << *it;
    }
    return o;
}

struct LessRight {
    bool operator() (const pair<vector<Guess>, double>& lhs,
                     const pair<vector<Guess>, double>& rhs)  {
        if (lhs.second > rhs.second) {
            return true;
        } else if (lhs.second < rhs.second) {
            return false;
        }
        return lhs.first < rhs.first;
    }
};

int getHatConfigBit(int hatConfig, int n, int i);
int curViewFromHatConfig(int hatConfig, int n, int cur);
void strategyGuesses(const vector<Guess>& strategy, int n, int hatConfig, vector<Guess>& guesses);
double scoreStrategy(const vector<Guess>& strategy, int n);
vector<Guess> breedParents(const vector<Guess>& strat1, const vector<Guess>& strat2, double mutationProb);
void mutateStrategy(vector<Guess>& strategy, double mutationProb);
vector<Guess> selectWeightedStrategy(const vector<pair<vector<Guess>, double> >&generation, double totalScore, const vector<double>& preCalc);
vector<double> preCalculateWeightedStrategy(const vector<pair<vector<Guess>, double> >&generation, double totalScore);
void breedGeneration(vector<pair<vector<Guess>, double> >& generation, int n, double mutationProb);
Guess guessFromChar(const char& ch);
vector<Guess> strategyFromString(const string& strategy);
void setFirstStrategy(vector<Guess>& strategy, int n);
bool incrementStrategy(vector<Guess>& strategy, int n);
vector<Guess> findBestStrategyExhaustive(int n);
vector<Guess> findBestStrategyRandom(int n, int numIter);
vector<Guess> findBestStrategyHillClimbRestart(int n, int numIter, int steps);
vector<Guess> findBestStrategyGenetic(int n, int numIter, int generationSize, double mutationProb);
int getStrategySize(int n);
void runTests();
template <typename T, typename U>
void assert(T expected, U actual, const string& message);
void assert(bool b, const string& message);

#endif // HATPUZZLE_H