#include <iostream>
#include <iomanip>
#include <conio.h>
#include <string>
#include <vector>
#include <regex>
using namespace std;

const string crt = "\n----------------------------------------------------------------------\n";

bool ValidirajPodatak(string podatak, string pravilo, string funkcija = "match")
{
    if (funkcija == "search")
        return regex_search(podatak, regex(pravilo));
    else
        return regex_match(podatak, regex(pravilo));
}

class Term //Pojam
{
    char* _key;
    char* _value;

    void SetDefaultValues()
    {
        int size = strlen("N/A") + 1;
        _key = new char[size];
        strcpy_s(_key, size, "N/A");

        _value = new char[size];
        strcpy_s(_value, size, "N/A");
    }
public:
    //Konstruktor
    //Atributi _key i _value ne smiju sadržavati brojeve, prazne prostore niti specijalne znakove: @, #, $.
    //Dodatno atribut _value ne smije sadržavati karaktere: č, ć, š, đ i ž.
    //U slučaju da vrijednosti proslijeđenih parametara ne zadovolje postavljene uslove,
    //postaviti default-ne vrijednosti atributima klase i baciti izuzetak.
    Term(const string & key, const string & value )
    {
        if (ValidirajPodatak(key, "([0-9]|\\s|[$#@])", "search") || ValidirajPodatak(value, "([čćžđš])", "search"))
        {
            SetDefaultValues();
            throw exception("Niste ispostovali pravila za unos rijeci u rjecnik");
        }
        else
        {
            int size = strlen(key.c_str()) + 1;
            _key = new char[size];
            strcpy_s(_key, size, key.c_str());

            size = strlen(value.c_str()) + 1;
            _value = new char[size];
            strcpy_s(_value, size, value.c_str());
        }
    }
    Term(const Term & obj)
    {
        int size = strlen(obj._key) + 1;
        _key = new char[size];
        strcpy_s(_key, size, obj._key);

        size = strlen(obj._value) + 1;
        _value = new char[size];
        strcpy_s(_value, size, obj._value);
    }
    //Destruktor
    ~Term()
    {
        delete[] _key;
        delete[] _value;

        _key = nullptr;
        _value = nullptr;
    }
    Term & operator = (const Term & right)
    {
        if (this != &right)
        {
            delete[] _key;
            delete[] _value;

            int size = strlen(right._key) + 1;
            _key = new char[size];
            strcpy_s(_key, size, right._key);

            size = strlen(right._value) + 1;
            _value = new char[size];
            strcpy_s(_value, size, right._value);
        }
        return *this;
    }
    const char * GetKey()const
    {
        return _key;
    }
    const char * GetValue()const
    {
        return _value;
    }
    //Operatori poređenja == i != (koristiti samo vrijednost atributa _key)
    friend bool operator ==(const Term &, const Term &);
    friend bool operator !=(const Term &, const Term &);
    friend bool operator <(const Term &, const Term &);

    //Operator za ispis
    friend ostream & operator <<(ostream &, const Term &);
};

bool operator ==(const Term & left, const Term & right)
{
    return strcmp(left._key, right._key) == 0;
}
bool operator !=(const Term & left, const Term & right)
{
    return !(left == right);
}
bool operator <(const Term & left, const Term & right)
{
    return strcmp(left._key, right._key) < 0;
}
ostream & operator <<(ostream & cout, const Term & obj)
{
    cout << obj._key << " - " << obj._value << endl;

    return cout;
}


class Dictionary //Riječnik pojmova
{
    string _title;
    int _publicationYear;
    //Ključne riječi bosanskog jezika u atribut _key
    //Odgovarajući prevod na engleskom jeziku u atribut _value
    vector<Term> _terms;
public:
    //Konstruktor
    //Naslov riječnika treba da počinje velikim slovom. U suprotnom baciti izuzetak i
    //postaviti default-ne vrijednosti atributa klase.
    Dictionary(const string & title, int publicationYear)
    {
        if (ValidirajPodatak(title, "[A-Z].+"))
        {
            _title = title;
            _publicationYear = publicationYear;
        }
        else
        {
            _title = "N/A";
            _publicationYear = -1;
            throw exception("Procitajte pravila prije kreiranja rjecnika");
        }
    }
    //Operator () za dodavanje novih pojmova u riječnik (u paru key-value).
    //Spriječiti dodavanje istih vrijednosti u kolekciju (baciti izuzetak).
    //Pojmovi u svakom momentu treba da budu sortirani abecedno (koristiti funkciju sort iz biblioteke algorithm).
    Dictionary & operator()(const Term & term)
    {
        for (size_t i = 0; i < _terms.size(); i++)
        {
            if ((string)_terms[i].GetKey() == (string)term.GetKey() && (string)_terms[i].GetValue() == (string)term.GetValue())
                throw exception("Pojam koji zelite dodati vec postoji u rjecniku");
        }

        _terms.push_back(term);
        sort(_terms.begin(), _terms.end());
        return *this;

    }
    //Operator -= za uklanjanje pojma iz riječnika na osnovu atributa _key.
    Dictionary & operator -=(const string & key)
    {
        vector<Term>::iterator it = _terms.begin();

        while (it != _terms.end())
        {
            if (it->GetKey() == key)
            {
                _terms.erase(it);
                return *this;
            }
            it++;
        }
        throw exception("Ne postoji pojam koji sadrzi zadani kljuc");
    }
    //Funkciju koja vraća trenutni broj pojmova u riječniku.
    int GetTrenutniBrojPojmova()const
    {
        return _terms.size();
    }
    //operator[] koji vraća vrijednost na osnovu ključne riječi (povratna vrijednost je engleska riječ-value,
    //na osnovu bosanske-key)
    const char * operator[](const string & key)const
    {
        for (size_t i = 0; i < _terms.size(); i++)
        {
            if (_terms[i].GetKey() == key)
                return _terms[i].GetValue();
        }
        throw exception("Ne postoji pojam koji sadrzi zadani kljuc");
    }
    //Funkciju koja vraća kolekciju ključeva (bosanskih riječi)
    //koji počinju sa određenim slovom. Ukoliko je broj takvih riječi paran,
    //vratiti sve one na parnim pozicijama, u suprotnom odabrati riječi na neparnim pozicijama.
    vector <string> GetKolekcijaKljuceva(char slovo)
    {
        vector<string> tempKolekcija;
        vector<string> kolekcijaKljuceva;

        string rijec;
        for (size_t i = 0; i < _terms.size(); i++)
        {
            rijec = _terms[i].GetKey();
            if (rijec[0] == slovo)
                tempKolekcija.push_back(_terms[i].GetKey());
        }

        if (tempKolekcija.size() % 2 == 0)
        {
            for (size_t i = 0; i < tempKolekcija.size(); i++)
            {
                if (i % 2 == 0)
                    kolekcijaKljuceva.push_back(tempKolekcija[i]);
            }
        }
        else
        {
            for (size_t i = 0; i < tempKolekcija.size(); i++)
            {
                if (i % 2 != 0)
                    kolekcijaKljuceva.push_back(tempKolekcija[i]);
            }
        }

        return kolekcijaKljuceva;
    }

    friend ostream & operator <<(ostream &, const Dictionary &);
};

ostream & operator <<(ostream & cout, const Dictionary & obj)
{
    cout << crt <<  obj._title << "\t\t\tPublication year: " << obj._publicationYear << crt;
    if (obj._terms.size() > 0)
    {
        cout << "\t\t\t:::Lista pojmova:::\n";
        for (size_t i = 0; i < obj._terms.size(); i++)
            cout << i + 1 << ". " << obj._terms[i].GetKey() << " - " << obj._terms[i].GetValue() << endl;
    }
    return cout;
}

//Osmisliti i implementirati klasu Competitor (Takmičar) na način da se upotrebom objekta klase Dictionary.
//svakom takmičaru dodijele određena pitanja (riječi bosanskog jezika) - koristiti implementiranu funkciju klase Dictionary.
//Svakom pitanju je potrebno pridružiti odgovor takmičara (kolekcija _odgovori).
//Obavezno implementirati funkciju koja vrši kalkulaciju osvojenih bodova (1 tačan odgovor = 1 bod).
//Po potrebi dopuniti klasu dodatnim atributima.
class Competitor //Takmičar
{
    string _ime;
    string _prezime;
    string _username; //ime.prezime
    string _password; //minimalno 6 karaktera, kombinacija velikih i malih slova,
                      //te najmanje jednog specijalnog karaktera iz liste: #%$@?!
    vector<string> _pitanja;
    vector<string> _odgovori;

    string GenerisiUsername(string ime, string prezime)
    {
        string username;

        for (size_t i = 0; i < ime.size(); i++)
        {
            ime[i] = tolower(ime[i]);
            for (size_t j = 0; j < prezime.size(); j++)
            {
                prezime[j] = tolower(prezime[j]);
            }
        }

        username = ime;
        username.append("." + prezime);

        return username;
    }
public:
    Competitor(const string & ime, const string & prezime, const string & password)
    {
        if (ValidirajPodatak(password, "(?=.{6,})(?=.*[A-Za-z])(?=.*[#%$@?!]{1,})", "search"))
        {
            _ime = ime;
            _prezime = prezime;
            _username = GenerisiUsername(_ime, _prezime);
            _password = password;
        }
        else
        {
            _ime = _prezime = _username = _password = "N/A";
            throw exception("Procitajte pravila prije registracije takmicara");
        }
    }

    friend ostream & operator << (ostream &, const Competitor &);
};

ostream & operator << (ostream & cout, const Competitor & obj)
{
    cout << "Ime i prezime: " << obj._ime << " " << obj._prezime << endl;
    cout << "Username: " << obj._username << endl;
    cout << "Password: " << obj._password<< endl;
    return cout;
}

void main()
{
    //Kreirati rijecnik pojmova.
    //Kreirati niz objekata tipa Competitor i simulirati takmičenje u poznavanju riječi engleskog jezika.
    //Pronaći najboljeg među takmičarima (najveći broj bodova).

#pragma region DodavanjePojmova
    Term kuca("Kuca", "House");
    Term krov("Krov", "Roof");
    Term kisa("Kisa", "Rain");
    Term krava("Krava", "Cow");
    Term voda("Voda", "Water");
    Term zid("Zid", "Wall");
    Term hrana("Hrana", "Food");
    Term racunar("Racunar", "Computer");
    Term igra("Igrica", "Game");
    Term telefon("Telefon", "Phone");
#pragma endregion

#pragma region DodavanjaPojmovaURjecnik
    Dictionary rjecnik("Bosansko - engleski rjecnik", 2016);
    rjecnik(kuca);
    rjecnik(voda);
    rjecnik(zid);
    rjecnik(hrana);
    rjecnik(racunar);
    rjecnik(igra);
    rjecnik(telefon);
    rjecnik(kisa);
    rjecnik(krava);
    rjecnik(krov);
#pragma endregion

    cout << rjecnik << endl;

    Competitor nisvet("Nisvet", "Mujkic", "!N1sv€t#");

    cout << nisvet << endl;

    _getch();
}