import field, pathfinding_tractorless
import random

class main():

    def __init__(self,traktor,field,ui,path):
        self.traktor = traktor
        self.field = field
        self.ui = ui
        self.path = path
        self.pathfinding = pathfinding_tractorless.pathfinding_tractorless()

    def zliczanie_wystapien(self):                          #zlicza wystepowanie kazdego z rodzajow pol na planszy
        tabela_wystapien = [0,0,0,0]
        for i in self.field.field_matrix:
            for j in i:
                if j == 1 or j == 3 or j == 5 or j == 7:    #zliczanie zachwaszczonych pól
                    tabela_wystapien[0] = tabela_wystapien[0] + 1 
                elif j == 1 or j == 2 or j == 3:            #zliczanie nienawodnionych pól
                    tabela_wystapien[1] = tabela_wystapien[1] + 1
                elif j == 4:                                #zliczanie pól gotowych do zasadzenia
                    tabela_wystapien[2] = tabela_wystapien[2] + 1
                elif j == 8:                                #zliczanie pól gotowych do zbiorów
                    tabela_wystapien[3] = tabela_wystapien[3] + 1
                else:
                    pass

    def wspolrzedne(self):                                  #wyznacza wspolrzedne pol danego rodzaju na planszy
        pola_buraczane = []
        k = 0
        for i in self.field.field_matrix:
            l = 0
            for j in i:
                if j == 8:                                  #w tym przypadku pol z burakami
                    pola_buraczane.append(k*10+l)
                l = l + 1
            k = k + 1
        pierwsze_szukane_pole = pola_buraczane[0]
        pola_buraczane.append(pierwsze_szukane_pole)
        print("Współrzędne pól buraczanych: " + str(pola_buraczane))
        return pola_buraczane

    def trasa_buraczana(self,pola_buraczane):               #wyznacza koszt trasy przez pola danego rodzaju w zadanej kolejnosci
        self.liczba_pol = len(pola_buraczane)
        total_cost = 0
        i = 0
        while i < (self.liczba_pol-1):
            total_cost = total_cost + self.pathfinding.pathfinding_tractorless(self.field,pola_buraczane,i)
            i = i + 1
        #print("Koszt przejścia przez pola buraczane rzędami: " + str(total_cost))
        #print("###################")
        return total_cost

    def tworzenie_pokolenia(self,pola_buraczane,i):
        x = len(pola_buraczane) - 2
        wspolrzedne_shuffle = []
        while x > 1:
            wspolrzedne_shuffle.append(pola_buraczane[x])
            x = x - 1
        x = len(pola_buraczane) - 2
        lista_osobnikow = []    
        while i > 0:                    #liczebność pierwszego pokolenia (domyślnie 10)
            nowy_osobnik = random.sample(wspolrzedne_shuffle, len(wspolrzedne_shuffle))
            nowy_osobnik.insert(0,0)    #dodanie na początek listy 0, jako współrzenej startowej
            nowy_osobnik.insert(x,0)    #dodanie na koniec listy 0, jako współrzenej końcowej
            lista_osobnikow.append(nowy_osobnik)
            i = i - 1
        print(lista_osobnikow)
        return lista_osobnikow

    def ocena_przystosowania(self,pokolenia):
        suma_kosztow_tras = 0
        ile_osobnikow = 0
        koszty_tras_osobnikow = []
        for i in pokolenia:
            koszty_tras_osobnikow.append(self.trasa_buraczana(i))
            suma_kosztow_tras = suma_kosztow_tras + self.trasa_buraczana(i)
            ile_osobnikow = ile_osobnikow + 1
        srednie_przystosowanie = suma_kosztow_tras/ile_osobnikow #parametr potrzebny do oceny przystosowania osobnikow
        przystosowanie_osobnikow = []
        sumaryczne_przystosowanie_osobnikow = 0
        l = 0
        for i in koszty_tras_osobnikow:
            przystosowanie_osobnikow.append(round(((srednie_przystosowanie/koszty_tras_osobnikow[l])*10),2))
            sumaryczne_przystosowanie_osobnikow += round(((srednie_przystosowanie/koszty_tras_osobnikow[l])*10),2)
            l = l + 1 
        print(str(round(sumaryczne_przystosowanie_osobnikow,2)))
        print("Ocena przystosowania każdego z osobników: " + str(przystosowanie_osobnikow))
        print("Koszty tras każdego z osobników: " + str(koszty_tras_osobnikow))
        print("Średnie przystosowanie wszystkich osobników: " + str(srednie_przystosowanie))
        return(przystosowanie_osobnikow)

    def wybor_populacji_posredniej(self,pierwsze_pokolenie,przystosowanie_osobnikow):
        x = len(przystosowanie_osobnikow)
        tabela_ruletki = []
        populacja_posrednia = []
        i = 0
        przedzial = 0
        while x > 0:                            #stworzenie "koła ruletki" do selecji osobników populacji pośredniej
            przedzial = przedzial + przystosowanie_osobnikow[i]
            tabela_ruletki.append(round(przedzial,2))
            x = x - 1
            i = i + 1
        print(str(tabela_ruletki))
        x = len(przystosowanie_osobnikow)/2     #losowanie połowy liczby osobników populacji początkowej do populacji pośredniej
        maks = tabela_ruletki[i-1]
        while x > 0:
            i = 0
            n = random.uniform(0, maks)         #losowanie przedziału
            while n > tabela_ruletki[i]:
                i = i + 1
            populacja_posrednia.append(pierwsze_pokolenie[i])            
            x = x - 1
        print(str(populacja_posrednia)) #populacja posrednia, z której zostanie utworzona populacja potomków
        return populacja_posrednia

    def krzyzowanie(self,populacja_posrednia):
        x = len(populacja_posrednia) - 1
        while x > 0:
            rodzic_1 = populacja_posrednia[x]
            print("Rodzic nr 1: " + str(rodzic_1))
            rodzic_2 = populacja_posrednia[x-1]
            print("Rodzic nr 2: " + str(rodzic_2))
            dziecko_1 = []
            dziecko_2 = []
            czy_krzyzowac = random.randint(1,100)       #losowanie czy krzyzowac rodzicow, czy nie
            if (czy_krzyzowac < 78) and (rodzic_1 != rodzic_2):                      #jesli krzyzowanie nastepuje
                print("Nastąpiło krzyżowanie")
                miejsce_krzyzowania = random.randint(1,(len(populacja_posrednia[x])-3))     #wybor miejsca krzyzowania
                print(str(miejsce_krzyzowania))
                print(str(rodzic_1[miejsce_krzyzowania]))
                l = 0
                k = miejsce_krzyzowania
                while k >= 0:                            #dodawanie do dziecka pierwszej połowy z pierwszego rodzica
                    dziecko_1.append(rodzic_1[l])
                    l = l + 1
                    k = k - 1
                k = miejsce_krzyzowania
                while k < (len(rodzic_1)-2):       #dodawanie do dziecka drugiej połowy z drugiego rodzica
                    for i in rodzic_2:
                        if i not in dziecko_1:
                            dziecko_1.append(i)
                            k = k + 1
                l = 0
                k = miejsce_krzyzowania
                while k >= 0:                               #dodawanie do dziecka pierwszej połowy z pierwszego rodzica
                    dziecko_2.append(rodzic_2[l])
                    l = l + 1
                    k = k - 1
                k = miejsce_krzyzowania
                while k < (len(rodzic_1)-2):       #dodawanie do dziecka drugiej połowy z drugiego rodzica
                    for i in rodzic_1:
                        if i not in dziecko_2:
                            dziecko_2.append(i)
                            k = k + 1
                dziecko_1.append(0)
                dziecko_2.append(0)
            else:                                           #jesli krzyzowanie nie nastepuje, wowczas potencjalni rodzice staja sie dziecmi                                 
                print("Krzyżowanie nie nastąpiło")
                dziecko_1 = rodzic_1
                dziecko_2 = rodzic_2
            print("Dziecko nr 1: " + str(dziecko_1))
            print("Dziecko nr 2: " + str(dziecko_2))
            x = x - 1 
        rodzic_1 = populacja_posrednia[0]
        print("Rodzic nr 1: " + str(rodzic_1))
        rodzic_2 = populacja_posrednia[(len(populacja_posrednia)-1)]
        print("Rodzic nr 2: " + str(rodzic_2))
        dziecko_1 = []
        dziecko_2 = []
        czy_krzyzowac = random.randint(1,100)       #losowanie czy krzyzowac rodzicow, czy nie
        if (czy_krzyzowac < 78) and (rodzic_1 != rodzic_2):                      #jesli krzyzowanie nastepuje
            print("Nastąpiło krzyżowanie")
            miejsce_krzyzowania = random.randint(1,(len(populacja_posrednia[x])-3))     #wybor miejsca krzyzowania
            print(str(miejsce_krzyzowania))
            print(str(rodzic_1[miejsce_krzyzowania]))
            l = 0
            k = miejsce_krzyzowania
            while k >= 0:                            #dodawanie do dziecka pierwszej połowy z pierwszego rodzica
                dziecko_1.append(rodzic_1[l])
                l = l + 1
                k = k - 1
            k = miejsce_krzyzowania
            while k < (len(rodzic_1)-2):       #dodawanie do dziecka drugiej połowy z drugiego rodzica
                for i in rodzic_2:
                    if i not in dziecko_1:
                        dziecko_1.append(i)
                        k = k + 1
            l = 0
            k = miejsce_krzyzowania
            while k >= 0:                               #dodawanie do dziecka pierwszej połowy z pierwszego rodzica
                dziecko_2.append(rodzic_2[l])
                l = l + 1
                k = k - 1
            k = miejsce_krzyzowania
            while k < (len(rodzic_1)-2):       #dodawanie do dziecka drugiej połowy z drugiego rodzica
                for i in rodzic_1:
                    if i not in dziecko_2:
                        dziecko_2.append(i)
                        k = k + 1
            dziecko_1.append(0)
            dziecko_2.append(0)
        else:                                           #jesli krzyzowanie nie nastepuje, wowczas potencjalni rodzice staja sie dziecmi                                 
            print("Krzyżowanie nie nastąpiło")
            dziecko_1 = rodzic_1
            dziecko_2 = rodzic_2
        print("Dziecko nr 1: " + str(dziecko_1))
        print("Dziecko nr 2: " + str(dziecko_2))

    def main(self):
        self.zliczanie_wystapien()
        self.pola_buraczane = self.wspolrzedne()
        self.koszt_trasy = self.trasa_buraczana(self.pola_buraczane)
        self.pierwsze_pokolenie = self.tworzenie_pokolenia(self.pola_buraczane,10)
        self.przystosowanie = self.ocena_przystosowania(self.pierwsze_pokolenie)
        self.populacja_posrednia = self.wybor_populacji_posredniej(self.pierwsze_pokolenie, self.przystosowanie)
        self.krzyzowanie(self.populacja_posrednia)