package logika;

import java.awt.*;
import java.util.ArrayList;

/**
 * Klasa Sciezka jest odpowiedzialna za ściezki tworzące bazy.
 */
public class Sciezka {
    /**
     * Lista pozycji w ścieżce, współrzędne kropek tworzących sciezke.
     */
    private ArrayList<Pozycja> pozycje = new ArrayList<Pozycja>();
    /**
     * kolor bazy
     */
    private TypKropki kolor;

    /**
     * zamienia typ bazy na kolor używany do rysowania kropek i linii w bazach
     *
     * @return kolor
     */
    public Color kolorSciezki() {
        return kolor == TypKropki.CZERWONA ? Color.RED : Color.BLUE;
    }

    /**
     * Konstruktor który przyjmuje za parametry współrzędne punktu startowego i na ich podstawie ustala kolor ścieżki
     *
     * @param x
     * @param y
     */
    public Sciezka(int x, int y) {
        kolor = Gra.pobierzInstancje().pobierzKomorke(x, y);
    }

    /**
     * Dodaje punkt startowy do ścieżki - pierwszą pozycję kropki
     *
     * @param x
     * @param y
     */
    public void dodajPunktStartowy(int x, int y) {
        pozycje.add(new Pozycja(x, y));
    }

    @Override
    /**
     * Zamienia ścieżkę na liczbę, która jest sumą wszystkich x kropek w liście pomnozona przez 2 i y pomnozonych przez 3.
     */
    public int hashCode() {
        int wartosc = 0;
        for (Pozycja pozycja : pozycje)
            wartosc += (pozycja.X * 2 + pozycja.Y * 3);
        return wartosc;
    }

    /**
     * Tworzy nową ścieżkę i kopiuje inną ścieżkię wraz z jej pozycjami i kolorem
     *
     * @return kopia
     */
    public Sciezka kopiuj() {
        Sciezka kopia = new Sciezka(pozycje.get(0).X, pozycje.get(0).Y);
        kopia.pozycje.addAll(pozycje);
        return kopia;
    }

    /**
     * Sprawdza, czy kropka o współrzędnych x,y należy już do ścieżki
     *
     * @param x
     * @param y
     * @return true, jezeli nalezy, false jezeli nie
     */
    public boolean zawieraPunkt(int x, int y) {
        for (Pozycja pozycja : pozycje) {
            if (pozycja.X == x && pozycja.Y == y)
                return true;
        }
        return false;
    }

    /**
     * Jest to metoda rekurencyjna. Działa na zasadzie przeszukiwania drzewa. Próbuje utworzyć ścieżkę idącą w każdym kierunku z danego punktu. Jeżeli następny sprawdzany punkt ma taki sam kolor, to jest ona wywoływana na jego rzecz rekurencyjnie.
     * Metoda kończy się, kiedy znalazła wszystkie możliwe ścieżki tak, że ich ostatni punkt byłby pierwszym.
     *
     * @param x
     * @param y
     * @param sciezka      kopia ścieżki idąca w innym kierunku
     * @param listaSciezek lista wszystkich ścieżek znalezionych przez algorytm
     * @return lista ścieżek
     */
    private static ArrayList<Sciezka> szukajSciezki(int x, int y, Sciezka sciezka, ArrayList<Sciezka> listaSciezek) {
        //sprawdza, czy lista istnieje, jezeli nie, to stworzy nową listę, żeby można było do niej dodawać
        if (listaSciezek == null)
            listaSciezek = new ArrayList<Sciezka>();
        //pętla stara się przejść przez wszystkie punkty dookoła
        for (int iy = y - 1; iy <= y + 1; iy++) {
            for (int ix = x - 1; ix <= x + 1; ix++) {
                //sprawdza, czy punkt należy do planszy, czy jest takiego samego koloru i sprawdza, czy punkt nie jest punktem startowym
                if (ix < Gra.WIELKOSC_PLANSZY && iy < Gra.WIELKOSC_PLANSZY && ix > 0 && iy > 0 && Gra.pobierzInstancje().pobierzKomorke(ix, iy) == sciezka.kolor && !(ix == x && iy == y)) {
                    //kopiuje dotychczasowa sciezke, bo idzie w innym kierunku
                    Sciezka kopia = sciezka.kopiuj();
                    //tworzy nową pozycję miejsca w które idziemy
                    Pozycja nowaPozycja = new Pozycja(ix, iy);
                    // sprawdza czy nastepna pozycja jest poczatkiem sciezki i czy wielkosc sciezki >=4 żeby wykluczyc zapetlenia
                    if (kopia.pozycje.get(0).equals(nowaPozycja) && kopia.pozycje.size() >= 4) {
                        //dodaje do listy sciezek skonczona sciezke
                        listaSciezek.add(kopia);
                        //sprawdza, czy sciezka nie przechodzi drugi raz przez ten sam punkt
                    } else if (!sciezka.zawieraPunkt(ix, iy)) {
                        //dodaje do kopii nową pozycję
                        kopia.pozycje.add(nowaPozycja);
                        //wywolanie metody jeszcze raz, rekurencyjnie, zeby szukala dalej
                        szukajSciezki(ix, iy, kopia, listaSciezek);
                    }
                }
            }
        }
        //po przejsciu przez wszystkie mozliwe sciezki zwraca listę ścieżek, które rzeczywiście można utworzyć
        return listaSciezek;
    }

    /**
     * Metoda jest odpowiedzialna za dodanie do listy baz ścieżek, które mozna utworzyć po wykonaniu ruchu
     *
     * @param x
     * @param y
     */
    public static void dodajSciezke(int x, int y) {
        //tworzymy nową sciezke startującą  w punkcie, w którym wykonano właśnie ruch (podstawowa pierwsza ścieżka)
        Sciezka poczatek = new Sciezka(x, y);
        // Punkt poczatkowy dodaje do sciezki
        poczatek.dodajPunktStartowy(x, y);
        // Szukanie wszystkich mozliwych sciezek z tego punktu
        ArrayList<Sciezka> sciezki = szukajSciezki(x, y, poczatek, new ArrayList<Sciezka>());
        // szukanie najdluzszej sciezki, z której mozna utworzyc baze
        Sciezka najdluzsza = null;
        //do sprawdzenia czy dodana sciezka pochodzi ma w sobie tylko jakas wspolrzedna, czy cala baze
        Sciezka zawartaWBazie = null;
        for (Sciezka sprawdzana : sciezki) {
            /**
             * Do sprawdzania czy punkt nalezy do wielokątu (czy kropka jest w srodku bazy) uzyłam klasy polygon, która zawiera taki algorytm
             */
            Polygon wielokat = new Polygon();
            for (Pozycja pozycja : sprawdzana.pozycje)
                wielokat.addPoint(pozycja.X, pozycja.Y);
            //zmienna, która stanowi o tym, czy w bazie znajduje sie chociaz jedna kropka innego koloru
            boolean zawieraInna = false;
            //petla przechodzi przez wszystkie punkty na naszej planszy gry i dla kazdego sprawdza, czy: jego kolor jest przeciwny do sciezki, czy nalezy do naszej bazy (w srodku), czy kropka jest w innej bazie i sprawdza, czy kropka nie nalezy juz do innej bazy i czy kropka w ogole nalezy do naszego wielokatu
            for (int py = 1; py < Gra.WIELKOSC_PLANSZY; py++) {
                for (int px = 1; px < Gra.WIELKOSC_PLANSZY; px++) {
                    if (Gra.pobierzInstancje().pobierzKomorke(px, py) != TypKropki.BRAK && Gra.pobierzInstancje().pobierzKomorke(px, py) != sprawdzana.kolor && !Gra.pobierzInstancje().czyKropkaZdobyta(px, py) && !Gra.pobierzInstancje().czyKropkaWBazie(px, py) && wielokat.contains(px, py)) {
                        //jezeli wszystkie warunki sa prawdziwe, to ustawiamy na true
                        zawieraInna = true;
                        //dodaje kropke do listy kropek zdobytych
                        Gra.pobierzInstancje().kropkaZdobyta(px, py);
                    }
                }
            }
            //sprawdza, czy sciezka ma jakakolwiek kropkę, która jest w środku
            if (zawieraInna) {
                //jezeli najdluzsza sciezka nie zostala jeszcze znaleziona lub znaleziona sciezka jest krotsza niz obecna, to zamieniamy najdluzsza na obecna
                if (najdluzsza == null || najdluzsza.pozycje.size() < sprawdzana.pozycje.size()) {
                    najdluzsza = sprawdzana;
                    zawartaWBazie = null;
                }

                // jezeli nie ma, to sprawdzmy czy zawiera jakas inna baze w calosci
            } else {
                // sprawdza wszystkie sciezki, jezeli jakas sie zawiera w srodku to dodaje
                for (Sciezka sciezka : Gra.pobierzInstancje().getSciezki()) {
                    // zaklada ze wszystkie naleza, a jak chociaz jedna nie nalezy to wtedy ustawia na false
                    boolean wszystkieNaleza = true;
                    for (Pozycja pozycja : sciezka.getPozycje()) {
                        //sprawdza, czy: jego kolor jest przeciwny do sciezki, czy nalezy do naszej bazy (w srodku), czy kropka jest w innej bazie i sprawdza i czy kropka w ogole nalezy do naszego wielokatu
                        if (!(Gra.pobierzInstancje().pobierzKomorke(pozycja.X, pozycja.Y) != TypKropki.BRAK && Gra.pobierzInstancje().pobierzKomorke(pozycja.X, pozycja.Y) != sprawdzana.kolor && !Gra.pobierzInstancje().czyKropkaZdobyta(pozycja.X, pozycja.Y) && wielokat.contains(pozycja.X, pozycja.Y))) {
                            wszystkieNaleza = false;
                            break;
                        }
                    }
                    if (wszystkieNaleza) {
                        najdluzsza = sprawdzana;
                        zawartaWBazie = sciezka;
                    }
                }
            }
        }
        //jezeli najdluzsza zosatala znaleziona, to dodaje ja do listy sciezek i tworzy z niej baze
        if (najdluzsza != null) {
            Gra.pobierzInstancje().getSciezki().add(najdluzsza);
            najdluzsza.stworzBaze();
            if (zawartaWBazie != null) {
                for (Pozycja pozycja : zawartaWBazie.pozycje)
                    Gra.pobierzInstancje().kropkaZdobyta(pozycja.X, pozycja.Y);
            }
        }
    }

    /**
     * tworzy baze ze sciezki
     */
    public void stworzBaze() {
        //przechodzi przez wszystkie pozycje i dodaje je do kropek w bazie
        for (Pozycja pozycja : pozycje)
            Gra.pobierzInstancje().kropkaWBazie(pozycja.X, pozycja.Y);
    }

    /**
     * Zwraca liste pozycji w  sciezce
     * @return pozycje
     */
    public ArrayList<Pozycja> getPozycje() {
        return pozycje;
    }
}