import logging.config
import os

import numpy as np
import pandas as pd
from scipy.integrate import simps

logging.config.fileConfig('./src/logging.conf', disable_existing_loggers=False)
logger = logging.getLogger(__name__)


def return_first_or_nan(l):
    """
    Returns the first value of a list if empty or returns nan. Used for getting dune/toe and crest values.
    :param l:
    :return:
    """
    if len(l) == 0:
        return np.nan
    else:
        return l[0]


def volume_change(df_profiles, df_profile_features, zone):
    """
    Calculates how much the volume change there is between prestrom and post storm profiles.
    :param df_profiles:
    :param df_profile_features:
    :param zone: Either 'swash' or 'dune_face'
    :return:
    """
    logger.info('Calculating change in beach volume in {} zone'.format(zone))

    df_vol_changes = pd.DataFrame(index=df_profile_features.index)
    df_profiles = df_profiles.sort_index()
    sites = df_profiles.groupby(level=['site_id'])

    for site_id, df_site in sites:
        logger.debug('Calculating change in beach volume at {} in {} zone'.format(site_id, zone))
        prestorm_dune_toe_x = df_profile_features.loc[df_profile_features.index == site_id].dune_toe_x.tolist()
        prestorm_dune_crest_x = df_profile_features.loc[df_profile_features.index == site_id].dune_crest_x.tolist()

        # We may not have a dune toe or crest defined, or there may be multiple defined.
        prestorm_dune_crest_x = return_first_or_nan(prestorm_dune_crest_x)
        prestorm_dune_toe_x = return_first_or_nan(prestorm_dune_toe_x)

        # If no dune to has been defined, Dlow = Dhigh. Refer to Sallenger (2000).
        if np.isnan(prestorm_dune_toe_x):
            prestorm_dune_toe_x = prestorm_dune_crest_x

        # Find last x coordinate where we have both prestorm and poststorm measurements. If we don't do this,
        # the prestorm and poststorm values are going to be calculated over different lengths.
        df_zone = df_site.dropna(subset=['z'])
        x_last_obs = min([max(df_zone.query("profile_type == '{}'".format(profile_type)).index.get_level_values('x'))
                          for profile_type in ['prestorm', 'poststorm']])

        # Where we want to measure pre and post storm volume is dependant on the zone selected
        if zone == 'swash':
            x_min = prestorm_dune_toe_x
            x_max = x_last_obs
        elif zone == 'dune_face':
            x_min = prestorm_dune_crest_x
            x_max = prestorm_dune_toe_x
        else:
            logger.warning('Zone argument not properly specified. Please check')
            x_min = None
            x_max = None

        # Now, compute the volume of sand between the x-coordinates prestorm_dune_toe_x and x_swash_last for both prestorm
        # and post storm profiles.
        prestorm_vol = beach_volume(x=df_zone.query("profile_type=='prestorm'").index.get_level_values('x'),
                                    z=df_zone.query("profile_type=='prestorm'").z,
                                    x_min=x_min,
                                    x_max=x_max)
        poststorm_vol = beach_volume(x=df_zone.query("profile_type=='poststorm'").index.get_level_values('x'),
                                     z=df_zone.query("profile_type=='poststorm'").z,
                                     x_min=x_min,
                                     x_max=x_max)

        df_vol_changes.loc[site_id, 'prestorm_{}_vol'.format(zone)] = prestorm_vol
        df_vol_changes.loc[site_id, 'poststorm_{}_vol'.format(zone)] = poststorm_vol
        df_vol_changes.loc[site_id, '{}_vol_change'.format(zone)] = prestorm_vol - poststorm_vol

    return df_vol_changes


def beach_volume(x, z, x_min=np.NINF, x_max=np.inf):
    """
    Returns the beach volume of a profile, calculated with Simpsons rule
    :param x: x-coordinates of beach profile
    :param z: z-coordinates of beach profile
    :param x_min: Minimum x-coordinate to consider when calculating volume
    :param x_max: Maximum x-coordinate to consider when calculating volume
    :return:
    """
    profile_mask = [True if x_min < x_coord < x_max else False for x_coord in x]
    x_masked = np.array(x)[profile_mask]
    z_masked = np.array(z)[profile_mask]

    if len(x_masked) == 0 or len(z_masked) == 0:
        return np.nan
    else:
        return simps(z_masked, x_masked)


def storm_regime(df_observed_impacts):
    """
    Returns the dataframe with an additional column of storm impacts based on the Storm Impact Scale. Refer to
    Sallenger (2000) for details.
    :param df_observed_impacts:
    :return:
    """
    logger.info('Getting observed storm regimes')
    df_observed_impacts.loc[df_observed_impacts.swash_vol_change < 3, 'storm_regime'] = 'swash'
    df_observed_impacts.loc[df_observed_impacts.dune_face_vol_change > 3, 'storm_regime'] = 'collision'
    return df_observed_impacts


if __name__ == '__main__':
    logger.info('Importing existing data')
    data_folder = './data/interim'
    df_profiles = pd.read_csv(os.path.join(data_folder, 'profiles.csv'), index_col=[0, 1, 2])
    df_profile_features = pd.read_csv(os.path.join(data_folder, 'profile_features.csv'), index_col=[0])

    logger.info('Creating new dataframe for observed impacts')
    df_observed_impacts = pd.DataFrame(index=df_profile_features.index)

    logger.info('Getting pre/post storm volumes')
    df_swash_vol_changes = volume_change(df_profiles, df_profile_features, zone='swash')
    df_dune_face_vol_changes = volume_change(df_profiles, df_profile_features, zone='dune_face')
    df_observed_impacts = df_observed_impacts.join([df_swash_vol_changes, df_dune_face_vol_changes])

    # Classify regime based on volume changes
    df_observed_impacts = storm_regime(df_observed_impacts)

    # Save dataframe to csv
    df_observed_impacts.to_csv(os.path.join(data_folder, 'impacts_observed.csv'))