#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)
{
    suma, 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

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, 1) && czy_jest(kosci, 2) && czy_jest(kosci, 3) && czy_jest(kosci, 4) && czy_jest(kosci, 5)) return true;
    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)) return true;
    if(czy_jest(kosci, 5) && czy_jest(kosci, 2) && czy_jest(kosci, 3) && czy_jest(kosci, 4)) return true;
    if(czy_jest(kosci, 5) && czy_jest(kosci, 6) && czy_jest(kosci, 3) && czy_jest(kosci, 4)) return true;
    return false;
}

Kombinacje wynik(short* kosci)      // funkcja zwracająca wynik z wyrzuconych kości
{
    bool flaga = true;
    // sprawdzanie genera³a
    for(short i = 1; i < 5; ++i)
        if(kosci[i] != kosci[0])
        {
            flaga = false;
            break;
        }
    if(flaga) return Kombinacje::general;

    // sprawdzanie duzego strita
    if(duzystrit(kosci)) return Kombinacje::duzy_strit;

    // sprawdzanie malego strita
    if(malystrit(kosci)) return Kombinacje::maly_strit;

    // 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])) return Kombinacje::full;

    // sprawdzanie czwórki
    if((kosci[0] == kosci[1] && kosci[1] == kosci[2] && kosci[2] == kosci[3]) || (kosci[1] == kosci[2] && kosci[2] == kosci[3] && kosci[3] == kosci[4])) return Kombinacje::czworka;

    // sprawdzanie trojki
    if((kosci[0] == kosci[1] && kosci[1] == kosci[2]) || (kosci[1] == kosci[2] && kosci[2] == kosci[3]) || (kosci[2] == kosci[3] && kosci[3] == kosci[4])) return Kombinacje::trojka;

    return Kombinacje::suma;
}

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::suma:
        return "brak kombinacji";
    case Kombinacje::trojka:
        return "trojka";
    }
}

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);
}

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

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);
    }
    if(znak == 'N')
        cout << "NIE\n";

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

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

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

    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);
    }

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

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

bool operator==(Gracz A, Gracz B)
{
    if(A.wynik == B.wynik && 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()
{
    short ile = gracze.size();
    short miejsce = 1;

    // wypisanie pierwszego miejsca:
    cout << "1. Gracz nr " << gracze[0].nr << "\t(" << gracze[0].imie << ")\t" << "wynik: " << wypisz_wynik(gracze[0].wynik) << " (suma oczek: " << gracze[0].wynik2 << ")\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: " << wypisz_wynik(gracze[i].wynik) << " (suma oczek: " << gracze[i].wynik2 << ")\n";
    }

    // 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 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 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;
    }

    cout << "Wcisnij dowolny klawisz, aby rozpoczac gre...";
    getch();
    gra();
    sortuj_ranking();
    wypisz_ranking();
    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;
}