import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras import models
from tensorflow.keras import optimizers
from tensorflow.keras.models import Sequential
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.layers import Dense, Dropout, CuDNNLSTM, BatchNormalization
from tensorflow.keras.callbacks import TensorBoard, ModelCheckpoint
from sklearn.metrics import mean_squared_error
from sklearn import preprocessing
import matplotlib.pyplot as plt
from collections import deque
import numpy as np
import pandas as pd
import random
import time
from pandas import DataFrame, Series

'''
# Funckja normalizująca
def norm(x):
  return (x - train_stats['mean']) / train_stats['std']
'''

# Funckja normalizująca
def norm(x):
  return (x - train_stats['min']) / (train_stats['max'] - train_stats['min'])

# Funkcja enkodująca one-hot
def one_hot(dataset, qantity):
    data = dataset.values.ravel().astype(int)
    onehot_encoded = []

    for value in data:
        vector = [0 for _ in range(qantity)]
        vector[value-1] = 1
        onehot_encoded.append(vector)
    return onehot_encoded

# Funkcja scalająca macierze
def concentrate(temp, week_nr, work_pos, target_power):
    temp = np.asarray(temp)
    week_nr = np.asarray(week_nr)
    work_pos = np.asarray(work_pos)
    x = np.concatenate((temp, work_pos, week_nr, target_power), axis=1)

    return x

# Funckja normalizująca i zestawiająca sekwencje
def normalize_df(df):
    #df = df.drop('future_power', 1)

    for column in df.columns:
        if column == 'temp_C':
            normalized_temp = norm(df[['temp_C']]).values

    # Enkodowanie one-hot
    # Numer tygodnia roku
    encoded_week_nr = one_hot(df[['week_nr']], 52)

    # Stan pracy
    encoded_work_pos = one_hot(df[['work_pos']], 4)

    # Przygotowanie macierzy zbiorów uczących i treningowych
    data = concentrate(normalized_temp, encoded_week_nr, encoded_work_pos, df[['p_3fh']].values)

    sequential_data = []
    prev_days = deque(maxlen = SEQUENCE_LENGTH)

    for x in data:
        prev_days.append([x for x in x[0:-1]])
        if len(prev_days) == SEQUENCE_LENGTH:
            sequential_data.append([np.array(prev_days), x[-1]])

    random.shuffle(sequential_data)

# Zbilansowanie danych
    random.shuffle(sequential_data)

    X =[]
    y = []

    for seq, target in sequential_data:  # going over our new sequential data
        X.append(seq)  # X is the sequences
        y.append(target)  # y is the targets/labels (buys vs sell/notbuy)

    return np.array(X), y

# Zmienne pomocnicze
SEQUENCE_LENGTH = 8  # Długość sekwencji
EPOCHS = 1
BATCH_SIZE = 16
NAME = f"{SEQUENCE_LENGTH}-sekwencja-{int(time.time())}"

#Przygotowanie zbioru danych
file_to_open = "db_csv_f.csv"
csv_dataset = pd.read_csv(file_to_open, sep = ',', header = 0, index_col  = False, skipinitialspace = True )
main_df =  DataFrame(csv_dataset)

main_df = main_df[['unix_time', 'week_nr', 'work_pos','temp_C', 'p_3fh']].dropna()
main_df.set_index('unix_time', inplace = True)

train_stats = main_df.copy()
train_stats.pop('p_3fh')
train_stats.pop('week_nr')
train_stats.pop('work_pos')
train_stats = train_stats.describe()
train_stats = train_stats.transpose()

# Dodanie informacji o zmianie mocy
#main_df['future_power'] = main_df['p_3fh'].shift(-PERIOD_TO_PREDICT)
#main_df['target'] = list(map(classify, main_df['p_3fh'], main_df['future_power']))
main_df.dropna(inplace=True)

# Podział na zbór uczący i treningowy
unix_times = sorted(main_df.index.values)
last_pct_unix_time = sorted(main_df.index.values)[-int(0.15*len(unix_times))]

validation_main_df = main_df[(main_df.index >= last_pct_unix_time)]
main_df = main_df[(main_df.index < last_pct_unix_time)]

train_x, train_y = normalize_df(main_df)
validation_x, validation_y = normalize_df(validation_main_df)
print(train_x.shape[1:])

# Budowa modelu
def build_model():
    model = Sequential()
    model.add(CuDNNLSTM(32, input_shape=(train_x.shape[1:]), return_sequences=True))
    model.add(Dropout(0.2))
    model.add(BatchNormalization())

    model.add(CuDNNLSTM(16))
    model.add(Dropout(0.2))
    model.add(BatchNormalization())

    model.add(Dense(8, activation='relu'))
    model.add(Dropout(0.1))

    model.add(Dense(4, activation='relu'))
    model.add(Dropout(0.1))

    model.add(Dense(1, activation='linear'))

    opt = tf.keras.optimizers.Adam(lr=0.001, decay=1e-6)
    model.compile(optimizer = opt, loss = 'mae', metrics=['mae','mse'])
    return model

# Algorytm k-składowej walidacji krzyżowej
folds = 4
num_val_samples = len(train_x) // folds
val_mean_abs_error = []

for x in range(folds):
    print("Processing folds #", x + 1)
    val_data = train_x[x * num_val_samples: (x + 1) * num_val_samples]
    val_target = train_y[x * num_val_samples: (x + 1) * num_val_samples]

    partial_train_data = np.concatenate(
                         [train_x[:x * num_val_samples],
                         train_x[(x + 1) * num_val_samples:]],
                         axis = 0)
    partial_train_target = np.concatenate(
                         [train_y[:x * num_val_samples],
                         train_y[(x + 1) * num_val_samples:]],
                         axis = 0)
    model = build_model()
    model.summary()
    history = model.fit(train_x, train_y,
                        batch_size = BATCH_SIZE,
                        epochs = EPOCHS,
                        verbose = 1,
                        validation_data=(validation_x, validation_y),
                        callbacks=[])
    val_mean_abs_error.append(history.history['val_mean_absolute_error'])

model.save('model')

# Wygładzony wykres walidacji
def smooth_plot(points, factor = 0.9):
    if (isinstance(points, list) == False):
        points.ravel()
    smooth_points = []
    for x in range(10, len(points)):
        if smooth_points:
            previous = smooth_points[-1]
            smooth_points.append(previous * factor + points[x] * (1- factor))
        else:
            smooth_points.append(points[x])
    return smooth_points

# Wykres od 10 epoki
def plot_from_epoch(points, epoch = 10):
    if (isinstance(points, list) == False):
        points.ravel()
    points_from_epoch = []
    for x in range(epoch, len(points)):
            points_from_epoch.append(points[x])
    return points_from_epoch

# Średni błąd w zależności od ilości złożeń w algorytmie k-składowej walidacji
def plot_error(mean_abs, folds):
    fig, axs = plt.subplots(3, 1)
    line_labels = []

    average_mean_abs = [
                    np.mean([x[i] for x in mean_abs]) for i in range(EPOCHS)]
    smooth_average_mean_abs = smooth_plot(average_mean_abs)

    for i in range(len(mean_abs)):
        axs[0].plot(range(1,EPOCHS + 1), mean_abs[i])
        axs[1].plot(range(10,EPOCHS), plot_from_epoch(mean_abs[i]))
        axs[2].plot(range(10, EPOCHS), smooth_plot(mean_abs[i]))
        line_labels.append(f'Fold-{i}')
    axs[0].plot(range(1,EPOCHS + 1), average_mean_abs, marker = ".", label = 'Wartość średnia')
    axs[1].plot(range(10,EPOCHS), plot_from_epoch(average_mean_abs), marker = ".")
    axs[2].plot(range(10,EPOCHS), smooth_average_mean_abs, marker = ".")
    line_labels.append('Wartość średnia')

    fig.text(0.05, 0.5, 'Wartość błędu bezwzględnego', horizontalalignment='center',
            rotation='vertical',verticalalignment='center',  fontsize = 16)
    fig.text(0.5, 0.06, 'Epoka', fontsize = 16)

    axs[0].set_title('Wykres błędu bezwzględnego', fontsize = 16)
    axs[2].set_title('Wykres wygładzony', fontsize = 16)

    # Create the legend
    fig.legend([axs[0], axs[1]],     # The line objects
               labels=line_labels,   # The labels for each line
               loc='best',           # Position of legend
               borderaxespad=0.1,    # Small spacing around legend box
               title='Legenda')      # Title for the legend

    plt.subplots_adjust(hspace = 0.5)
    plt.show()

val_mean_abs_error = np.asarray(val_mean_abs_error)
plot_error(val_mean_abs_error, folds)

# Konfiguracja TensorBoard i ModelCheckpoint
#tensorboard = TensorBoard(log_dir = f'logs/{NAME}')

#filepath = "RNN_-{EPOCHS:02d}-{val_acc:.3f}"
#checkpoint = ModelCheckpoint("models/{}.model".format(filepath, monitor = 'val_acc', verbose = 1, save_best_only = True, mode = 'max'))

# Wykres predykcji
# Prognoza dla finalnej wersji modelu
model = models.load_model('model')
predictions = model.predict(validation_x).flatten()
plt.plot(validation_y, label='Dane testowe')
plt.plot(predictions, label='Predykcja')
plt.title("Wykres")
plt.legend()
plt.show()