"""
Authors: Vitor Eller (@Vfermat) and Liam Dunphy (@ldunphy98)
"""

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import datetime as dt

from scipy.interpolate import interp1d
from math import log, exp
from mpl_toolkits.mplot3d import Axes3D
from datetime import datetime
from .Holidays.AnbimaHolidays import AnbimaHolidays


class SwapCurve(object):

    interpolate_display = {
            'linear': 'r-',
            'cubic': 'g--',
            'quadratic': 'b:',
            'nearest': 'y-.',
            'flatforward': 'r-'
            }

    conventions = {
            'business_days': 252,
            'calendar_days': 360
            }

    calendars = {
        'br_anbima': AnbimaHolidays().get_holidays()
    }

    def __init__(self, rates, convention='business_days',
                 calendar='br_anbima'):
        """[summary]

        Arguments
        ----------
            rates : pandas df
                Rates should be a pandas dataframe where the columns are the
                maturity of the title and the rows should be `datetime` type.
                For more information, check the `ReadMe.md` document.

        Keyword Arguments
        ----------
            convention : str (default: {'business_days'})
                Your calendar convention. For options, check the `ReadMe.md` document.
            calendar : str (default: {'br_anbima'})
                Which holidays should the code use.
                For now, only Br - Anbima is implemented.
        """

        self.convention = convention
        self.convention_year = self.conventions[convention]
        self.rates = rates
        self.holidays = self.calendars[calendar]

    def plot_3d(self, plot_type='surface'):
        """Function to plot the surface of the swap curve.

        Keyword Arguments
        ----------
            plot_type : str (default: {'surface'})
                Which type of plot you want to see. You can choose either `surface` or `wireframe`
        """

        x = self.rates.index
        y = self.rates.columns
        # Creating 2D Array with swap rates
        z = []
        for column in y:
            base_curve = self.rates[column]
            curve = self._get_3d_curve(base_curve, x)
            z.append(curve)
        z = np.array(z)
        # Converting x (maturities terms) to days to maturities
        x = [self._days_in_term(term, self.convention) for term in x]
        # Converting y (dates) to number. Otherwise, plot will not work
        inty = [0]
        for date in y:
            if date != y[0]:
                diff = date - y[0]
                inty.append(diff.days)
        y = inty
        # Creating 2D arrays for x and y
        x, y = np.meshgrid(x, y)

        # Plotting Graphic
        fig = plt.figure()
        ax = fig.add_subplot(111, projection='3d')
        if plot_type == 'surface':
            ax.plot_surface(y, x, z)
        elif plot_type == 'wireframe':
            ax.plot_wireframe(y, x, z)
        else:
            raise ValueError('Invalid Plot Type. Please read documentation for valid plots.')
        ax.set_xlabel('Date')
        ax.set_ylabel('Days to Maturity')
        ax.set_zlabel('Swap Rate (%)')
        plt.show()

    def get_rate(self, base_curves, desired_terms,
                 interpolate_methods=['cubic']):
        """
        Function that get the Swap Rate for a specific term. It calculates
        based on the interpolation of the base curve.

        Parameters
        ----------
        base_curves : array_like
            Curves that will be used on the interpolation, to discover the
            rate for a specific term.
        desired_terms : array_like
            Terms you want to find the swap rate. Should be passed as days.
            (future development will allow you to input a desired date.)
        interpolate_methods : array_like, optional
            Methods used to interpolate the curve. Only works if `interpolate`
            is True. Default is 'cubic'.

            Accepted methods are: `linear`, `cubic`, `quadratic`,
            `nearest` and `flatforward`.

        Returns
        ----------
        info : dict
            A dictionary containing the rates for the asked terms. If more than
            one base curve is used, there will be one rate for each term, for
            each base curve.

            The dictionary has two `levels`, being as follow:
                info = {'interpolate_method': {'term': 'rate'}}
        """

        # Checking inputs
        if type(base_curves) not in (list, np.ndarray):
            raise TypeError("Argument 'base_curves' should be array_like.")
        if type(desired_terms) not in (list, np.ndarray):
            raise TypeError("Argument 'desired_terms' should be array_like.")
        if type(interpolate_methods) not in (list, np.ndarray):
            raise TypeError("Argument 'interpolate_methods' should be array_like.")

        # Checking if base_curves are valid:
        curves = []
        for date in base_curves:
            try:
                curve = self.rates[date]
                curve = curve.dropna()
            except IndexError as e:
                print('{}. {} is an invalid date, since there is not a curve for this date. It will not be used.'.format(e, date))
            else:
                curves.append(curve)

        # Checking if there are curves to be plotted
        if len(curves) == 0:
            raise ValueError('There are no Base Curves to be used.')

        # Creating dataFrame with information asked
        info = {}
        for method in interpolate_methods:
            info[method] = pd.DataFrame()
        for curve in curves:
            for method in interpolate_methods:
                terms = curve.index
                dterms = [self._days_in_term(t, self.convention) for
                          t in terms]
                n_desired_terms = desired_terms.copy()
                # Checks if desired_terms are valid
                for term in desired_terms:
                    if term < min(dterms) or term > max(dterms):
                        print('{} is an invalid term.'.format(term))
                        n_desired_terms.remove(term)
                irates = self._interpolate_rates(dterms, list(curve),
                                                 n_desired_terms, method,
                                                 self.convention_year)
                rates = {k: v for k, v in zip(n_desired_terms,
                                              irates)}
                for k in rates.keys():
                    info[method].at[curve.name, k] = rates[k]

        return info

    def get_historic_forward(self, maturity1, maturity2, plot=False,
                             interpolate_method='cubic'):
        """Function that returns the historic of the forward rate between two maturities. 
        Maturities have to be between max and min maturities for that title.

        Arguments
        ----------
            maturity1 : int
                Lower Maturity.
            maturity2 : int
                Higher Maturity

        Keyword Arguments
        ----------
            plot : bool (default: {False})
                Let the user decide if he wants to plot the historic or not.
            interpolate_method {str} (default: {'cubic'})
                Let the user decide which Interpolation Method will be used.
        """

        historic = pd.Series()
        for i in range(len(self.rates.columns)):
            date = self.rates.columns[i]
            rate1 = self.get_rate([date], [maturity1],
                                  [interpolate_method])[interpolate_method][maturity1][date]
            rate2 = self.get_rate([date], [maturity2],
                                  [interpolate_method])[interpolate_method][maturity2][date]
            forward = self._forward_rate(date, maturity1, maturity2,
                                         rate1, rate2, self.convention_year)
            historic.at[date] = forward
        if plot:
            historic.plot()
            plt.show()

        return historic

    def get_historic_rates(self, maturity, plot=False):
        terms = self.rates.index
        day_terms = [self._days_in_term(term, self.convention) for term in terms]
        if maturity in day_terms:
            historic_rates_curve = self.rates.loc[maturity]
            if plot:
                historic_rates_curve.plot()
                plt.show()
            return historic_rates_curve
        else:
            dates = list(self.rates.columns)
            response = self.get_rate(dates, [maturity])
            table_term = response["cubic"][maturity]
            if plot:
                table_term.plot()
                plt.show()
            return table_term

    def plot_day_curve(self, dates, interpolate=False,
                       interpolate_methods=['cubic'], scatter=False):
        """
        Function to plot the SwapCurve for a specific set of days.

        Parameters
        ----------
        dates : array_like
            Dates to be plotted.

            Obs: A great improvement would be to allow the user to pick a date
            that we do not have the curve, and plot it. So basically construct
            the curve for a specific day, based on near ones.
        interpolate : boolean, optional
            If you want to create and interpolation of the curve or not.
            If interpolate is False, curve plotted will be similar to a
            `linear` interpolation. Default is False.
        interpolate_methods : array_like, optional
            Methods used to interpolate the curve. Only works if `interpolate`
            is True. Default is 'cubic'.

            Accepted methods are: `linear`, `cubic`, `quadratic`,
            and `nearest`.
        scatter : boolean, optional
            Only works if `interpolate` is False. If `scatter` is True, then
            instead of plotting something close to a `linear` interpolation,
            the graphic will look like a scatter plot.

        See Also
        ----------
        plot_term_historic : plot the historic rate for the desired term
        """
        # Checking Inputs
        if type(dates) not in (list, np.ndarray):
            raise TypeError("Argument 'dates' should be array_like.")
        if type(interpolate_methods) not in (list, np.ndarray) and interpolate_methods is not None:
            raise TypeError("If you desire to interpolate, argument 'interpolate_method' should be a list")

        # Gathering curves information.
        curves = []
        for date in dates:
            try:
                curve = self.rates[date]
                curve = curve.dropna()
            except IndexError as e:
                print('{}. {} is an invalid date. It will not be used.'.format(e, date))
            else:
                curves.append(curve)

        # Check if there are curves to be plotted (or all dates where invalid)
        if len(curves) == 0:
            raise ValueError('There are no dates to be plotted.')

        plotted = False
        # Start plotting
        for curve in curves:
            date = curve.name
            date = date.strftime('%d/%b/%Y')
            if interpolate:
                if len(interpolate_methods) == 1:
                    terms = curve.index
                    dterms = [self._days_in_term(t, self.convention) for
                              t in terms]
                    iterms = np.arange(min(dterms), max(dterms), 1)
                    irates = self._interpolate_rates(dterms, list(curve),
                                                     iterms,
                                                     interpolate_methods[0],
                                                     self.convention_year)
                    plt.plot(iterms, irates, label=date)
                    plt.legend()
                    plt.xlabel('Days to Maturity')
                    plt.ylabel('Swap Rate (%)')
                else:
                    """
                    If there are more than one interpolation method to be used
                    ther will be created an specific graphic for each desired
                    date (if there are more than one). This happens to
                    ensure visualization of the data.
                    """
                    terms = curve.index
                    dterms = [self._days_in_term(t, self.convention) for
                              t in terms]
                    iterms = np.arange(min(dterms), max(dterms), 10)
                    for method in interpolate_methods:
                        plot_type = self.interpolate_display[method]
                        irates = self._interpolate_rates(dterms, list(curve),
                                                         iterms, method,
                                                         self.convention_year)
                        plt.plot(iterms, irates, plot_type, label=method)
                    plt.xlabel('Days to Maturity')
                    plt.ylabel('Swap Rate (%)')
                    plt.title(date)
                    plt.legend()
                    plt.show()
                    plotted = True
            else:
                if not scatter:
                    curve.plot(label=date)
                else:
                    terms = curve.index
                    dterms = [self._days_in_term(t, self.convention) for
                              t in terms]
                    rates = curve.tolist()
                    plt.plot(dterms, rates, 'o', label=date)

        if not plotted:
            plt.xlabel('Days to Maturity')
            plt.ylabel('Swap Rate (%)')
            plt.legend()
            plt.show()

    def get_historic_duration(self, maturity, plot=False):

        durations = pd.Series()
        # term = self._days_in_term(maturity, self.convention)
        term = maturity
        for date in self.rates.columns.values:
            rate = self.get_rate([date], [term])["cubic"][term]
            duration = self._get_duration(maturity, float(rate), self.convention_year)
            durations.at[date] = float(duration)

        if plot:
            durations.plot()
            plt.show()

        return durations

    def _get_3d_curve(self, base_curve, maturities):

        icurve = base_curve.copy()
        icurve = icurve.dropna()

        icurve_maturities = icurve.index
        icurve_dmaturities = [self._days_in_term(term, self.convention) for
                              term in icurve_maturities]
        max_maturity = max(icurve_dmaturities)
        min_maturity = max(icurve_dmaturities)
        date = base_curve.name

        for maturity in maturities:
            dmaturity = self._days_in_term(maturity, self.convention)
            if (dmaturity > min_maturity and dmaturity < max_maturity) and dmaturity not in icurve_dmaturities:
                rate = self.get_rate(date, dmaturity)['cubic'][dmaturity]
                base_curve[maturity] = rate

        return base_curve

    @staticmethod
    def _get_duration(maturity, rate, convention):

        rate = rate/100
        numerator = maturity/convention
        duration = - numerator / (1+rate)

        return duration

    @staticmethod
    def _interpolate_rates(day_terms, rates, interp_terms,
                           method, convention_days):

        if method != 'flat_forward':
            func = interp1d(day_terms, rates, kind=method)
            interp_rates = [func(day) for day in interp_terms]
        else:
            ff = FlatForward()
            interp_rates = ff.interpolate(rates, day_terms,
                                          interp_terms, convention_days)

        return interp_rates

    @staticmethod
    def _days_in_term(term, rules):

        rule = {
                'D': {
                        'business_days': 1,
                        'calendar_days': 1
                        },
                'W': {
                        'business_days': 5,
                        'calendar_days': 7
                        },
                'M': {
                        'business_days': 22,
                        'calendar_days': 30
                        },
                'Y': {
                        'business_days': 252,
                        'calendar_days': 360
                        }
        }

        term_time = term[-1]
        multiplication = int(term[0:-1])

        maturity = rule[term_time][rules]

        term_days = maturity * multiplication

        return term_days

    @staticmethod
    def _forward_rate(base_date, maturity1, maturity2,
                      rate1, rate2, convention):

        rate1 = rate1/100
        rate2 = rate2/100
        holidays = AnbimaHolidays().get_holidays()

        maturity1_date = base_date + dt.timedelta(days=maturity1)
        maturity2_date = base_date + dt.timedelta(days=maturity2)

        business_days1 = np.busday_count(np.array(base_date).astype('datetime64[D]'),
                                         np.array(maturity1_date).astype('datetime64[D]'), holidays=holidays)
        business_days2 = np.busday_count(np.array(base_date).astype('datetime64[D]'),
                                         np.array(maturity2_date).astype('datetime64[D]'), holidays=holidays)

        days_to_years1 = (business_days1/convention)
        days_to_years2 = (business_days2/convention)

        numerator = (1+rate2)**days_to_years2
        denominator = (1+rate1)**days_to_years1

        get_forward = ((numerator/denominator)-1)*100

        return get_forward


class FlatForward(object):
    """This class has the abilities of creating a Flat Forward interpolation
    on a specific set of swap rates.
    """

    def interpolate(self, rates, maturities,
                    desired_maturities, convention_days):
        """Function responsible for activating a FlatForward interpolation method
        on a specific set of rates.

        Arguments
        ----------
            rates : list
                A List or a Numpy ndarray containing a collection of rates (Real Ones).
            maturities : list
                A List or a Numpy ndarray containing a collection of maturities (On DU unities).
            desired_maturities {list}
                A List or a Numpy ndarray containing the maturities which you want to
                calculate the rates (On DU unities).
            convention_days : int
                Int which representates the convention of the year (252 for Business Days, 365 for Days, etc.).


        Return
        ----------
            desired_rates : list
                A list containing the rates the user wanted. Indexing correspond desired_maturities indexing.
        """

        discounts = [self._convert_rate(rate, maturity, convention_days) for
                     rate, maturity in zip(rates, maturities)]
        interp_func = interp1d(maturities, discounts)

        desired_rates = []
        for maturity in desired_maturities:
            discount = interp_func(maturity)
            rate = self._convert_discount(discount, maturity, convention_days)
            desired_rates.append(rate)

        return desired_rates

    @staticmethod
    def _convert_rate(rate, maturity, convention_days):

        rate = rate/100
        discount = 1/((1+rate)**(maturity/convention_days))
        discount = log(discount)
        return discount

    @staticmethod
    def _convert_discount(discount, maturity, convention_days):

        discount = exp(discount)
        rate = (1/discount)**(convention_days/maturity) - 1
        rate = rate*100
        return rate
