#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int rozmiar;
bool wTrakcie = false;
char tab[10][10];



struct Gracz
{
    string nick;
    int przegrane;
    int wygrane;
    int iloscGier;
};

Gracz gracz1;
Gracz gracz2;

struct Pole
{
    int val;
    int id;
    Pole(int ID)
    {
        val = 0;    // Wartosci od 0 do 2. 0 - pole puste, 1 - kolko, 2 - krzyzyk
        id = ID;    // Od 0 do rozmiar*rozmiar - 1
    }
    Pole *Gora      = NULL;
    Pole *PrawaGora = NULL;
    Pole *Prawo     = NULL;
    Pole *PrawyDol  = NULL;
    Pole *Dol       = NULL;
    Pole *LewyDol   = NULL;
    Pole *Lewo      = NULL;
    Pole *LewaGora  = NULL;
};

struct Ruch
{
    Ruch(int _id, int _ktory, bool _czyj)
    {
        Indeks = _id;
        Ktory = _ktory;
        Czyj = _czyj;
    }
    int Indeks; // Indeks modyfikowanego pola
    int Ktory;  // Ktory z kolei ruch od poczatku rozgrywki
    bool Czyj;  // Tura ktorego gracza
};

struct Lista
{
    Lista(Ruch * nowy)
    {
        ruch = nowy;
    }
    Lista * nastepne = NULL;
    Ruch * ruch;
};

void wyswietl(Pole * start, Lista *& poczatek);
void wyswietlInterfejs(Pole * start, Lista *& poczatek);
void wyswietlStatystyki(Pole * start, Lista *& poczatek);

Pole* wyszukaj(int wymiar, int nast, Pole * skad)
{
    Pole * temp = skad;
    int ileWPrawo = nast % wymiar - temp->id % wymiar;
    int ileWDol = nast / wymiar - temp->id / wymiar;
    if (ileWPrawo < 0)
    {
        ileWPrawo = -ileWPrawo;
        for (int i = 0; i < ileWPrawo; i++)
        {
            temp = temp->Lewo;
        }
    }
    else
    {
        for (int i = 0; i < ileWPrawo; i++)
        {
            temp = temp->Prawo;
        }
    }

    if (ileWDol < 0)
    {
        ileWDol = -ileWDol;
        for (int i = 0; i < ileWDol; i++)
        {
            temp = temp->Gora;
        }
    }
    else
    {
        for (int i = 0; i < ileWDol; i++)
        {
            temp = temp->Dol;
        }
    }
    return temp;
}

void Dodaj(Ruch * NowyElement, Lista ** poczatek)
{
    Lista * temp;
    temp = *poczatek;
    if (*poczatek == NULL)
    {
        *poczatek = new Lista(NowyElement);             //tworzy nowy (PIERWSZY) element listy,
                                                        //ktory zawiera wskaznik na nowy ruch
                                                        //odpali sie tylko przy pierwszym ruchu w grze
                                                        //i w sytuacji kiedy gracze cofna wszystkie ruchy
        // Uaktywnienie przycisku pozwalajacego na cofanie ruchu
    }
    else
    {
        while (temp->nastepne != NULL)
        {
            temp = temp->nastepne;              //poruszanie sie na koniec listy
        }
        temp->nastepne = new Lista(NowyElement);    //dodanie nowego elementu do listy
    }
}

void Zdejmij(Lista *& poczatek, Pole * start, bool tryb)
{
    int indeks;
    Lista * temp = poczatek;
    if (temp->nastepne == NULL)
    {
        indeks = temp->ruch->Indeks;
        wyszukaj(rozmiar, indeks, start)->val = 0;
        poczatek = NULL;                    //cofnieto wszystkie ruchy - lista jest pusta
        // Dezaktywacja przycisku pozwalajacego na cofanie ruchu
    }
    else
    {
        while (temp->nastepne->nastepne != NULL)
        {
            temp = temp->nastepne;              //poruszanie sie do przedostatniego elementu listy
        }
        indeks = temp->nastepne->ruch->Indeks;
        wyszukaj(rozmiar, indeks, start)->val = 0;
        delete temp->nastepne;                      //zmiana wskaznika na ostatni element na null -
        temp->nastepne = NULL;                      //przedostatni element jest teraz ostatnim
    }
    if (!tryb)
    {
        int x, y;
        x = indeks % rozmiar;
        y = indeks / rozmiar;
        tab[x][y] = '-';
        wyswietl(start, poczatek);
    }
}

void reinicjalizujPlansze(Pole * start)
{
    Pole * temp = start;

    bool parzysty = 1;
    for (int i = 0; i < rozmiar; i++)
    {
        parzysty = (i % 2 == 0);
        for (int j = 0; j < rozmiar; j++)
        {
            if (parzysty)
            {
                temp->id = rozmiar * i + j;
                if (j == rozmiar - 1)
                    temp = temp->Prawo;
                else if (temp->Dol != NULL)
                    temp = temp->Dol;
            }
            else
            {
                temp->id = rozmiar * i + rozmiar - j;
                if (j == rozmiar - 1)
                    temp = temp->Lewo;
                else if (temp->Dol != NULL)
                    temp = temp->Dol;
            }
        }
    }
}

void utworzPlansze(int n, int nastepnePole, Pole * start)
{
    if (start->Dol == NULL)
    {
        start->Dol = new Pole(start->id + 10);
        start->Dol->Gora = start;
    }
    if (start->Prawo == NULL)
    {
        start->Prawo = new Pole(start->id + 1);
        start->Prawo->Lewo = start;
    }
    start->Prawo->LewyDol = start->Dol;
    start->Dol->PrawaGora = start->Prawo;
    if (start->PrawyDol == NULL)
    {
        start->PrawyDol = new Pole(start->id + 10 + 1);
        start->PrawyDol->LewaGora = start;
    }
    start->Prawo->Dol = start->PrawyDol;
    start->PrawyDol->Gora = start->Prawo;
    start->Dol->Prawo = start->PrawyDol;
    start->PrawyDol->Lewo = start->Dol;
    n--;
    if (n == 0)
        return;

    if ((nastepnePole + 1) % 10 == 10 - 1)
        nastepnePole += 2;
    else
        nastepnePole++;

    utworzPlansze(n, nastepnePole, wyszukaj(10, nastepnePole, start));
}

bool sprawdzenieWygranej(Pole * start)
{
    //val pole - gracz 1 kółka, gracz 2 krzyżyk - ruch ktory == 0 - gracz 1, ruch ktory == 1 - gracz 2
    int max;
    if (rozmiar == 3)
        max = 3;
    else if (rozmiar == 4)
        max = 4;
    else if (rozmiar > 4)
        max = 5;

    int ile = 1;
    Pole * test = start;
    int wartoscTestowa = -1;
    if (test->val == 1)
    {
        wartoscTestowa = 1;
    }
    else if (test->val == 2)
    {
        wartoscTestowa = 2;
    }
    //testujemy dół/góra
    while (test->Dol != NULL)
    {
        if (test->Dol->val == wartoscTestowa)
        {
            ile++;
            test = test->Dol;
            if (ile == max)
                return true;
        }
        else
            break;
    }
    test = start;
    while (test->Gora != NULL)
    {
        if (test->Gora->val == wartoscTestowa)
        {
            ile++;
            test = test->Gora;
            if (ile == max)
                return true;
        }
        else
            break;
    }
    test = start;
    ile = 1;
    //testujemy prawo/lewo
    while (test->Prawo != NULL)
    {
        if (test->Prawo->val == wartoscTestowa)
        {
            ile++;
            test = test->Prawo;
            if (ile == max)
                return true;
        }
        else
            break;
    }
    test = start;
    while (test->Lewo != NULL)
    {
        if (test->Lewo->val == wartoscTestowa)
        {
            ile++;
            test = test->Lewo;
            if (ile == max)
                return true;
        }
        else
            break;
    }
    test = start;
    ile = 1;
    //testujemy prawodol/lewogora
    while (test->PrawyDol != NULL)
    {
        if (test->PrawyDol->val == wartoscTestowa)
        {
            ile++;
            test = test->PrawyDol;
            if (ile == max)
                return true;
        }
        else
            break;
    }
    test = start;
    while (test->LewaGora != NULL)
    {
        if (test->LewaGora->val == wartoscTestowa)
        {
            ile++;
            test = test->LewaGora;
            if (ile == max)
                return true;
        }
        else
            break;
    }
    test = start;
    ile = 1;
    //testujemy prawogora/lewodol
    while (test->PrawaGora != NULL)
    {
        if (test->PrawaGora->val == wartoscTestowa)
        {
            ile++;
            test = test->PrawaGora;
            if (ile == max)
                return true;
        }
        else
            break;
    }
    test = start;
    while (test->LewyDol != NULL)
    {
        if (test->LewyDol->val == wartoscTestowa)
        {
            ile++;
            test = test->LewyDol;
            if (ile == max)
                return true;
        }
        else
            break;
    }
    return false;
}

void inicjalizujMape(Pole * start)
{
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            tab[i][j] = '-';
        }
    }
    utworzPlansze(9*9, 0, start);
}

void czyscMape(Pole * start, Lista *& poczatek)
{
    while (poczatek != NULL)
    {
        Zdejmij(poczatek, start, 1);
    }
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            tab[i][j] = '-';
        }
    }
}

bool wykonajRuch(Pole * start, Lista *& poczatek, int x, int y)
{
    int indeks = x + rozmiar * y;
    Lista * test = poczatek;
    Pole * obecne = wyszukaj(rozmiar, indeks, start);
    if (obecne->val != 0)
    {
        cout << "Wykonano błędny ruch - pole jest już zajęte!!!\n";
        cout << "Wpisz dowolny znak aby wrócić do gry";
        char komenda;

        cin >> komenda;
        return false;
    }
    if (test != NULL)
    {
        while (test->nastepne != NULL)
        {
            test = test->nastepne;
        }
        if (test->ruch->Czyj)
        {
            obecne->val = 1;
        }
        else
        {
            obecne->val = 2;
        }
        Dodaj(new Ruch(indeks, test->ruch->Ktory++, !test->ruch->Czyj), &test);
        tab[x][y] = test->ruch->Czyj ? 'o' : 'x';
    }
    else
    {
        obecne->val = 1;
        Dodaj(new Ruch(indeks, 1, false), &poczatek);
        tab[x][y] = 'o';
    }

    if (sprawdzenieWygranej(obecne))
    {
        system("cls");
        int wygrana = test->ruch->Czyj ? 1 : 2;
        for (int i = 0; i < 5; i++)
        {
            cout << "Wygral gracz: " << wygrana << "!!!\n";
        }
        if (wygrana == 1)
        {
            gracz1.wygrane++;
            gracz1.iloscGier++;
            gracz2.przegrane++;
            gracz2.iloscGier++;
        }
        else
        {
            gracz1.przegrane++;
            gracz1.iloscGier++;
            gracz2.wygrane++;
            gracz2.iloscGier++;

            Gracz gracztemp = gracz1;
            gracz1 = gracz2;
            gracz2 = gracztemp;
        }
        cout << "Wpisz dowolny znak aby wrocic do poprzedniego menu\n";
        char komenda;
        cin >> komenda;
        wTrakcie = false;
        return true;
    }
    return false;
}

void pobierzGraczy()
{
    cout << "Podaj nick gracza 1:\n";

    cin >> gracz1.nick;

    cout << "Podaj nick gracza 2:\n";

    cin >> gracz2.nick;

    while (gracz1.nick == gracz2.nick)
    {
        cout << "Blad! Nie mozna wpisac drugi raz tego samego nicku!!!";
        cin >> gracz2.nick;
    }

    ifstream plikGracza1(gracz1.nick + "Save");
    ifstream plikGracza2(gracz2.nick + "Save");

    if (plikGracza1.is_open())
    {
        string number;
        getline(plikGracza1, number);
        gracz1.przegrane = stoi(number);
        getline(plikGracza1, number);
        gracz1.wygrane = stoi(number);
        getline(plikGracza1, number);
        gracz1.iloscGier = stoi(number);
    }
    else
    {
        gracz1.przegrane = 0;
        gracz1.wygrane = 0;
        gracz1.iloscGier = 0;
    }
    if (plikGracza2.is_open())
    {
        string number;
        getline(plikGracza2, number);
        gracz2.przegrane = stoi(number);
        getline(plikGracza2, number);
        gracz2.wygrane = stoi(number);
        getline(plikGracza2, number);
        gracz2.iloscGier = stoi(number);
    }
    else
    {
        gracz2.przegrane = 0;
        gracz2.wygrane = 0;
        gracz2.iloscGier = 0;
    }
    plikGracza1.close();
    plikGracza2.close();
}

void zapisz()
{
    ofstream plikGracza1(gracz1.nick + "Save");
    ofstream plikGracza2(gracz2.nick + "Save");

    plikGracza1 << gracz1.przegrane << "\n";
    plikGracza1 << gracz1.wygrane   << "\n";
    plikGracza1 << gracz1.iloscGier << "\n";

    plikGracza2 << gracz2.przegrane << "\n";
    plikGracza2 << gracz2.wygrane   << "\n";
    plikGracza2 << gracz2.iloscGier << "\n";
}

void wyswietlStatystyki(Pole * start, Lista *& poczatek)
{
    system("cls");
    cout << "Gracz 1 "      << gracz1.nick      << ":\n"
         << "Liczba gier: " << gracz1.iloscGier << "\n"
         << "Wygranych: "   << gracz1.wygrane   << "\n"
         << "Przegranych: " << gracz1.przegrane << "\n\n";

    cout << "Gracz 2 "      << gracz2.nick << ":\n"
        << "Liczba gier: "  << gracz2.iloscGier << "\n"
        << "Wygranych: "    << gracz2.wygrane << "\n"
        << "Przegranych: "  << gracz2.przegrane << "\n\n";

    cout << "Wpisz dowolny znak aby wrocic do poprzedniego menu\n";
    char komenda;
    cin >> komenda;
    wyswietlInterfejs(start, poczatek);
}

void wyswietl(Pole * start, Lista *& poczatek)
{
    system("cls");
    cout << " ";
    for (int i = 0; i < rozmiar; i++)
        cout << i + 1;
    cout << "\n";
    for (int i = 0; i < rozmiar; i++)
    {
        cout << i + 1;
        for (int j = 0; j < rozmiar; j++)
        {
            cout << tab[i][j];
        }
        cout << "\n";
    }
    cout << "Ruch gracza ";
    if (poczatek == NULL)
        cout << gracz1.nick << " (Kolko)\n";
    else
    {
        Lista * temp;
        temp = poczatek;
        while (temp->nastepne != NULL)
        {
            temp = temp->nastepne;
        }
        if (temp->ruch->Czyj)
        {
            cout << gracz1.nick << " (Kolko)\n";
        }
        else
        {
            cout << gracz2.nick << " (Krzyzyk)\n";
        }
    }

    cout << "\nPodaj komende:\n"
        << "1. Wykonaj ruch\n"
        << "2. Cofnij ruch\n"
        << "3. Powrot do menu\n";

    int komenda;

    cin >> komenda;

    switch (komenda)
    {
    case 1:
        cout << "Podaj numer pola (wspolrzedne x, y)\n";
        int x, y;
        cin >> x >> y;
        if (wykonajRuch(start, poczatek, x - 1, y - 1))
            czyscMape(start, poczatek);
        wyswietl(start, poczatek);
        break;
    case 2:
        if (poczatek != NULL)
            Zdejmij(poczatek, start, false);
        else
            wyswietl(start, poczatek);
        break;
    default:
        wyswietlInterfejs(start, poczatek);
        break;
    }
}

void wyswietlInterfejs(Pole * start, Lista *& poczatek)
{

    system("cls");
    cout << "Co chcecie zrobic?\n"
         << "1. Gra\n"
         << "2. Statystyki\n"
         << "3. Wyjscie\n";
    int komenda;
    cin >> komenda;

    switch (komenda)
    {
    case 1:
        if (wTrakcie)
            wyswietl(start, poczatek);
        else
        {
            if (!wTrakcie)
            {
                cout << "Podaj rozmiar mapy (z zakresu od 3 do 10)\n";
                cin >> rozmiar;
                while (rozmiar > 10 || rozmiar < 3)
                {
                    cout << "Bledny rozmiar. Nalezy podac liczbe z zakresu 3 do 10.\n";
                    cin >> rozmiar;
                }
                reinicjalizujPlansze(start);
                wTrakcie = true;
                wyswietl(start, poczatek);
            }
            else
                wyswietl(start, poczatek);
        }

        break;
    case 2:
        wyswietlStatystyki(start, poczatek);
        break;
    default:
        break;
    }
}

int main()
{
    Pole * start = new Pole(0);
    Lista * poczatek = NULL;
    inicjalizujMape(start);
    pobierzGraczy();
    wyswietlInterfejs(start, poczatek);
    zapisz();
    return 0;
}