#pragma once
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>

template <typename T>
std::string EnumToString(T value, const std::vector<std::string> &  names) {
    return names[static_cast<int>(value)];
}

template <typename T>
T RandomEnum(const int max) {
   return static_cast<T> (rand() % max);
}

template <typename T> 
T StringToEnum(std::string name, const std::vector<std::string> & names) {
    size_t i;
    std::string newName;
    std::vector<std::string>:: const_iterator pos;

    // lower it
    for (i = 0; i < name.size(); ++i) {
        newName += static_cast<char>(tolower(name[i]));
    }

    // uppercase first letter
    if (newName.size() > 0) {
        newName[0] = static_cast<char> (toupper(newName[0]));
    }

    // find it.
    pos = std::find(cbegin(names), cend(names), newName);

    // return it
    if (pos == cend(names)) {
        return static_cast<T>(names.size());
    } else {
        return static_cast<T>(pos-cbegin(names));
    }

}

enum class SuiteT {HEART, SPADE, DIAMOND, CLUB, NONE};
const std::vector<std::string> SUITE_NAMES{"Heart","Spade",
                                                  "Diamond","Club","None"};
const int SUITE_COUNT{static_cast<int>(SuiteT::NONE)};

SuiteT StringToSuiteT(std::string name);

enum class ValueT {ACE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, NONE};
const std::vector<std::string> VALUE_NAMES {"Ace", "Two", "Three", "Four",
                          "Five", "Six", "Seven", "Eight", "Nine", "Ten",
                                          "Jack", "Queen", "King", "None"};
const int VALUE_COUNT{static_cast<int>(ValueT::NONE)};
ValueT StringToValueT(std::string name);

class CardT {
    public:
        CardT(SuiteT s = SuiteT::NONE, ValueT v=ValueT::NONE):
                                                suite(s), value(v) {};
        void Randomize();

        virtual bool operator ==(const CardT & other) const;
        virtual bool operator <(const CardT & other) const;

        virtual std::string Name() {
            return "CardT";
        }

        ValueT Value() const;
        SuiteT Suite() const;

        std::string ToString() const;

    private:
        SuiteT suite{SuiteT::NONE};
        ValueT value{ValueT::NONE};
};

std::ostream & operator << (std::ostream & s, const CardT & c);