import os

import numpy as np
import pandas as pd


class StandardScaler:
    """
    This scaler code is borrowed from https://github.com/liuxu77/LargeST/blob/main/data/generate_data_for_training.py
    """
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std

    def transform(self, data):
        return (data - self.mean) / self.std

    def inverse_transform(self, data):
        return (data * self.std) + self.mean


def generate_data_and_idx(df: pd.DataFrame, x_offsets, y_offsets, add_time_of_day, add_day_of_week):
    num_samples, num_nodes = df.shape
    data = np.expand_dims(df.values, axis=-1)

    feature_list = [data]
    if add_time_of_day:
        time_ind = (df.index.values - df.index.values.astype('datetime64[D]')) / np.timedelta64(1, 'D')
        time_of_day = np.tile(time_ind, [1, num_nodes, 1]).transpose((2, 1, 0))
        feature_list.append(time_of_day)
    if add_day_of_week:
        dow = df.index.dayofweek
        dow_tiled = np.tile(dow, [1, num_nodes, 1]).transpose((2, 1, 0))
        day_of_week = dow_tiled / 7
        feature_list.append(day_of_week)

    data = np.concatenate(feature_list, axis=-1)

    min_t = abs(min(x_offsets))
    max_t = abs(num_samples - abs(max(y_offsets)))  # Exclusive
    print('idx min & max:', min_t, max_t)
    idx = np.arange(min_t, max_t, 1)
    return data, idx


def new_and_dying_sensors(df: pd.DataFrame):
    df = df.sort_index()

    isna   = df.isna()
    valid  = ~isna

    has_before = valid.cumsum(axis=0).gt(0)
    has_after  = valid[::-1].cumsum(axis=0)[::-1].gt(0)

    leading_nan = isna & ~has_before
    trailing_nan = isna & ~has_after
    internal_nan = isna & has_before & has_after

    newborn_cols = leading_nan.any(axis=0)
    dying_cols   = trailing_nan.any(axis=0)
    invalid_cols = internal_nan.any(axis=0) | isna.all(axis=0)

    newborn_sensors = df.columns[newborn_cols].tolist()
    dying_sensors   = df.columns[dying_cols].tolist()
    invalid_sensors = df.columns[invalid_cols].tolist()

    return newborn_sensors, dying_sensors, invalid_sensors


def generate_largest_data(df: pd.DataFrame, output_folder: str, sensors: list = None, seq_len_x: int = 12, seq_len_y: int = 12,
                          splits: dict[str, float] = None):

    if splits is None:
        splits = {'train': 0.6, 'val': 0.2}

    x_offsets = np.sort(np.arange(-(seq_len_x - 1), 1, 1))
    y_offsets = np.sort(np.arange(1, seq_len_y + 1, 1))

    if sensors is not None:
        df = df[df['sensor_id'].isin(sensors)]

    df['traffic_intensity'] = df['traffic_intensity'] / 4   # data is a 15-min interval but represented as per hour
    df_pivot = df.pivot(index='entry_date', columns='sensor_id', values='traffic_intensity')
    print('original data shape:', df_pivot.shape)

    newborn, dying, invalid = new_and_dying_sensors(df_pivot)
    if len(invalid) > 0:
        raise Exception("invalid sensors (with nans inside) found")

    to_drop = set(newborn) | set(dying)
    df_clean = df_pivot.drop(columns=to_drop)
    data, idx = generate_data_and_idx(df_clean, x_offsets, y_offsets, add_time_of_day=True, add_day_of_week=True)
    print('final data shape:', data.shape, 'idx shape:', idx.shape)

    # generate splits
    num_samples = len(idx)
    num_train = int(num_samples * splits['train'])
    num_val = int(num_samples * splits['val'])
    num_test = num_samples - num_train - num_val
    idx_train = idx[:num_train]
    idx_val = idx[num_train:num_train + num_val]
    idx_test = idx[num_train + num_val:]

    # normalize data
    x_train = data[:idx_val[0] - seq_len_x, :, 0]
    scaler = StandardScaler(mean=x_train.mean(), std=x_train.std())
    data[..., 0] = scaler.transform(data[..., 0])

    # save data
    os.makedirs(output_folder, exist_ok=True)
    np.savez_compressed(os.path.join(output_folder, 'his.npz'), data=data, mean=scaler.mean, std=scaler.std)
    np.save(os.path.join(output_folder, 'idx_train.npy'), idx_train)
    np.save(os.path.join(output_folder, 'idx_val.npy'), idx_val)
    np.save(os.path.join(output_folder, 'idx_test.npy'), idx_test)