#include <iostream>
#include <string>
#include <time.h>
#include <iomanip>

using namespace std;

enum class ResultT {YELLOW_SIGN, TENTACLE, ELDER_SIGN, 
                           CTHULHU, EYE, UNKNOWN};
enum struct StatusT {ALIVE, INSANE, DEAD, UNKNOWN};

// define some constants that make life easier using a ResultT
const ResultT FIRST_RESULT = ResultT::YELLOW_SIGN;
// string::npos
const size_t RESULT_COUNT =  static_cast<int>(ResultT::UNKNOWN) 
                            - static_cast<int>(FIRST_RESULT);

// define some operations to support ResultT
ResultT Next(ResultT r);
string ResultTToString(ResultT r);
ResultT StringToResultT(string s);
string ToUpperString(string s);

ResultT RollDie();
void PrintPercent(int num, int denom);

/*
 *
 *    ResultT result;
 *
 *    result = RollDie();
 *    if (result == YELLOW_SIGN) {
 *        targetSanity -= 1;
 *    } else if (result == TENTACLE) {
 *        if (caster) {
 *            sanity += 1;
 *            targetSanity -= 1;
 *        } else {
 *            ...  
 *        }
 *    }
 */

const int TRIALS = 100;

int main() {

    srand(static_cast<unsigned int>(time(nullptr)));
   
    ResultT x = ResultT::YELLOW_SIGN;
    //StatusT y = StatusT::UNKNOWN;
    int i;
    int yellowCount{0};
    int tentacleCount{0};
    int elderCount{0};
    int cthulhuCount{0};
    int eyeCount{0};



    cout << "There are " << RESULT_COUNT << " different results " << endl;

    for(x = FIRST_RESULT; x < ResultT::UNKNOWN; x= Next(x)) {
        cout << ResultTToString(x) << endl;
    }

    for(i = 0; i < TRIALS; i++) {
        x = RollDie();

        switch(x){
           case ResultT::YELLOW_SIGN:
               yellowCount ++;
               break;
           case ResultT::TENTACLE:
               tentacleCount ++;
               break;
           case ResultT::ELDER_SIGN:
               elderCount ++;
               break;
           case ResultT::CTHULHU:
               cthulhuCount ++;
               break;
           case ResultT::EYE:
               eyeCount ++;
               break;
        }

        cout << ResultTToString(x) << endl;

    }

    cout << setw(15) << "Yellow Sign "  << setw(5) << yellowCount << setw(10);
    PrintPercent(yellowCount, TRIALS);
    cout << endl;
    cout << setw(15) << "Tentacle "  << setw(5) << tentacleCount << setw(10);
    PrintPercent(tentacleCount, TRIALS);
    cout << endl;
    cout << setw(15) << "Elder Sign "  << setw(5) << elderCount <<  setw(10);  
    PrintPercent(elderCount, TRIALS);
    cout << endl;
    cout << setw(15) << "Cthulhu "  << setw(5) << cthulhuCount <<  setw(10)  ;
    PrintPercent(cthulhuCount, TRIALS);
    cout << endl;
    cout << setw(15) << "Eye "  << setw(5) << eyeCount << setw(10);
    PrintPercent(eyeCount, TRIALS);
    cout << endl;

    return 0;
}

string ToUpperString(string s){
   size_t i;
   
   for(i = 0; i < s.size(); i++) {
       s[i] = static_cast<char>(toupper(s[i]));
   }

   return s;
}

string ResultTToString(ResultT r){

    string result {"UNKNOWN"};
    switch(r) {
       case ResultT::YELLOW_SIGN:
          result = "Yellow Sign";
          break;
       case ResultT::TENTACLE:
          result = "Tentacle";
          break;
       case ResultT::ELDER_SIGN:
          result = "Elder Sign";
          break;
       case ResultT::CTHULHU:
          result = "Cthulhu";
          break;
       case ResultT::EYE:
          result = "Eye";
          break;
       case ResultT::UNKNOWN:
       default:
           result = "Error";
    }
    return result;
}


ResultT StringToResultT(string s){
    ResultT result;

    s = ToUpperString(s);

    if (s == "YELLOW SIGN") {
        result = ResultT::YELLOW_SIGN; 
    } else if (s == "TENTACLE") {
        result = ResultT::TENTACLE;
    } else if (s == "ELDER SIGN") {
        result = ResultT::ELDER_SIGN;
    } else if (s == "CTHULHU") {
        result = ResultT::CTHULHU;
    } else if (s == "EYE") {
        result = ResultT::EYE;
    } else {
        result = ResultT::UNKNOWN;
    }

    return result;
}


ResultT Next(ResultT r){
    ResultT result{ResultT::UNKNOWN};

    if(r < ResultT::UNKNOWN) {
        result = static_cast<ResultT>(static_cast<int>(r) +1);
    }

    return result;
}

ResultT RollDie(){
    ResultT result{ResultT::UNKNOWN};

    int roll;

    roll = rand() % 12;

    switch(roll) {
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
           result = ResultT::YELLOW_SIGN;
           break;
        case 5:
        case 6:
        case 7:
        case 8:
           result = ResultT::TENTACLE;
           break;
        case 9:
           result = ResultT::ELDER_SIGN;
           break;
        case 10:
           result = ResultT::CTHULHU;
           break;
        case 11:
           result = ResultT::EYE;
           break;

    }

    return result;

}


void PrintPercent(int num, int denom){
    int value = static_cast<int>(static_cast<float>(num) 
                                  / static_cast<float>(denom) * 100);
    cout << value << "%";

    return;
}