import warnings
warnings.filterwarnings("ignore") # Unterdrücke matplotlib Warnungen für sauberen Output

import pandas as pd

# Erstellen der Spaltennamen für das Dataframe, da der verwendeter Datensatz keine Spaltenbeschreibung besitzt
operational_setting_columns_names=["Operation Setting " + str(i) for i in range(1,4)]
sensor_data_columns_names=["Sensor " + str(i) for i in range(1,22)]
column_names = ["Instance", "Timestep"] + operational_setting_columns_names + sensor_data_columns_names

# Laden des Trainingdatensatzes FD001 mit den zuvor erstellten Spaltennamen
X_train = pd.read_csv("./CMAPSSData/train_FD001.txt", names=column_names, delim_whitespace=True, dtype=float)
print('Anzahl der Instanzen: ' + str(len(X_train["Instance"].unique())))
X_train.head()

X_train.describe(percentiles=[]).transpose()[1:]

import matplotlib.pyplot as plt


def plot_label_distribution(data, title=None):
    """
    Erstellt ein Balkendiagramm, das die Lebensdauer der Instanzen visualisiert
    """
    overall_instance_lengths = []
    number_of_instances = len(data["Instance"].unique())
    for instance_id in range(number_of_instances): # Über alle Instanzen
        instance = data[data["Instance"] == instance_id + 1]
        overall_instance_lengths.append(instance.shape[0])

    fig, ax = plt.subplots()
    ax.hist(x=overall_instance_lengths, bins=number_of_instances);
    ax.set(xlabel='Timesteps', ylabel='Amount', title=title)
    fig.show()

plot_label_distribution(X_train)

instance_id = 1

# Darstellung des zeitlichen Verlaufs der Umgebungsbedingungen/Sensoren einer Instanz
number_of_plots = len(operational_setting_columns_names) + len(sensor_data_columns_names)
plt.figure(figsize=(15, 3*number_of_plots))
history_dataframe_id = X_train[X_train["Instance"] == instance_id]

for i, v in enumerate(operational_setting_columns_names):
    diagram = plt.subplot(number_of_plots, 1, 1 + i)
    diagram.plot(history_dataframe_id.index.values,history_dataframe_id.iloc[:, 2 + i].values)
    diagram.title.set_text(v)
    diagram.set_xlabel("Timestep")
    diagram.set_ylabel("Value")
    plt.tight_layout()

for i, v in enumerate(sensor_data_columns_names):
    diagram = plt.subplot(number_of_plots, 1, 4 + i)
    diagram.plot(history_dataframe_id.index.values,history_dataframe_id.iloc[:, 5 + i].values)
    diagram.title.set_text(v)
    diagram.set_xlabel("Timestep")
    diagram.set_ylabel("Value")
    plt.tight_layout()

plt.show()

import random

# Der Seed ermöglicht Reproduzierbarkeit der Zufallswerte
random.seed(42)

def decide_new_instance_length(upper_bound):
    """
    Entscheidet per Zufall, wie lang die Instanz zukünftig sein wird. 
    Der Wert liegt in [6, 190] um später mit den Testdaten überein zu stimmen.
    """
    if upper_bound > 190:
        upper_bound = 190
    return random.randint(6, upper_bound)


# Mithilfe von decide_new_instance_length(), wird die Zeitreihe abgeschnitten und das RUL Label erstellt
X_train_labeled= X_train.copy(deep=True)
y_train = []
for instance_id in range(len(X_train["Instance"].unique())):
    instance_length_original = X_train[X_train["Instance"] == instance_id + 1].shape[0]
    instance_length_new = decide_new_instance_length(instance_length_original)
    rul = instance_length_original - instance_length_new
    y_train.append(rul)

    to_deleted_lines = X_train_labeled[(X_train_labeled["Instance"] == instance_id + 1) &
                                       ( X_train_labeled["Timestep"] > instance_length_new)].index
    X_train_labeled.drop(to_deleted_lines,inplace=True)

# Die RUL Label werden nun in ein Pandas DataFrame gespeichert
y_train = pd.DataFrame({"RUL":y_train})
y_train

instance_id =1
print("Orig: \t" + str(X_train[X_train["Instance"] == instance_id].shape[0]))
print("Neu: \t" + str(X_train_labeled[X_train_labeled["Instance"] == instance_id].shape[0]) + "   RUL: " + str(y_train['RUL'][instance_id-1]))

plot_label_distribution(X_train, 'Original')

plot_label_distribution(X_train_labeled, 'Labeled')

X_train_labeled.describe(percentiles=[]).transpose()[1:]

''' Erstellen eines neuen Dataframes das den Anforderungen von tsfresh entspricht'''
def change_format(data):
    dataset = list()
    for index, row in data.iterrows():
    #    if index < 5:
        instance_id = pd.to_numeric(row[0])
        timestep = pd.to_numeric(row[1])
        for sensor_id, sensor in enumerate(data.columns[2:]):
            dataset.append([instance_id, timestep, str(sensor_id), pd.to_numeric(row[2 + sensor_id])])
    return pd.DataFrame(dataset, columns=['instance','timestep','sensor','value']).astype({'instance': 'int32','timestep': 'int32', 'sensor': 'str', 'value': 'float32'})

X_train_formated = change_format(X_train_labeled)
X_train_formated

# laden des Testdatensatzes. Dieser enthält bereits Label, die in einer extra Datei gespeichert wurden.
X_test= pd.read_csv("./CMAPSSData/test_FD001.txt", names=column_names, delim_whitespace=True, dtype=float)
X_test_formated = change_format(X_test)

X_test_formated

y_test= pd.read_csv("./CMAPSSData/RUL_FD001.txt", names=["RUL"])
y_test

from tsfresh.transformers import FeatureAugmenter#, RelevantFeatureAugmenter
from tsfresh.feature_extraction import MinimalFCParameters

augmenter = FeatureAugmenter(
    column_id="instance",
    column_kind="sensor",
    column_sort="timestep",
    column_value="value",
    default_fc_parameters=MinimalFCParameters(),
    disable_progressbar=False)

augmenter.set_timeseries_container(X_train_formated)
features = augmenter.transform(pd.DataFrame(index=y_train.index))
features

def plot_predictions(y_true, y_pred, model_name):
    plt.figure(figsize=(12,7))
    plt.plot(y_test)
    plt.plot(y_pred)
    plt.title('Prädiktionen der Test-Instanzen (' + model_name + ')')
    plt.xlabel('Instanz-ID')
    plt.ylabel('Instanz-Länge')
    plt.legend(["True Values", "Predicted Values"])
    plt.show()

def plot_percentage_error(y_true, y_pred, model_name):
    plt.figure(figsize=(12,7))
    percentage_error = (y_true - y_pred) / y_true
    plt.stem(np.arange(len(y_test["RUL"])),percentage_error["RUL"])
    plt.title('Prozentualer Fehler der Test-Instanzen (' + model_name + ')')
    plt.xlabel('Instanz-ID')
    plt.ylabel('Prozentualer Fehler')
    plt.text(50, np.amin(percentage_error)-6,
             'Positive Werte bedeuten, die tatsächliche Laufzeit wurde unterschätzt\nNegative Werte bedeuten, die tatsächliche Laufzeit wurde überschätzt.',
             horizontalalignment='center')
    plt.show()

from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
import math

def percentage_error(y_true, y_pred):
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    sum = 0
    for index in range(0,len(y_true)):
        sum = sum + (y_true[index] - y_pred[index]) / y_true[index]
    return np.mean(sum)

def mean_absolute_percentage_error(y_true, y_pred):
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    return np.mean(np.abs((y_true - y_pred) / y_true)) * 100

def simple_asymmetric_loss(y_true,y_pred):
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    sum = 0
    for index in range(0,len(y_true)):
        if y_pred[index]>= y_true[index]:
            sum = sum + y_true[index] - y_pred[index]
    return np.mean(sum)

def complex_asymmetric_loss(y_true,y_pred):
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)

    sum = 0
    for index in range(0,len(y_true)):
        percentage_error = (y_true[index] - y_pred[index]) / y_true[index]
        if percentage_error <= 0 : # late prediction
            ai = math.exp(- (math.log(0.5) + (percentage_error / 5)))
        else: # early prediction
            ai = math.exp(+ (math.log(0.5) + (percentage_error / 20)))
        sum = sum + (1 - ai)
    return np.mean(sum)

import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin

class InvalidNumberReplacementTransformer(BaseEstimator, TransformerMixin):
    def fit(self, X, y):
        return self

    def transform(self, X):
        extracted_features = np.float32(X.to_numpy())
        features = np.nan_to_num(extracted_features)
        return features

from sklearn.pipeline import make_pipeline

def train_and_test_model(regressor, name):
    pipeline = make_pipeline(
      augmenter,
      InvalidNumberReplacementTransformer(),
      regressor()
     )
    pipeline.set_params(featureaugmenter__timeseries_container=X_train_formated)
    pipeline.fit(pd.DataFrame(index=y_train.index), y_train["RUL"])

    pipeline.set_params(featureaugmenter__timeseries_container=X_test_formated)
    predictions = pipeline.predict(pd.DataFrame(index=y_train.index))
    predictions = predictions.reshape(100,1)

    plot_predictions(y_test, predictions, name)
    plot_percentage_error(y_test, predictions, name)

    print("MAE: \t%.2f" % mean_absolute_error(y_test, predictions) )
    print("MSE:\t%.2f" % mean_squared_error(y_test, predictions) )
    print("PE:\t%.2f" % percentage_error(y_test, predictions) )
    print("MAPE:\t%.2f" % mean_absolute_percentage_error(y_test, predictions) )
    print("SAL:\t%.2f" % simple_asymmetric_loss(y_test, predictions) )
    print("CAL:\t%.2f" % complex_asymmetric_loss(y_test, predictions) )

from sklearn.linear_model import LinearRegression

train_and_test_model(LinearRegression, 'LR')

from sklearn.neighbors import KNeighborsRegressor

train_and_test_model(KNeighborsRegressor, 'KNN')

from sklearn.svm import SVR

train_and_test_model(SVR, 'SVR')

from sklearn.tree import DecisionTreeRegressor

train_and_test_model(DecisionTreeRegressor, 'DT')