#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{




};


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 ruch_pionka(Pionek *pionek,Pionek* tablica[], int kostka) //int kostka,
{
    int m;

    if(pionek->w_grze == false)
    {
        pionek->w_grze = true;
        switch( pionek->kolor)
        {
        case czerwony:
            pionek->ustaw_polozenie(20);
            break;
        case zielony:
            pionek->ustaw_polozenie(10);
            break;
        case zolty:
            pionek->ustaw_polozenie(0);
            break;
        case niebieski:
            pionek->ustaw_polozenie(30);
            break;
        }
    }
    else
    {
//przesuwanie pionka

        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);
    }
}
kolor_pionka zwroc_kolor_nastepnego(kolor_pionka a)
{
    if(a==zolty)
        return zielony;
    if(a== zielony)
        return czerwony;
    if(a==czerwony)
        return niebieski;
    if(a==niebieski)
        return zolty;

}

int main()
{
    int i;
    srand( time( NULL ) );
 int kostka;
  bool czy_losowac=true;
  kolor_pionka aktualny;
  aktualny = zielony;



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


    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)
                {

                    ruch_pionka(pionek,Pionki,kostka);
                    czy_losowac=true;
                    aktualny=zwroc_kolor_nastepnego(pionek->kolor);


                }
            }
    }

        oknoAplikacji.clear( sf::Color::Black );
        oknoAplikacji.draw(obrazek);
        int i;
        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);
        oknoAplikacji.display();
    }
    for(i=0; i<liczbaPionkow; i++)
    {
        delete(Pionki[i]);
    }
return 0;
}