#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <conio.h>

using namespace std;

enum class Kombinacje   // lista wyliczeniowa możliwych wyników (ułożona od najsłabszego do najlepszego możliwego wyniku)
{
    para, dwie_pary, nieparzyste, parzyste, trojka, czworka, full, maly_strit, duzy_strit, general
};

struct Gracz
{
    short nr;
    string imie;
    short kosci[5];
    Kombinacje wynik;
    short wynik2;
};

vector<Gracz> gracze;       // wektor przechowujący wszystkich graczy
short rundy;

short suma(short* kosci)        // zwraca sume oczek na kostkach
{
    short wynik = 0;
    for(short i = 0; i < 5; ++i)
        wynik += kosci[i];
    return wynik;
}

bool czy_jest(short* kosci, short liczba) // funkcja sprawdzająca czy dana liczba występuje w wyrzuconej kombinacji
{
    for(short i = 0; i < 5; ++i)
        if(kosci[i] == liczba) return true;
    return false;
}

bool duzystrit(short* kosci)    // osobna funkcja sprawdzająca czy z kombinacji wychodzi duży strit
{
    if(czy_jest(kosci, 6) && czy_jest(kosci, 2) && czy_jest(kosci, 3) && czy_jest(kosci, 4) && czy_jest(kosci, 5)) return true;
    return false;
}

bool malystrit(short* kosci)    // osobna funkcja sprawdzająca czy z kombinacji wychodzi mały strit
{
    if(czy_jest(kosci, 1) && czy_jest(kosci, 2) && czy_jest(kosci, 3) && czy_jest(kosci, 4) && czy_jest(kosci, 5)) return true;
    return false;
}

bool czworka(short* kosci, short& pkt)
{
    if(kosci[0] == kosci[1] && kosci[1] == kosci[2] && kosci[2] == kosci[3])
    {
        pkt = 4 * kosci[0] + 20;
        return true;
    }
    if(kosci[1] == kosci[2] && kosci[2] == kosci[3] && kosci[3] == kosci[4])
    {
        pkt = 4 * kosci[1] + 20;
        return true;
    }
    return false;
}

bool trojka(short* kosci, short& pkt)
{
    if(kosci[0] == kosci[1] && kosci[1] == kosci[2])
    {
        pkt = 3 * kosci[0];
        return true;
    }

    if(kosci[1] == kosci[2] && kosci[2] == kosci[3])
    {
        pkt = 3 * kosci[1];
        return true;
    }

    if(kosci[2] == kosci[3] && kosci[3] == kosci[4])
    {
        pkt = 3 * kosci[2];
        return true;
    }
    return false;
}

bool nieparzyste(short* kosci)
{
    if(kosci[0] %2 != 0 && kosci[1] %2 != 0 && kosci[2] %2 != 0 && kosci[3] %2 != 0 && kosci[4] %2 != 0)
        return true;
    return false;
}

bool parzyste(short* kosci)
{
    if(kosci[0] %2 == 0 && kosci[1] %2 == 0 && kosci[2] %2 == 0 && kosci[3] %2 == 0 && kosci[4] %2 == 0)
        return true;
    return false;
}

bool dwie_pary(short* kosci, short& pkt)
{
    if(kosci[0] == kosci[1] && kosci[2] == kosci[3])
    {
        pkt = 2 * kosci[0] + 2 * kosci[2];
        return true;
    }
    if(kosci[0] == kosci[1] && kosci[3] == kosci[4])
    {
        pkt = 2 * kosci[0] + 2 * kosci[3];
        return true;
    }
    if(kosci[1] == kosci[2] && kosci[3] == kosci[4])
    {
        pkt = 2 * kosci[1] + 2 * kosci[3];
        return true;
    }
    return false;
}

bool para(short* kosci, short& pkt)
{
    if(kosci[0] == kosci[1])
    {
        pkt = 2 * kosci[0];
        return true;
    }
    if(kosci[1] == kosci[2])
    {
        pkt = 2 * kosci[1];
        return true;
    }
    if(kosci[2] == kosci[3])
    {
        pkt = 2 * kosci[2];
        return true;
    }
    if(kosci[3] == kosci[4])
    {
        pkt = 2 * kosci[3];
        return true;
    }
    return false;
}

Kombinacje wynik(short* kosci, short& punkty)      // funkcja zwracająca wynik z wyrzuconych kości
{
    Kombinacje figura;
    punkty = 0;
    short punkty_spr;

    bool flaga = true;
    // sprawdzanie genera³a
    for(short i = 1; i < 5; ++i)
        if(kosci[i] != kosci[0])
        {
            flaga = false;
            break;
        }

    if(flaga)
    {
        figura = Kombinacje::general;
        punkty = 50 + suma(kosci);
    }

    // sprawdzanie duzego strita
    if(duzystrit(kosci))
    {
        if(20 > punkty)
        {
            figura = Kombinacje::duzy_strit;
            punkty = 20;
        }
    }

    // sprawdzanie malego strita
    if(malystrit(kosci))
    {
        if(15 > punkty)
        {
            figura = Kombinacje::maly_strit;
            punkty = 15;
        }
    }

    // sprawdzanie fulla
    if((kosci[0] == kosci[1] && kosci[2] == kosci[3] && kosci[3] == kosci[4]) || (kosci[0] == kosci[1] && kosci[1] == kosci[2] && kosci[3] == kosci[4]))
    {
        punkty_spr = 10 + suma(kosci);
        if(punkty_spr > punkty)
        {
            figura = Kombinacje::full;
            punkty = punkty_spr;
        }
    }

    // sprawdzanie czwórki
    if(czworka(kosci, punkty_spr))
    {
        if(punkty_spr > punkty)
        {
            figura = Kombinacje::czworka;
            punkty = punkty_spr;
        }
    }

    // sprawdzanie trojki
    if(trojka(kosci, punkty_spr))
    {
        if(punkty_spr > punkty)
        {
            figura = Kombinacje::trojka;
            punkty = punkty_spr;
        }
    }

    // sprawdzanie nieparzystych
    if(nieparzyste(kosci))
    {
        punkty_spr = suma(kosci);
        if(punkty_spr > punkty)
        {
            punkty = punkty_spr;
            figura = Kombinacje::nieparzyste;
        }
    }

    // sprawdzanie parzystych
    if(parzyste(kosci))
    {
        punkty_spr = suma(kosci);
        if(punkty_spr > punkty)
        {
            punkty = punkty_spr;
            figura = Kombinacje::parzyste;
        }
    }

    // sprawdzanie dwóch par
    if(dwie_pary(kosci, punkty_spr))
    {
        if(punkty_spr > punkty)
        {
            punkty = punkty_spr;
            figura = Kombinacje::dwie_pary;
        }
    }

    // sprawdzanie pary
    if(para(kosci, punkty_spr))
    {
        if(punkty_spr > punkty)
        {
            punkty = punkty_spr;
            figura = Kombinacje::para;
        }
    }

    return figura;
}

void sortuj(short* tab)
{
    for(short i = 0; i < 4; ++i)
        for(short j = 0; j < 4 - i; ++j)
            if(tab[j] < tab[j + 1])
                swap(tab[j], tab[j + 1]);
}

void wypisz(short* tab)
{
    for(short i = 0; i < 5; ++i)
        cout << tab[i] << '\t';
    cout << endl;
}

string wypisz_wynik(Kombinacje kombo)
{
    switch(kombo)
    {
    case Kombinacje::czworka:
        return "czworka";
    case Kombinacje::duzy_strit:
        return "duzy strit";
    case Kombinacje::full:
        return "full";
    case Kombinacje::general:
        return "general";
    case Kombinacje::maly_strit:
        return "maly strit";
    case Kombinacje::para:
        return "para";
    case Kombinacje::trojka:
        return "trojka";
    case Kombinacje::parzyste:
        return "parzyste";
    case Kombinacje::nieparzyste:
        return "nieparzyste";
    case Kombinacje::dwie_pary:
        return "dwie pary";
    }
}

void kopiuj_tablice(short* tab, short* posortowana)
{
    for(short i = 0; i < 5; ++i)
        posortowana[i] = tab[i];
    sortuj(posortowana);
}

bool czy_juz_jest(vector<short> przerzucone, short liczba)      // funkcja sprawdzająca czy numer przerzuconej kostki już jest w tablicy
{
    short rozmiar = przerzucone.size();
    for(short i = 0; i < rozmiar; ++i)
        if(przerzucone[i] == liczba)
            return true;
    return false;
}

void przerzuc(short gracz)
{
    vector<short> przerzucone;
    przerzucone.clear();
    char znak;
    short numer;
    do
    {
        do
        {
            znak = getch();
            znak = toupper(znak);
        }
        while(znak != '1' && znak != '2' && znak != '3' && znak != '4' && znak != '5' && znak != 'K');

        if(znak == 'K')
            break;

        numer = znak - '0';
        if(czy_juz_jest(przerzucone, numer - 1))
            continue;       // ta kostka już została wybrana, więc pomijamy
        przerzucone.push_back(numer - 1);
        cout << numer << '\t';
        if(przerzucone.size() == 5) break;      // wszystkie kości zostały wybrane, więc kolejnych już nie wpisujemy
    }
    while(true);

    // przerzucanie wybranych kości
    short ile = przerzucone.size();
    if(ile == 0)
    {
        cout << "Nie wybrales/wybralas kosci do przerzucenia.\n";
        return;
    }

    cout << "\nWcisnij dowolny klawisz, aby przerzucic wybrane kosci...\n";
    getch();
    srand(time(nullptr));
    for(short i = 0; i < ile; ++i)
        gracze[gracz].kosci[przerzucone[i]] = 1 + rand() % 6;
    cout << "Kosci zostaly rzucone ;)\t";
    wypisz(gracze[gracz].kosci);
}

void rzut_koscmi(short n)
{
    srand(time(nullptr));
    for(short i = 0; i < 5; ++i)
        gracze[n].kosci[i] = 1 + rand() % 6;
    cout << "Kosci zostaly rzucone ;)\t";
    wypisz(gracze[n].kosci);
    cout << "Czy chcesz przerzucic kosci? (t/n): ";
    char znak;
    do
    {
        znak = getch();
        znak = toupper(znak);
    }
    while(znak != 'T' && znak != 'N');
    if(znak == 'T')
    {
        cout << "TAK\n";
        cout << "Wybierz numery kosci (1-5), ktore chcesz przerzucic lub wcisnij K jesli zakonczyles/zakonczylas wybieranie:\n";

        // wybieranie kosci do przerzucenia:
        przerzuc(n);
    }
    bool flaga = true;
    if(znak == 'N')
    {
        flaga = false;
        cout << "NIE\n";
    }

    // ponowne przerzucenie kości
    if(flaga)
    {
        cout << "Czy chcesz ponownie przerzucic kosci? (t/n): ";
        do
        {
            znak = getch();
            znak = toupper(znak);
        }
        while(znak != 'T' && znak != 'N');
        if(znak == 'T')
        {
            cout << "TAK\n";
            cout << "Wybierz numery kosci (1-5), ktore chcesz przerzucic lub wcisnij K jesli zakonczyles/zakonczylas wybieranie:\n";

            // wybieranie kosci do przerzucenia:
            przerzuc(n);
        }
        if(znak == 'N')
            cout << "NIE\n";
    }

    // sprawdzenie wyniku:
    short tablica[5];
    kopiuj_tablice(gracze[n].kosci, tablica);
    short punkty;
    gracze[n].wynik = wynik(tablica, punkty);
    gracze[n].wynik2 += punkty;

    // wypisanie wyniku:
    cout << "\n\tTwoj wynik to " << wypisz_wynik(gracze[n].wynik) << " (liczba punktow: " << punkty << ')' << endl << endl;
    cout << "Wcisnij dowolny klawisz, aby zakonczyc swoja ture...";
    getch();
}

// funkcje operatorowe, umożliwiające weryfikowanie który z graczy ma lepszy wynik:
bool operator<(Gracz A, Gracz B)
{
    if(A.wynik2 < B.wynik2)
        return true;
    return false;
}

bool operator==(Gracz A, Gracz B)
{
    if(A.wynik2 == B.wynik2)
        return true;
    return false;
}

void sortuj_ranking()
{
    short ile = gracze.size() - 1;

    for(short i = 0; i < ile; ++i)
        for(short j = 0; j < ile - i; ++j)
            if(gracze[j] < gracze[j + 1])
                swap(gracze[j], gracze[j + 1]);

}

void wypisz_ranking(bool koniec)
{
    short ile = gracze.size();
    short miejsce = 1;

    // wypisanie pierwszego miejsca:
    cout << "1. Gracz nr " << gracze[0].nr << "\t(" << gracze[0].imie << ")\t" << "wynik: " << gracze[0].wynik2 << " pkt\n";

    // wypisanie kolejnych miejsc:
    for(short i = 1; i < ile; ++i)
    {
        if(gracze[i] < gracze[i - 1])
            miejsce = i + 1;
        cout << miejsce << ". Gracz nr " << gracze[i].nr << "\t(" << gracze[i].imie << ")\t" << "wynik: " << gracze[i].wynik2 << " pkt\n";
    }

    if(koniec)
    {
        // liczymy ilu graczy zwyciężyło:
        short zwyciezcy = 1;

        for(short i = 1; i < ile; ++i)
        {
            if(gracze[i] == gracze[0])
                ++zwyciezcy;
            else
                break;
        }

        cout << endl;
        if(zwyciezcy == 1)
            cout << "Zwyciezyl gracz nr " << gracze[0].nr << " (" << gracze[0].imie << ") Gratulacje!\n";
        else    // wypisanie więcej niż jednego gracza
        {
            cout << "Zwyciezyli ex aequo ";

            for(short i = 0; true; ++i)
            {
                cout << "gracz nr " << gracze[i].nr << " (" << gracze[i].imie << ')';
                if(i == zwyciezcy - 1)
                {
                    cout << "\nGratulacje!\n";
                    break;
                }
                else if(i == zwyciezcy - 2)
                    cout << " i ";
                else
                    cout << ", ";
            }
        }
    }
}

void gra()
{
    short liczba_graczy = gracze.size();
    char komenda;

    for(short i = 0; i < rundy; ++i)
    {
        system("cls");
        cout << "RUNDA " << i + 1 << endl;
        cout << "Wcisnij dowolny klawisz, aby rozpoczac runde!";
        getch();

        for(short i = 0; i < liczba_graczy; ++i)
        {
            system("cls");
            cout << "Tura gracza " << i + 1 << ": " << gracze[i].imie << "\nWcisnij dowolny klawisz, aby rzucic koscmi!\n";
            getch();
            rzut_koscmi(i);
        }

        if(i < rundy - 1)
        {
            system("cls");
            cout << "Runda zostala zakonczona. Czy chcesz zobaczyc aktualny ranking? (t/n) ";
            do
            {
                komenda = getch();
                komenda = toupper(komenda);
            }
            while(komenda != 'T' && komenda != 'N');

            if(komenda == 'T')
            {
                cout << "TAK\n";
                wypisz_ranking(false);
                cout << endl << "Wcisnij dowolny klawisz, aby kontynuowac...";
                getch();
            }
            else
            {
                cout << "NIE\n";
            }
        }
    }

    system("cls");
    cout << "Wszyscy gracze rzucili koscmi. Wcisnij dowolny klawisz, aby zobaczyc kto wygral!";
    getch();
    system("cls");
}

void interfejs()        // funkcja uruchamiająca program
{
    cout << "Wpisz liczbe graczy (od 2 do 10): ";
    short liczba_graczy;
    cin >> liczba_graczy;
    while(cin.fail() || liczba_graczy < 2 || liczba_graczy > 10)
    {
        cout << "Wpisales/wpisalas niepoprawna liczbe. Wpisz jeszcze raz: ";
        cin.clear();
        cin.ignore(99999, '\n');
        cin >> liczba_graczy;
    }

    gracze.resize(liczba_graczy);

    // wpisywanie imion graczy:
    cout << "Podaj imiona graczy\n";
    for(short i = 0; i < liczba_graczy; ++i)
    {
        cout << "\tGracz nr " << i + 1 << ": ";
        cin >> gracze[i].imie;
        gracze[i].nr = i + 1;
    }

    system("cls");

    cout << "Wpisz liczbe rund (od 1 do 5): ";
    cin >> rundy;
    while(cin.fail() || liczba_graczy < 1 || liczba_graczy > 5)
    {
        cout << "Wpisales/wpisalas niepoprawna liczbe. Wpisz jeszcze raz: ";
        cin.clear();
        cin.ignore(99999, '\n');
        cin >> rundy;
    }

    cout << "Wcisnij dowolny klawisz, aby rozpoczac gre...";
    getch();
    gra();
    sortuj_ranking();
    wypisz_ranking(true);
    cout << "\n\n\nWcisnij N, aby wyjsc z programu lub T, aby zagrac jeszcze raz...";

    char znak;
    do
    {
        znak = getch();
        znak = toupper(znak);
    }
    while(znak != 'T' && znak != 'N');

    if(znak == 'T')
    {
        system("cls");
        interfejs();
    }
}

int main()
{
    interfejs();
    return 0;
}