from scipy import signal
import numpy as np


def find_steps(array, threshold):
    """
    Finds local maxima by segmenting array based on positions at which
    the threshold value is crossed. Note that this thresholding is
    applied after the absolute value of the array is taken. Thus,
    the distinction between upward and downward steps is lost. However,
    get_step_sizes can be used to determine directionality after the
    fact.
    Parameters
    ----------
    array : numpy array
        1 dimensional array that represents time series of data points
    threshold : int / float
        Threshold value that defines a step
    Returns
    -------
    steps : list
        List of indices of the detected steps
    """
    steps        = []
    array        = np.abs(array)
    above_points = np.where(array > threshold, 1, 0)
    ap_dif       = np.diff(above_points)
    cross_ups    = np.where(ap_dif == 1)[0]
    cross_dns    = np.where(ap_dif == -1)[0]
    for upi, dni in zip(cross_ups,cross_dns):
        steps.append(np.argmax(array[upi:dni]) + upi)
    return steps


class PeaksDetector:
    def __init__(self):
        pass

    async def fit(self, dataset, contamination=0.005):
        pass

    async def predict(self, dataframe):
        array = dataframe['value'].as_matrix()
        window_size = 20
        # window = np.ones(101)
        # mean_filtered = signal.fftconvolve(
        #     np.concatenate([np.zeros(window_size), array, np.zeros(window_size)]),
        #     window,
        #     mode='valid'
        # )
        # filtered = np.divide(array, mean_filtered / 101)

        window = signal.general_gaussian(2 * window_size + 1, p=0.5, sig=5)
        #print(window)
        filtered = signal.fftconvolve(array, window, mode='valid')

        # filtered = np.concatenate([
        #     np.zeros(window_size),
        #     filtered,
        #     np.zeros(window_size)
        # ])
        filtered = filtered / np.sum(window)
        array = array[window_size:-window_size]
        filtered = np.subtract(array, filtered)

        # filtered = np.convolve(array, step, mode='valid')
        # print(len(array))
        # print(len(filtered))

        # step = np.hstack((np.ones(window_size), 0, -1*np.ones(window_size)))
        #
        # conv = np.convolve(array, step, mode='valid')
        #
        # conv = np.concatenate([
        #     np.zeros(window_size),
        #     conv,
        #     np.zeros(window_size)])

        #data = step_detect.t_scan(array, window=window_size)
        data = filtered
        data /= data.max()

        result = find_steps(data, 0.1)
        return [(dataframe.index[x], dataframe.index[x + window_size]) for x in result]

    def save(self, model_filename):
        pass
        # with open(model_filename, 'wb') as file:
        #     pickle.dump((self.clf, self.scaler), file)

    def load(self, model_filename):
        pass
        # with open(model_filename, 'rb') as file:
        #     self.clf, self.scaler = pickle.load(file)