import csv

from numpy import mean, std, var
from pandas import read_csv
from pandas import DataFrame
from pandas import concat
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier, \
    RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split,  KFold
from sklearn.naive_bayes import BernoulliNB, GaussianNB
### load data ###
# ładujemy dane z pliku.tab
# format lini: 56(nr robota) 15(nr pomiaru)     14(siła 1) 15(siła 2) -35(siła 3)    -38(moment 1)   35(moment 2)    1(moement 3) fr_collision(rezultat)
from sklearn.neural_network import MLPClassifier
from sklearn.tree import DecisionTreeClassifier

raw_data_without_headers = []  # robimy pustą listę, do której będziemy sobie wrzucać dane
with open(
        'data/robot_lp1_modIdTp.tab') as data_tab:  # taki zapis w pythonie "jeśli otworzysz plik <jakis plik> i wrzucisz treść do <jakaś_zmienna> to wykonaj poniższe linijki",
    # śmiało możesz mowić, ze znalazłeś taki zapis w dokumentacji i go wykorzystałeś. Taki zapis jest wygodny bo nie trzeba psrawdzać czy udało się otworzyć plik.
    rows = csv.reader(data_tab, dialect='excel-tab')  # opakowujemy dane w specjalny format za pomocą funkcji csv.reader(), bo wygodnie sie przechodzi do kolejnych linijek, delimiter to znak odstępu pomiędzy danymi, '\t' to tabulator
    for i in rows:  # przechodzimy po kolejnych linijkach
        if len(
                i) == 1:  # jeśli nasza linijka ma tylko jedną daną np i=["tresc"] to tylko wypisujemy ze jest to header, pewnie da sie to zrobic bardziej elegancko, no ale tak mi było szybciej bez patrzenia w dokumentacje
            print("header ommiting")
        else:
            i[0] = i[0].split(' ')[
                1]  # [id, time] -> time # jako, ze zamiasta tablulatora są też spacje (to jest jakiś błąd zapisu w pliku pewnie) to naprawiamy: dzielimy string pomiędzy spacjami i bieżemy ten z indexem 1 (czyli drugi od lewej)
            Mfz, res = i[6].split(
                ' ')  # tu od razy wrzucamy do 2 zmienych, bo  i[6].split(' ') to ciąg na przykład "-1 normal", więc da nam 2 ciągi: "-1" oraz "normal"
            i[6] = Mfz  # napistdey "-1 normal" -> "-1"
            i.append(
                res)  # dodajemy kolejną kolumne z rezultatami takimi jak "normal", wtedy z  "-1 1 51 -4 -1 -1" zrobi sie  "-1 1 51 -4 -1 -1 normal"
            raw_data_without_headers.append(i)  # wrzucamy kolejno naprawione linijki do wczesniej utworzonej listy

# w tym miejscu mamy już naprawioną listę robotow w zmiennej o nazwie raw_data_without_headers.

data_frame = DataFrame(
    raw_data_without_headers)  # tworzymy "ramke danych", żeby zobaczyć dane do uczenia (nie musimy tego robić w ten sposób, ale zajrzyjmy do zbioru)
data_frame.columns = ['t', 'Fx', 'Fy', 'Fz', 'MFx', 'MFy', 'MFz',
                      'res']  # dodajemy opisy kolumn według opisu zbioru, żeby wiedzieć co jest czym
del data_frame[
    't']  # kasujemy daną która opisuje "kolejną informacje w czasie". Dla każdego robota jest 15 takich pomiarów, ich iteracja raczej nie jest potrzeba do uczenia.
print(data_frame.head(5))  # zobaczmy pierwsze 5 // pierwszy: 0  -1  -1  63  -3  -1   0  normal
print(data_frame.tail(15))  # zobaczmy ostatnie 15 // ostatni: 1319  -13  2  15  -25  -25   6  fr_collision
# czyli jak widać dane udało sie naprawić i byłby gotowe do uczenia, ale ze my chcemy z nich zrobić dane agregacyjne, które za chwile będziemy generować


iter_15 = 0  # zmienna za pomoca której będziemy sprawdzać każde 15 linijek w liście (co 15 iteracji będziemy cośtam liczyć)

# utorzymy puste listy na dane, każda na końcu powinna mieć wielkość: długość_pliku_bez_nagówka/liczba_zapisów_dla_robota
# czyli dla pliku robot_lp1_modIdTp bez nagłówka: 1320/15= 88. Zatem będziemy mieli 88 danych w kazej liście (czyli 1 robot = 1 linijka w każdym zbiorze).


# listy, które są zerowane gdy osiągną rozmiar 15 (czyli jak mamy 15 robotow to coś znich liczymy i potem zerujemy)
Fx_15_values_arr = []
Fy_15_values_arr = []
Fz_15_values_arr = []
MFx_15_values_arr = []
MFy_15_values_arr = []
MFz_15_values_arr = []

# Listy std (odchylenie standardowe) dla każdgo z robotow
Fx_std_arr = []
Fy_std_arr = []
Fz_std_arr = []
MFx_std_arr = []
MFy_std_arr = []
MFz_std_arr = []

# Listy średnich dla każdgo z robotow
Fx_avg_arr = []
Fy_avg_arr = []
Fz_avg_arr = []
MFx_avg_arr = []
MFy_avg_arr = []
MFz_avg_arr = []

# Listy minimów dla każdgo z robotow
Fx_min_arr = []
Fy_min_arr = []
Fz_min_arr = []
MFx_min_arr = []
MFy_min_arr = []
MFz_min_arr = []

# Listy maximow dla każdgo z robotow
Fx_max_arr = []
Fy_max_arr = []
Fz_max_arr = []
MFx_max_arr = []
MFy_max_arr = []
MFz_max_arr = []

# Rezultaty, tutaj pamiętamy, że dana wynikowa (np"collision" czy tam "normal") jest w zbiorze taka sama dla każdych 15 kolejnych pomiarów
res_arr = []

# Przystąpmy do wygenerowania danych agregacyjnych:
for i, trial in data_frame.iterrows():
    iter_15 = iter_15 + 1

    Fx_15_values_arr.append(int(data_frame.loc[i, "Fx"]))
    Fy_15_values_arr.append(int(data_frame.loc[i, "Fy"]))
    Fz_15_values_arr.append(int(data_frame.loc[i, "Fz"]))
    MFx_15_values_arr.append(int(data_frame.loc[i, "MFx"]))
    MFy_15_values_arr.append(int(data_frame.loc[i, "MFy"]))
    MFz_15_values_arr.append(int(data_frame.loc[i, "MFz"]))

    if iter_15 == 15:  # tutaj ootraliśmy do 15 linijki danych, czyli cały robot zstdowany. Czyli co 15 linijek liczmy stdy itd
        print("Iteracji:", iter_15)
        Fx_avg_arr.append(float(mean(Fx_15_values_arr)))
        Fy_avg_arr.append(float(mean(Fy_15_values_arr)))
        Fz_avg_arr.append(float(mean(Fz_15_values_arr)))
        MFx_avg_arr.append(float(mean(MFx_15_values_arr)))
        MFy_avg_arr.append(float(mean(MFy_15_values_arr)))
        MFz_avg_arr.append(float(mean(MFz_15_values_arr)))

        Fx_min_arr.append(float(min(Fx_15_values_arr)))
        Fy_min_arr.append(float(min(Fy_15_values_arr)))
        Fz_min_arr.append(float(min(Fz_15_values_arr)))
        MFx_min_arr.append(float(min(MFx_15_values_arr)))
        MFy_min_arr.append(float(min(MFy_15_values_arr)))
        MFz_min_arr.append(float(min(MFz_15_values_arr)))

        Fx_max_arr.append(float(max(Fx_15_values_arr)))
        Fy_max_arr.append(float(max(Fy_15_values_arr)))
        Fz_max_arr.append(float(max(Fz_15_values_arr)))
        MFx_max_arr.append(float(max(MFx_15_values_arr)))
        MFy_max_arr.append(float(max(MFy_15_values_arr)))
        MFz_max_arr.append(float(max(MFz_15_values_arr)))

        # Compute the standard deviation.
        Fx_std_arr.append(float(std(Fx_15_values_arr)))
        Fy_std_arr.append(float(std(Fy_15_values_arr)))
        Fz_std_arr.append(float(std(Fz_15_values_arr)))
        MFx_std_arr.append(float(std(MFx_15_values_arr)))
        MFy_std_arr.append(float(std(MFy_15_values_arr)))
        MFz_std_arr.append(float(std(MFz_15_values_arr)))

        iter_15 = 0

        # Skoro mamy juz wszystkie dane zapisane w tablicach to zerujmy dane tymczasowe
        Fx_15_values_arr = []
        Fy_15_values_arr = []
        Fz_15_values_arr = []
        MFx_15_values_arr = []
        MFy_15_values_arr = []
        MFz_15_values_arr = []

        res_arr.append(str(data_frame.loc[
                               i, "res"]))  # jesze zbudujmy sobie listę wyników, Skoro dla każdych 15 warości mamy to samo, to możemy zapisywac rezulttat z 15 liniki

# A poniżej zobczmy czy wszystkie zbiory są równe (każdy ma tyle ile jest robotów)
print("Dlugosci kilku wybranych list:")
print(len(Fx_avg_arr))
print(len(Fx_max_arr))
print(len(Fx_min_arr))
print(len(MFx_avg_arr))
print(len(res_arr))

print("Pierwsza średnia danej Fx, czyli dla robota 1")
print(Fx_avg_arr[0])

data_tab = []  # nowa pusta lista, tutaj na postawie tych powyższych list zbudujemy jedną, taka która powoli na proste wygenerwanie poprawnego "DataFrame"
for i in range(len(
        Fx_avg_arr)):  # len(Fx_avg_arr),czyli długość(Fx_avg_arr) da nam 88,a range(88) sprawi, że for będzie iterować od 0 do 88
    data_tab.append([Fx_avg_arr[i], Fy_avg_arr[i], Fz_avg_arr[i],
                     Fx_max_arr[i], Fy_max_arr[i], Fz_max_arr[i],
                     Fx_min_arr[i], Fy_min_arr[i], Fz_min_arr[i],
                     Fx_std_arr[i], Fy_std_arr[i], Fz_std_arr[i],

                     MFx_avg_arr[i], MFy_avg_arr[i], MFz_avg_arr[i],
                     MFx_max_arr[i], MFy_max_arr[i], MFz_max_arr[i],
                     MFx_min_arr[i], MFy_min_arr[i], MFz_min_arr[i],
                     MFx_std_arr[i], MFy_std_arr[i], MFz_std_arr[i],

                     res_arr[i]])

print("Lista data_Tab")  # zobaczmy jak to wygląda
print(data_tab[0])  # zobaczmy jak to wygląda, iterujemy od zera
print(data_tab[1])
print(data_tab[2])
# print(data_tab[87])  # linika ostatnia

# Dane juz mamy, teraz to opakujmy w specjalne typy żeby móc wrzucić do klasyfikatorów

df = DataFrame(
    data_tab)  # generujemy obiekt (zbior danych) DataFrame, który jest przeznaczony do uczenia maszynowgo w bilbiotekach ktorych uzywamy.
df.columns = ["Fx_avg", "Fy_avg", "Fz_avg",
              "Fx_max", "Fy_max", "Fz_max",
              "Fx_min", "Fy_min", "Fz_min",
              "Fx_std", "Fy_std", "Fz_std",

              "MFx_avg", "MFy_avg", "MFz_avg",
              "MFx_max", "MFy_max", "MFz_max",
              "MFx_min", "MFy_min", "MFz_min",
              "MFx_std", "MFy_std", "MFz_std",

              "res"]  # dodajmy opisy kolumn żeby wiedzieć co jest czym

print("Ramka danych z danymi aggr:")  # zobaczmy jak to wgyląda
print(df.head(5))
print(df.tail(5))

#zapisywanie poniżej pomijam, bo juz zapisalem ten plik i recznie dodałem numeracje robota, nie ma sensu nadpisywać bez potrzeby
#export_csv = df.to_csv("robot_lp_1_features.csv", sep=",", line_terminator='\n')


Y = df["res"]  # zapisyjemy etykiety do uczenia, "normal" "colision" itd do osobnej zmiennej
del df["res"]  # wyrzucamy etykiety z wektorów cech bo to musza być w osobnmy zbiorze
X = df  # zapisujemy wektory cech do X

print("Split data...")
 # dzielimy zbiór na 88 podzbiorów, czyli 1 robot = 1 zbiór
# co nam to da? możemy dzięki temu osobno testować każdego robota, czyli będzie to metoda leave-one-out
# leave-one-out jest to jedna z walidacji kfold (jej specjalny przypadek, gdzie właśnie zbiór ma tylko 1 elemencie).
# wiecej o walidacjach: https://pl.wikipedia.org/wiki/Sprawdzian_krzy%C5%BCowy
# najważniejszy fragment o tej walidacji:  'próba jest dzielona na N (u nas 88) podzbiorów, zawierających po jednym elemencie'
kf = KFold(n_splits=88)

print("Init classifiers...")
#Inicjalizujemy obiektu klasyfikatorow
ada = AdaBoostClassifier(n_estimators=100)
knn_1 = KNeighborsClassifier(n_neighbors=1)
d_tress = DecisionTreeClassifier()
# brn = BernoulliNB()
gauss = GaussianNB()
gbc = GradientBoostingClassifier()
extra_tress = ExtraTreesClassifier(n_estimators = 100)
lr = LogisticRegression(solver="lbfgs", multi_class="auto", max_iter = 5000)
mlp = MLPClassifier( max_iter = 5000)
rand_fores = RandomForestClassifier(n_estimators = 100)
linear = LinearDiscriminantAnalysis(solver='lsqr')

# Tworzymy sobie listy do przechowywania wynikow uczenia.
# Każada lista będzie miała 88 wynikow. Bo każdy robot będzie testsowany na zasadzie:
# 1 robot testujący : 97 robotow uczących
print("Init outpusts...")
output_ada = []
output_knn_1 = []
output_d_tress = []
output_gauss = []
output_gbc = []
output_extra_tress = []
output_lr = []
output_mlp = []
output_rand_fores = []
output_linear = []

# Teraz będziemy robić pętle o 88 powótrzeniach, tak, żeby każdego robota walidować dokładnie raz.
# Tutaj w kazej iteracji od nowa uczony jest klasyfikator wszystkimi robotami poza tym, za pomocą którego będziemy testować.
class_iterator = 1
for train_indexes, test_indexes in kf.split(X): # Zapis "kf.split(x)" zwroci nam jakis obiekt o 88 wartościach.
    # W tych warościach będą indeksy konkretnych obiektów. Podział tutaj zachodzi automatycznie.
    print("\n\n\n################ ada ", class_iterator, '/', kf.n_splits, "################") # wypisujemy którą lecimy pętle oraz ile  ma być w sumie
    print("train idexes:", train_indexes, "\n test indexes:", test_indexes) # podejrzyjmy indeksy których danych będziemy testować.
    print("\n test Y:", Y.loc[test_indexes]) # .loc[test_indexes] zwróci element o danym indeksie. Indexowanie w zbiorze jest od 0, wiec np. ".loc[0]" zwróci nam 1 element
    print("\n test X:", X.loc[test_indexes])

    X_train = X.loc[train_indexes] # za pomocą indeksów które przygotowała nam funkcja, wybieramy sobie dane które nas interesują, tutaj cechy uczące
    Y_train = Y.loc[train_indexes] # tutaj etykiety uczące
    X_test = X.loc[test_indexes]
    Y_test = Y.loc[test_indexes]

    ada.fit(X_train, Y_train) # tutaj trenujemy sobie wszytkie klasfikatory, jeden po drugim, wszystkie mają te same dane
    knn_1.fit(X_train, Y_train)
    d_tress.fit(X_train, Y_train)
    gauss.fit(X_train, Y_train)
    gbc.fit(X_train, Y_train)
    extra_tress.fit(X_train, Y_train)
    lr.fit(X_train, Y_train)
    mlp.fit(X_train, Y_train)
    rand_fores.fit(X_train, Y_train)
    linear.fit(X_train, Y_train)

    output_ada.append( ada.score(X_test, Y_test)*100) # dodajemy wynik z każdej klasyfikacji do listy. Na przyklad:
    # W 1 iteracji będzie testowany robot 1, wiec wynik jego testtu zostanie wrzucone do tej zmiennej jako 1.
    # Mnozymy *100 zeby miec w [%]
    output_knn_1.append( knn_1.score(X_test, Y_test)*100)
    output_d_tress.append(d_tress.score(X_test, Y_test)*100)
    output_gauss.append(gauss.score(X_test, Y_test)*100)
    output_gbc.append(gbc.score(X_test, Y_test)*100)
    output_extra_tress.append(extra_tress.score(X_test, Y_test)*100)
    output_lr.append(lr.score(X_test, Y_test)*100)
    output_mlp.append(mlp.score(X_test, Y_test)*100)
    output_rand_fores.append(rand_fores.score(X_test, Y_test)*100)
    output_linear.append(linear.score(X_test, Y_test)*100)

    class_iterator += 1 # zwiekszamy zmianna, żeby wiedziec którą robimy iteracje.

    # W tym miejscu kodu mamy już coś w listach "output_costam" z wynikami, zobaczymy więc jak wygląda wynik obecnej iteracja.
    # Czyli interesuje nas ostatni wynik, właśnie z obecnej iteracji, który sie dodał do listy pare linijek wyżej.
    # Zapis [-1] daje nam ostatni element z danej listy. -1 to indeks ostatniej wartosci.
    print("################",
          "output_ada=", output_ada[-1], "% ",
          "output_knn_1=", output_knn_1[-1], "% ",
          "output_d_tress=", output_d_tress[-1], "% ",
          "output_gauss=", output_gauss[-1], "% ",
          "output_gbc=", output_gbc[-1], "% ",
          "output_extra_tress=", output_extra_tress[-1], "% ",
          "output_lr=", output_lr[-1], "% ",
          "output_mlp=", output_mlp[-1], "% ",
          "output_rand_fores=", output_rand_fores[-1], "% ",
          "output_linear=", output_linear[-1], "% ",
          "################")

print("\n\n\n################ ############ #########")
print("################ Output data ################")
print("################ ################ ###########")

# Niżej to co nas najbardziej interesuje.
# są tutaj średnie da danych klasyfikatorow. to jest wynik końcowy.
# w każej z list mamy 88 wynikow, bo testowaliśmy każdego z robota osobno, a musimy mieć 1 wynik, dlatego liczmy z nich średnią.
print("output_ada ", mean(output_ada ))
print("output_knn_1 ", mean(output_knn_1 ))
print("output_d_tress ", mean(output_d_tress ))
print("output_gauss ", mean(output_gauss ))
print("output_gbc ", mean(output_gbc ))
print("output_extra_tress ", mean(output_extra_tress ))
print("output_lr ", mean(output_lr ))
print("output_mlp ", mean(output_mlp ))
print("output_rand_fores ", mean( output_rand_fores))
print("output_linear ", mean(output_linear ))