import csv

from numpy import mean, std, var
from pandas import read_csv
from pandas import DataFrame
from pandas import concat
from sklearn.ensemble import AdaBoostClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split, RepeatedKFold, KFold

### 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.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',
                      delimiter='\t')  # 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).


# 15 wartsci
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 dla każdgo z robotow
Fx_std_arr = []
Fy_std_arr = []
Fz_std_arr = []
MFx_std_arr = []
MFy_std_arr = []
MFz_std_arr = []

# vary std dla każdgo z robotow
Fx_var_arr = []
Fy_var_arr = []
Fz_var_arr = []
MFx_var_arr = []
MFy_var_arr = []
MFz_var_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)))

        # Compute the var.
        Fx_var_arr.append(float(var(Fx_15_values_arr,ddof=1)))
        Fy_var_arr.append(float(var(Fy_15_values_arr,ddof=1)))
        Fz_var_arr.append(float(var(Fz_15_values_arr,ddof=1)))
        MFx_var_arr.append(float(var(MFx_15_values_arr,ddof=1)))
        MFy_var_arr.append(float(var(MFy_15_values_arr,ddof=1)))
        MFz_var_arr.append(float(var(MFz_15_values_arr,ddof=1)))

        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 mieć 88 wg naszych obliczeń z linijki 40, 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],
                     Fx_var_arr[i], Fy_var_arr[i], Fz_var_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],
                     MFx_var_arr[i], MFy_var_arr[i], MFz_var_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",
              "Fx_var", "Fy_var", "Fz_var",

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

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

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...")
kf = KFold(n_splits=10)

print("Init classifiers...")
ada = AdaBoostClassifier(n_estimators=100)
knn_1 = KNeighborsClassifier(n_neighbors=1)
knn_10 = KNeighborsClassifier(n_neighbors=10)
d_tress = DecisionTreeClassifier()

print("Init outpusts...")
output_ada = []
output_knn_1 = []
output_knn_10 = []
output_d_tress = []

class_iterator = 1
for train_indexes, test_indexes in kf.split(X):
    print("\n\n\n################ ada ", class_iterator, '/', kf.n_splits, "################")
    print("train idexes:", train_indexes, "\n test indexes:", test_indexes)
    print("\n test Y:", Y.loc[test_indexes])
    print("\n test X:", X.loc[test_indexes])

    X_train = X.loc[train_indexes]
    Y_train = Y.loc[train_indexes]
    X_test = X.loc[test_indexes]
    Y_test = Y.loc[test_indexes]

    ada.fit(X_train, Y_train)
    knn_1.fit(X_train, Y_train)
    knn_10.fit(X_train, Y_train)
    d_tress.fit(X_train, Y_train)

    score_ada = ada.score(X_test, Y_test)
    score_knn_1 = knn_1.score(X_test, Y_test)
    score_knn_10 = knn_10.score(X_test, Y_test)
    score_d_tress = d_tress.score(X_test, Y_test)

    output_ada.append(score_ada * 100)
    output_knn_1.append(score_knn_1 * 100)
    output_knn_10.append(score_knn_10 * 100)
    output_d_tress.append(score_d_tress * 100)

    class_iterator += 1

    print("################",
          "ada=", score_ada * 100, "% ",
          "knn_1=", score_knn_1 * 100, "% ",
          "knn_10=", score_knn_10 * 100, "% ",
          "d_tress=", score_d_tress * 100, "% ",
          "################")

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

print('Ada res:', output_ada)
print('Final ada', mean(output_ada))

print('Knn-1 res:', output_knn_1)
print('Final knn-1', mean(output_knn_1))

print('Knn-10 res:', output_knn_10)
print('Final knn-10', mean(output_knn_10))

print('d_tress res:', output_d_tress)
print('Final d_tress', mean(output_d_tress))