#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include<stdio.h>
#include "Domek.h"
#include<stdlib.h>
#include<iostream>
#include "wspolrzedne.h"
#include "Pionek.h"
#include "klikniecie.h"
#include "Kostka.h"

class Gracz
{

public:
    kolor_pionka kolor;
    Gracz(kolor_pionka kolor)
    {
        this->kolor = kolor;
    }


};

Kostka::Kostka(sf::RenderWindow *oknoAplikacji)
{


    this->oknoAplikacji= oknoAplikacji;
    cube[0].loadFromFile("kostka1.png");
    cube[1].loadFromFile("kostka2.png");
    cube[2].loadFromFile("kostka3.png");
    cube[3].loadFromFile("kostka4.png");
    cube[4].loadFromFile("kostka5.png");
    cube[5].loadFromFile("kostka6.png");
    int i;
    for(i=0; i<6; i++)
    {
        kostki[i].setTexture(cube[i]);
    }

}

void Kostka:: wyswietl_kostke(int liczba_oczek, kolor_pionka a)
{
    if(liczba_oczek>0)
    {
        oknoAplikacji->draw(kostki[liczba_oczek-1]);
        if(a==czerwony)
        {
            kostki[liczba_oczek-1].setPosition(430,500);
        }
        if(a==niebieski)
        {
            kostki[liczba_oczek-1].setPosition(130,500);
        }

        if(a==zolty)
        {
            kostki[liczba_oczek-1].setPosition(130,10);
        }
        if(a==zielony)
        {
            kostki[liczba_oczek-1].setPosition(430,10);
        }
    }
}

int rzut_kostka()
{
    int kostka = (rand()%6) + 1;
    return kostka;

}
bool czy_w_domku(Pionek* tablica[], kolor_pionka kolorek)
{
    int i;

    for(i=0; i<=liczbaPionkow; i++)
    {
        if( kolorek == tablica[i]->kolor && tablica[i]->w_grze==true)
        {
            return false;
        }
    }
    return true;
}

using namespace std;

int na_jakie_pole_przejdzie(Pionek* pionek, int kostka)
{

    int przyszla_pozycja;
    int aktualna_pozycja;
    int start, roznica, start_bazy;
    przyszla_pozycja = pionek->pobierz_polozenie() + kostka;
    aktualna_pozycja = pionek->pobierz_polozenie();
    if(pionek->kolor == czerwony)
    {
        start = 20;
        roznica = 28;
        start_bazy = 48;
    }
    else if(pionek->kolor == niebieski)
    {
        start = 30;
        roznica = 15;
        start_bazy = 44;

    }
    else if(pionek->kolor == zielony)
    {
        start = 10;
        roznica = 43;
        start_bazy = 52;

    }
    else if(pionek->kolor == zolty)
    {
        start = 40;
        roznica = 0;
        start_bazy = 40;

    }

    if (przyszla_pozycja >= start && aktualna_pozycja<start)
    {
        if(przyszla_pozycja>=start && przyszla_pozycja<=(start+3))
        {
            return przyszla_pozycja + roznica ;
        }
        else
            return aktualna_pozycja;
    }

    if(aktualna_pozycja>=start_bazy && aktualna_pozycja<=(start_bazy+3))
    {
        if(przyszla_pozycja>(start_bazy+3))
            return aktualna_pozycja;

        else
            return przyszla_pozycja;
    }


    return przyszla_pozycja %40;

}

Pionek* spytaj_o_pole(Pionek* tablica[], int nr_pola)
{
    int i;
    for(i=0; i<liczbaPionkow; i++)
    {
        if(tablica[i]->pobierz_polozenie() == nr_pola)
            return tablica[i];
    }
    return NULL;
}


void na_start(Pionek *pionek,Pionek* tablica[], int kostka)
{

    if(pionek->w_grze == false)
    {
        pionek->w_grze = true;
        Pionek *p;
        int start;

        switch( pionek->kolor)
        {
        case czerwony:
            start=20;
            pionek->ustaw_polozenie(start);
            break;
        case zielony:
            start = 10;
            pionek->ustaw_polozenie(start);
            break;
        case zolty:
            pionek->w_grze = true;
            start=0;
            pionek->ustaw_polozenie(start);
            break;
        case niebieski:
            start=30;
            pionek->ustaw_polozenie(start);
            break;
        }
    }
}


void ruch_pionka(Pionek *pionek,Pionek* tablica[], int kostka)
{
    int m;
    Pionek *p;
    m = na_jakie_pole_przejdzie(pionek,kostka);
    p = spytaj_o_pole(tablica,m);



    if(p!= NULL)
    {
        if(pionek->kolor != p->kolor)
        {
            p->wroc_do_domku();
        }
        else
            return;
    }
    pionek->ustaw_polozenie(m);
}

Gracz red(czerwony);
Gracz blue(niebieski);
Gracz green(zielony);
Gracz yellow(zolty);


Gracz* zwroc_kolor_nastepnego(kolor_pionka a)
{
    if(a==zolty)
        return &green;
    if(a== zielony)
        return &red;
    if(a==czerwony)
        return &blue;
    if(a==niebieski)
        return &yellow;

}


int main()
{
    int i;
    srand( time( NULL ) );
    int kostka;
    bool czy_losowac=true;
    Gracz* aktualny;
    bool czy_poczatek;


    sf::RenderWindow oknoAplikacji( sf::VideoMode( 600, 600, 32 ), "Chinczyk" );

    sf::Texture plansza;
    plansza.loadFromFile( "chinczyk.png" );
    sf::Sprite obrazek;
    obrazek.setTexture( plansza );
    Kostka kosteczka(&oknoAplikacji);

    //postawienie pionków;

    Pionek* Pionki[liczbaPionkow];

    Domek czerwony_domek(490,490, "czerwony.png", czerwony);
    czerwony_domek.dodaj_pionka(&Pionki[0]);

    Domek niebieski_domek(0,490, "niebieski.png", niebieski);
    niebieski_domek.dodaj_pionka(&Pionki[4]);

    Domek zielony_domek (490, 0, "zielony.png", zielony);
    zielony_domek.dodaj_pionka(&Pionki[8]);

    Domek zolty_domek (0, 0, "zolty.png", zolty);
    zolty_domek.dodaj_pionka(&Pionki[12]);
//od tych zaczynamy:
    aktualny = &yellow;


    while( oknoAplikacji.isOpen() )
    {
        sf::Event zdarzenie;
        while( oknoAplikacji.pollEvent( zdarzenie ) )
        {
            if( zdarzenie.type == sf::Event::Closed )
                oknoAplikacji.close();

            if( zdarzenie.type == sf::Event::KeyPressed && zdarzenie.key.code == sf::Keyboard::Escape )
                oknoAplikacji.close();

            if( zdarzenie.type == sf::Event::MouseButtonPressed && zdarzenie.mouseButton.button == sf::Mouse::Middle )
                oknoAplikacji.close();

            if(zdarzenie.type == sf::Event::MouseButtonReleased && zdarzenie.mouseButton.button== sf::Mouse::Left)

            {
                Pionek *pionek = zwroc_kliknietego_pionka(sf::Mouse::getPosition(oknoAplikacji), Pionki);
                if(pionek != NULL && pionek->kolor==aktualny->kolor)
                {
                    czy_losowac=true;
                    czy_poczatek = czy_w_domku(Pionki,aktualny->kolor);
                    if(czy_poczatek==true){
                    if(pionek->w_grze==false)
                    {
                        na_start(pionek,Pionki,kostka);
                    }}
                    else
                        ruch_pionka(pionek,Pionki,kostka);
                    aktualny=zwroc_kolor_nastepnego(pionek->kolor);
                }
            }
        }

        oknoAplikacji.clear( sf::Color::Black );
        oknoAplikacji.draw(obrazek);
        for(i=0; i<liczbaPionkow; i++)
        {
            oknoAplikacji.draw(*(Pionki[i]->zwracanie_sprite()));
        }

        if(czy_losowac)
        {
            kostka = rzut_kostka();
            czy_losowac = false;
        }

        kosteczka.wyswietl_kostke(kostka,aktualny->kolor);
        oknoAplikacji.display();

    }
    for(i=0; i<liczbaPionkow; i++)
    {
        delete(Pionki[i]);
    }
    return 0;
}