// Head.h
#ifndef HEAD_H
#define HEAD_H

#include <iostream>

using namespace std;

class Gra;
class Gracz;
class Gracz_cmp;
class Gracz_user;
class Interfejs;
class Plansza;

struct wspolrzedne
{
    int x;
    int y;
};

wspolrzedne konwertuj(string);

#endif // HEAD_H

// Funkcje.cpp
#include "Head.h"

wspolrzedne konwertuj(string pole)
{
    wspolrzedne wynik;
    wynik.x = static_cast<int>(pole[0] - 65);
    wynik.y = static_cast<int>(pole[1] - 48);
    return wynik;
}

// main.cpp
#include "Interfejs.h"

using namespace std;

int main()
{
    Interfejs interfejs;
    interfejs.start();

    return 0;
}

// Gra.h
#ifndef GRA_H
#define GRA_H

#include "Head.h"

class Gra
{
    friend class Gracz_cmp;
    friend class Gracz_user;
    friend class Interfejs;
public:
    Gra(Plansza*, Gracz*, Gracz*);
    void graj();
private:
    bool aktywna;
    Gracz* gracz1;
    Gracz* gracz2;
    Plansza* plansza;
};

#endif // GRA_H

// Gra.cpp
#include <conio.h>
#include <iostream>
#include "Gra.h"
#include "Gracz.h"
#include "Plansza.h"

using namespace std;

/*class Gra
{
    friend class Gracz_cmp;
    friend class Gracz_user;
    friend class Interfejs;
public:
    Gra(Plansza*, Gracz*, Gracz*);
    void graj();
private:
    bool aktywna;
    Gracz* gracz1;
    Gracz* gracz2;
    Plansza* plansza;
};*/

Gra::Gra(Plansza* board, Gracz* p1, Gracz* p2) : plansza(board), gracz1(p1), gracz2(p2), aktywna(true)
{
}

void Gra::graj()
{
    cout << "Uruchamiam gre\n";
    while (aktywna)
    {
        plansza->wyswietl();
        gracz1->ruch();
        if (plansza->czy_koniec())
        {
            aktywna = false;
            break;
        }
        plansza->wyswietl();
        gracz2->ruch();
        if (plansza->czy_koniec())
        {
            aktywna = false;
            break;
        }
        cout << "Tura zostala wykonana, wcisnij dowolny klawisz...\n";
        _getch();
    }
}

// Gracz.h
#ifndef GRACZ_H
#define GRACZ_H

#include "Head.h"

class Gracz
{
public:
    Gracz(char);
    virtual void ruch() = 0;
    void set_gra(Gra*);
protected:
    char symbol;
    Gra* gra;
};

#endif // GRACZ_H

// Gracz.cpp
#include "Gracz.h"

/*class Gracz
{
public:
    Gracz(char);
    virtual void ruch() = 0;
    void set_gra(Gra*);
protected:
    char symbol;
    Gra* gra;
};*/

Gracz::Gracz(char znak) : symbol(znak), gra(nullptr)
{
}

void Gracz::set_gra(Gra* game)
{
    gra = game;
}

// Gracz_cmp.h
#ifndef GRACZ_CMP_H
#define GRACZ_CMP_H

#include "Gracz.h"
#include "Head.h"

class Gracz_cmp : public Gracz
{
public:
    Gracz_cmp(char);
    void ruch();
};

#endif // GRACZ_CMP_H

// Gracz_cmp.cpp
#include <conio.h>
#include <ctime>
#include <iostream>
#include "Gra.h"
#include "Gracz_cmp.h"
#include "Plansza.h"

using namespace std;

/*class Gracz_cmp : public Gracz
{
public:
    Gracz_cmp(char);
    void ruch();
};*/

Gracz_cmp::Gracz_cmp(char znak) : Gracz(znak)
{
}

void Gracz_cmp::ruch()
{
    cout << "Komputer wykonuje ruch\n";
    gra->plansza->lista_wolnych_pol();
    //gra->plansza->wypisz_wolne_pola();
    srand(static_cast<unsigned>(time(nullptr)));

    int wybor = rand() % gra->plansza->wolne_pola.size();
    gra->plansza->zapelnij_pole(gra->plansza->wolne_pola[wybor], symbol);
    cout << "Ruch komputera wykonany, wcisnij dowolny klawisz...\n";
    _getch();
}

// Gracz_user.h
#ifndef GRACZ_USER_H
#define GRACZ_USER_H

#include <iostream>
#include "Gracz.h"
#include "Head.h"

using namespace std;

class Gracz_user : public Gracz
{
public:
    Gracz_user(string, char);
    void ruch();
private:
    string imie;
};

#endif // GRACZ_USER_H

// Gracz_user.cpp
#include "Gra.h"
#include "Gracz_user.h"
#include "Plansza.h"

/*class Gracz_user : public Gracz
{
public:
    Gracz_user(string, char);
    void ruch();
private:
    string imie;
};*/

Gracz_user::Gracz_user(string name, char znak) : Gracz(znak), imie(name)
{
}

void Gracz_user::ruch()
{
    cout << "Uzytkownik wykonuje ruch\n";
    cout << "Podaj wspolrzedne, gdzie chcesz wstawic " << symbol << ": (np. B3)";
    string pole;
    cin >> pole;

    // !!!! wpisaæ sprawdzenie wspó³rzêdnych!
    wspolrzedne xy = konwertuj(pole);
    gra->plansza->zapelnij_pole(xy, symbol);
    cout << "Ruch gracza wykonany, wcisnij dowolny klawisz...\n";
}

// Interfejs.h
#ifndef INTERFEJS_H
#define INTERFEJS_H

#include "Head.h"

class Interfejs
{
public:
    Interfejs();
    ~Interfejs();
    void start();
private:
    Gra* gra;
    Gracz* gracz1;
    Gracz* gracz2;
    Plansza* plansza;
};

#endif // INTERFEJS_H

// Interfejs.cpp
#include <conio.h>
#include <iostream>
#include "Gra.h"
#include "Gracz_cmp.h"
#include "Gracz_user.h"
#include "Interfejs.h"
#include "Plansza.h"

using namespace std;

/*class Interfejs
{
public:
    Interfejs();
    ~Interfejs();
    void start();
private:
    Gra* gra;
    Gracz* gracz1;
    Gracz* gracz2;
    Plansza* plansza;
};*/

Interfejs::Interfejs() : plansza(nullptr), gra(nullptr), gracz1(nullptr), gracz2(nullptr)
{
}

Interfejs::~Interfejs()
{
    if (plansza)
        delete plansza;
    if (gra)
        delete gra;
    if (gracz1)
        delete gracz1;
    if (gracz2)
        delete gracz2;
    cout << "Intefejs usuniety\n";
}

void Interfejs::start()
{
    cout << "Wpisz swoje imie: ";
    string name;
    cin >> name;

    cout << "Kto ma zaczynac gre? (U - uzytkownik, K - komputer): ";
    char wybor;
    do
    {
        wybor = _getch();
    } while (wybor != 'k' && wybor != 'K' && wybor != 'u' && wybor != 'U');
    wybor = toupper(wybor);
    cout << wybor << endl;

    if (wybor == 'K')        // zaczyna komputer
    {
        gracz1 = new Gracz_cmp('O');
        gracz2 = new Gracz_user(name, 'X');
    }

    else                    // zaczyna u¿ytkownik
    {
        gracz1 = new Gracz_user(name, 'O');
        gracz2 = new Gracz_cmp('X');
    }

    cout << "Okresl jak duza ma byc plansza (minimum 5, maksimum 26): ";
    int rozmiar;
    cin >> rozmiar;
    while (rozmiar < 5 || rozmiar > 26)
    {
        cout << "Podany przez Ciebie rozmiar nie jest prawidlowy, wpisz jeszcze raz: ";
        cin >> rozmiar;
    }

    // tworzymy planszę
    plansza = new Plansza(rozmiar);

    // tworzymy grę
    gra = new Gra(plansza, gracz1, gracz2);
    gracz1->set_gra(gra);
    gracz2->set_gra(gra);

    gra->graj();
}

// Plansza.h
#ifndef PLANSZA_H
#define PLANSZA_H

#include <vector>
#include "Head.h"

using namespace std;

class Plansza
{
    friend class Gracz_cmp;
    friend class Gracz_user;
private:
    char** tablica;
    int rozmiar;
    vector<wspolrzedne> wolne_pola;
public:
    Plansza(int);
    ~Plansza();
    bool czy_koniec();
    bool czywolne(wspolrzedne);
    void lista_wolnych_pol();
    void wypisz_wolne_pola();
    void wyswietl();
    void zapelnij_pole(wspolrzedne, char);
};

#endif // PLANSZA_H

// Plansza.cpp
#include <iostream>
#include "Plansza.h"

using namespace std;

/*class Plansza
{
    friend class Gracz_cmp;
    friend class Gracz_user;
private:
    char** tablica;
    int rozmiar;
    vector<wspolrzedne> wolne_pola;
public:
    Plansza(int);
    ~Plansza();
    bool czy_koniec();
    bool czywolne(wspolrzedne);
    void lista_wolnych_pol();
    void wypisz_wolne_pola();
    void wyswietl();
    void zapelnij_pole(wspolrzedne, char);
};*/

Plansza::Plansza(int wielkosc) : rozmiar(wielkosc)
{
    tablica = new char* [rozmiar];
    for (int i = 0; i < rozmiar; ++i)
    {
        tablica[i] = new char[rozmiar];
        for (int j = 0; j < rozmiar; ++j)
            tablica[i][j] = ' ';
    }
}
Plansza::~Plansza()
{
    for (int i = 0; i < rozmiar; ++i)
    {
        delete[] tablica[i];
    }
    delete[] tablica;
    cout << "Plansza zostala usunieta" << endl;
}

bool Plansza::czy_koniec()
{
    cout << "Sprawdzam czy gra ma byc kontynuowana\n";
    return false;
}

bool Plansza::czywolne(wspolrzedne xy)
{
    if (tablica[xy.x][xy.y] == ' ')
        return true;
    return false;
}

void Plansza::lista_wolnych_pol()
{
    wspolrzedne xy;
    for (int i = 0; i < rozmiar; ++i)
        for (int j = 0; j < rozmiar; ++j)
        {
            xy.x = i;
            xy.y = j;
            if (czywolne(xy))
                wolne_pola.push_back(xy);
        }
}

void Plansza::wypisz_wolne_pola()
{
    for (int i = 0; i < wolne_pola.size(); ++i)
    {
        cout << "(" << wolne_pola[i].x << "," << wolne_pola[i].y << "), ";
    }
    cout << endl;
}

void Plansza::wyswietl()
{
    for (int i = 0; i < rozmiar + 2; ++i)
        cout << '_';
    cout << endl;
    for (int i = 0; i < rozmiar; ++i)
    {
        cout << '|';
        for (int j = 0; j < rozmiar; ++j)
            cout << tablica[i][j];
        cout << '|' << endl;
    }
    for (int i = 0; i < rozmiar + 2; ++i)
        cout << '_';
    cout << endl;
}

void Plansza::zapelnij_pole(wspolrzedne xy, char symbol)
{
    tablica[xy.x][xy.y] = symbol;
}