#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import pandas as pd
import numpy as np
pd.set_option('display.width', 2000)  # nezalamuj tabulky

from funkce.nacteni import signal  # znaceni, channels, pocty_znacek, signal, sig_df_to_array
from funkce.vypocet import *
from funkce.D_file_read import read_d_header
from fnusa_sigproc.methods_uni import pse, pac, fac
from pyentrp.entropy import *


def upravit_interpolace_butterworth_sigma():
    # --- výpis počtů značek věech subjektů
    seegs = [15, 32, 45, 48]
    seegs = [15, 45, 48]

    # --- volba délky zpracovávaného záznamu - např. vytažení hodnoty signálu ve vzorku 797950 a jeho blízkého okolí (0,06 sekund)
    time = 0.06
    fs = 5000
    okoli = round((time * fs) / 2)


    # načtení signálů
    sig_FR, sig_vFR, sig_uFR = signal(48, okoli)

    # resampling data
    #x = 0:(1/5000):(sig_FR[0]/5000)
    x_vz = np.linspace(0, 2*okoli, 2*okoli+1) #(len(sig_FR[0])/5000), (1/5000))
    x_vz = x_vz[0:len(x_vz)-1]
    x_time = np.linspace(0, time,  2*okoli+1)
    x_time = x_time[0:len(x_time)-1]

    y = []
    y = sig_FR[0] #; sig_FR[1]]


    # np.insert(y, slice(np.linspace(0, 2*okoli,  okoli+1)), np.zeros(151))


    # vytvoření indexů pro řádek v df, ve kterém bude nenulový signál (například při L=10 indexy 0, 10, 20..) -> později přepsáno na indexy 1, 11, 21, ..
    step = L = 3 # step je roven faktoru L interpolace
    start = 1
    N = sig_FR.shape[0]+1
    result=np.arange(0,N)*step+start #super věc na generování start step stop # numpy function that allows you to specify start, step, and N
    result


    # generování dataframu s nulami, index 0 až ...
    df_zeros = pd.DataFrame(0, index=np.arange(result[-1]), columns=sig_FR.columns)

    # zvolení indexu podle faktoru L, vložení L-1 vzorků (při expanzi signálu)
    df_zeros['idx'] = np.arange(result[-1])
    df_zeros = df_zeros.set_index('idx')

    # mazání řádků, kde bude originální signál
    df_zeros = df_zeros.drop(df_zeros.index[result[0:len(result)-1]])


    # definice indexů podle faktoru L
    # result.remove(-1)
    # sig_FR = sig_FR.iloc[1:] #poslední index mi neajk zlobí, pořeším později
    sig_FR['idx'] = result[0:len(result)-1] #sig_FR['idx'] = np.arange(300+1) #result + 1 # sig_FR.loc[-1] = np.zeros(sig_FR.shape[1])  # adding a row
    sig_FR = sig_FR.set_index('idx')



    # funguje
    neww = pd.concat([sig_FR, df_zeros]).sort_index().reset_index(drop=True)
    neww = neww.iloc[1:] #smazání prvního nulového řádku

    # new = pd.concat([sig_FR, df_zeros])
    # new = new.set_index(index=(new.index + abs(result[-1])))
    # new = pd.DataFrame(nuly_df.values.tolist() * len(idx), columns=nuly_df.columns, index=idx-1)


    x_vz_new_int = np.linspace(0, 2*okoli, L*2*okoli+1) #(len(sig_FR[0])/5000), (1/5000))
    x_vz_new_int = x_vz_new_int[0:len(x_vz_new_int)-1]

    x_time_new_int = np.linspace(0, time,  L*2*okoli+1)
    x_time_new_int = x_time_new_int[0:len(x_time_new_int)-1]


    ## interpolační filtr  hint(n) ={-1/16, 0, 9/16, 1, 9/16, 0, -1/16}.
    # yy = neww[0].iloc[[2,3]]
    # yy = neww[0].iloc[[0,len(result)-1]]



    from scipy.interpolate import interp1d
    f = interp1d(x_time_new_int, neww[0], kind='nearest')
    y_new = f(x_time_new_int)

    import matplotlib.pyplot as plt
    plt.figure(4)
    plt.stem(x_time_new_int, y_new)



    f = interp1d(x_time, y, x_time_new_int) #, kind='nearest')
    y_new = f(x_time_new_int)

    import matplotlib.pyplot as plt
    plt.figure(4)
    plt.stem(x_time_new_int, y_new)




    # nové osy x_time a x_vz
    x_vz_new = np.linspace(0, 2*okoli, L*2*okoli+1) #(len(sig_FR[0])/5000), (1/5000))
    x_vz_new = x_vz_new[0:len(x_vz_new)-1]

    x_time_new = np.linspace(0, time,  L*2*okoli+1)
    x_time_new = x_time_new[0:len(x_time_new)-1]


    # menší úpravy - zkrácení vektoru, aby df začínal a končil hodnotami signálu a ne nulovým řádkem (možné jsou asi obě cesty)..
    # x_time_new = x_time_new[0:len(x_time_new)-L+1]
    # x_vz_new = x_vz_new[0:len(x_vz_new)-L+1]





    from scipy.signal import filtfilt as filtfilt
    from scipy.signal import butter, lfilter, freqz # from scipy.signal import
    from scipy.signal import freqs


    # Butterworthův filtr
    nyq_fq = 0.5 * fs
    lowcut = 2500 #Hz
    low_fq = lowcut / nyq_fq
    # high_fq = highcut / nyq
    order = 8

    b, a = butter(order, low_fq/2, btype='low', analog=False)
    w, h = freqs(b, a)

    yyy = neww[0]
    yyy = neww.values.tolist()
    yyy = neww[0].tolist() #už mu dávám pěkný list

    # y_butter = list()
    y_butter = filtfilt(b, a, yyy, padlen=150) #, padlen=150)
    y_butter1 = lfilter(b, a, yyy)


    import matplotlib.pyplot as plt
    plt.figure(1)
    plt.subplot(3, 1, 1)
    plt.stem(x_time, y)
    plt.legend(['data'], loc='best')
    plt.title('Původní signál')
    plt.show()

    plt.subplot(3, 1, 2)
    plt.stem(x_time_new, yyy)
    plt.legend(['data'], loc='best')
    plt.title('Expanze signálu')
    plt.show()

    plt.subplot(3, 1, 3)
    plt.stem(x_time_new, y_butter1)
    plt.legend(['data'], loc='best')
    plt.title('Butterworthův filtr')
    plt.show()











    ## sinc filter
    fc = 0.2500  # Cutoff frequency as a fraction of the sampling rate (in (0, 0.5)).
    b = 0.18  # Transition band, as a fraction of the sampling rate (in (0, 0.5)).
    N = int(np.ceil((4 / b)))
    if not N % 2: N += 1  # Make sure that N is odd.
    n = np.arange(N)

    # Compute sinc filter.
    h = np.sinc(2 * fc * (n - (N - 1) / 2.))

    # Compute Blackman window.
    w = 0.42 - 0.5 * np.cos(2 * np.pi * n / (N - 1)) + \
        0.08 * np.cos(4 * np.pi * n / (N - 1))

    # Multiply sinc filter with window.
    h = h * w

    # Normalize to get unity gain.
    h = h / np.sum(h)


    s = np.convolve(yyy, h)

    plt.figure(3)
    plt.stem(s)


    return print('not sure what this function does')









def resample_signals(seeg):

    import matplotlib.pyplot as plt
    from funkce.nacteni import signal
    import numpy as np

    #seeg = 15
    okoli = 150 # původní
    # postup pomocí fuknce z netu

    # musím načíst původní signály, abych je mohla podvzorkovat
    sig_FR, sig_vFR, sig_uFR = signal(seeg, okoli)

    step = L = 2 # step je roven faktoru L interpolace

    #y = sig_FR[1]

    from scipy.signal import resample, decimate


    sig_FR_resampled= pd.DataFrame()
    sig_vFR_resampled= pd.DataFrame()
    sig_uFR_resampled= pd.DataFrame()


    for sig in range(0, sig_FR.shape[1]):
        # expanze
        y_interp = resample(sig_FR[sig],L*okoli*2)

        # decimace
        y_downsampled = decimate(y_interp, 5)

        sig_FR_resampled[sig] = np.round_(y_downsampled, 0)


    for sig in range(0, sig_vFR.shape[1]):
        # expanze
        y_interp = resample(sig_vFR[sig],L*okoli*2)

        # decimace
        y_downsampled = decimate(y_interp, 5)

        sig_vFR_resampled[sig] = np.round_(y_downsampled, 0)


    for sig in range(0, sig_uFR.shape[1]):
        # expanze
        y_interp = resample(sig_uFR[sig],L*okoli*2)

        # decimace
        y_downsampled = decimate(y_interp, 5)

        sig_uFR_resampled[sig] = np.round_(y_downsampled, 0)

    # prevence proti vykreslení do existujícího okna
    plt.close('all')

    plt.figure(figsize=[9, 6])


    plt.subplot(3, 1, 1)
    plt.stem(sig_uFR[sig]) #, 'go-', xnew, f, '.-', 10, y[0], 'ro')
    plt.legend(['signál o vzorkovací frekvenci 5 kHz'], loc='best')
    plt.title('Původní signál')
    plt.show()


    plt.subplot(3, 1, 2)
    plt.stem(y_interp) #, 'go-', xnew, f, '.-', 10, y[0], 'ro')
    plt.legend(['signál o vzorkovací frekvenci 10 kHz'], loc='best')
    plt.title('Interpolace signálu, faktor L=2')
    plt.show()


    plt.subplot(3, 1, 3)
    plt.stem(sig_uFR_resampled[sig]) #, 'go-', xnew, f, '.-', 10, y[0], 'ro')
    plt.legend(['signál o vzorkovací frekvenci 2 kHz'], loc='best')
    plt.title('Decimace signálu, faktor D=5')
    plt.xlabel('čas [s]')
    #plt.show()

    plt.tight_layout()

    plt.savefig("Grafy/resampled_ukazka_uFR_" + str(seeg) + ".png")

    plt.close()

    return sig_FR_resampled, sig_vFR_resampled, sig_uFR_resampled


    # # nové osy x_time a x_vz
    # x_vz_new = np.linspace(0, 2*okoli, L*2*okoli+1) #(len(sig_FR[0])/5000), (1/5000))
    # x_vz_new = x_vz_new[0:len(x_vz_new)-1]
    # x_time_new = np.linspace(0, time,  L*2*okoli+1)
    # x_time_new = x_time_new[0:len(x_time_new)-1]
    #
    #
    #
    # plt.figure(2)
    # plt.subplot(3, 1, 2)
    # plt.stem(x_time_new, y_interp) #, 'go-', xnew, f, '.-', 10, y[0], 'ro')
    # plt.legend(['signál o vzorkovací frekvenci 10 kHz'], loc='best')
    # plt.title('Interpolace signálu')
    # plt.show()
    #
    #
    # D = 5
    # vzorku_dec = int((L*okoli*2)/5)
    # y_res_dec = resample(y,vzorku_dec)
    #
    #
    # x_time_new_dec = np.linspace(0, time,  vzorku_dec+1)
    # x_time_new_dec = x_time_new_dec[0:len(x_time_new_dec)-1]
    #


    #x_time_new = x_time_new[0:len(x_time_new)-1]

    # plt.figure(2)
    # plt.subplot(3, 1, 1)
    # plt.stem(x_time_new, neww[0]) #, 'go-', xnew, f, '.-', 10, y[0], 'ro')
    # # plt.legend(['data'], loc='best')
    # plt.title('Expanze signálu, faktor L=2')
    # plt.ylabel('Amplituda signálu [mV]')
    # plt.show()




