import math 
import os
import shutil
import subprocess
import numpy as np
import csv
import matplotlib.pyplot as plt
import sys
from scipy import signal
import re
from scipy.interpolate import griddata
import scipy.io as sio
import imageio
from mpl_toolkits import mplot3d
from scipy import signal
from scipy.fftpack import fft, ifft

# fonction moyenne glissante
def lissage(Lx,Ly,p):
    '''Fonction qui débruite une courbe par une moyenne glissante
        sur 2P+1 points'''
    Lxout=[]
    Lyout=[]
    Lxout = Lx[p: -p]
    for index in range(p, len(Ly)-p):
        average = np.mean(Ly[index-p : index+p+1])
        Lyout.append(average)
    return Lxout,Lyout


# import orientation data
with open('ADV/ARTHA_aut18.sen','r') as n:
    content = n.readlines()
    heading = []
    pitch = []
    roll = []
    i = 0
    for i in range(len(content)-1):
        row = content[i].split()
        heading.append(float(row[10]))
        pitch.append(float(row[11]))
        roll.append(float(row[12]))
        i+=1

# import Pressure and velocity measurement
with open('ADV/ARTHA_aut18.dat','r') as n:
    content = n.readlines()
    E = []
    N = []
    Up = []
    P = []
    burstnb = []
    position = []
    i = 0
    for i in range(len(content)-1):
        row = content[i].split()
        burstnb.append(int(row[0]))
        position.append(int(row[1]))
        E.append(float(row[2]))
        N.append(float(row[3]))
        Up.append(float(row[4]))
        P.append(float(row[14]))
        i+=1

# import seal level pressure and reshape vector to fit the ADV data
with open('press_socoa_0110_2311_18.data','r') as n:
    content = n.readlines()[1:]
    burstind = []
    date = []
    slp = []
    ind = 1
    i = 0
    for i in range(len(content)-1):
        row = content[i].split(";")
        date.append(int(row[1]))
        slp.append(float(row[3]))
        if date[i] >= 2018101004 and date[i]%2 == 0:
            burstind.append(int(ind))
            ind+=1
        else :
            burstind.append("nan")
        i+=1

slpind = []
i=0
while i<len(slp):
    if burstind[i] != 'nan' :
        slpind.append(slp[i])
    i+=1


slpind = slpind[:304]


# height from ground to ADV
delta = 0.4
# gravity
g = 9.81
#define time vector
t = np.linspace(0, 1200, 2400)


burstP = np.zeros((304,2400))
burstE = np.zeros((304,2400))
burstN = np.zeros((304,2400))

i = 0
j = 0
n = 1
while i < len(P) :
    burstP[n,j] = P[i] - slpind[n]/100*0.4/10.13
    burstE[n,j] = E[i]
    burstN[n,j] = N[i]
    if i >= n*2400 - 1:
        n+=1
        j=-1
    i+=1
    j+=1

burstP = np.delete(burstP,0,0)
burstE = np.delete(burstE,0,0)
burstN = np.delete(burstN,0,0)

# number of point in the burst
N = 2400
# time step
T = 0.5


#frequency vector

xf = np.linspace(0.0, 1.0/(2.0*T), N//2)

# hs calculation interval
x1 =  np.max(np.where(xf < 0.05))
x2 =  np.min(np.where(xf > 0.17))


# u = vitesse hori
# p = pression

# h = profondeur locale
#fs = fréquence echantillonage
# zmesP = profondeur de mesure de la pression
# zmesU = profondeur de mesure de la vitesse
def PUV_dam(u,p,h,fs,zmesP,zmesU):
    u = detrend(u)
    p = detrend(p)
    ampliseuil = 0.001
    N = len(u)
    delta = 1.0/T
    #transformée de fourrier
    Yu = fft(u)
    Yp = fft(p)
    nyquist = 1/2
    #Fu_xb = ((1:N/2)-1)/(N/2)/deltat*nyquist
    xf = np.linspace(0.0, 1.0/(2.0*T), N//2)
    Ampu = np.abs(Yu[1:N/2])/(N/2.0)
    Ampp = np.abs(Yp[1:N/2])/(N/2.0)
    #pas de frequence deltaf
    deltaf=1/(N/2)/deltat*nyquist;
    #phase
    ThetaU=angle(Yu[1:N/2]);
    ThetaP=angle(Yp[1:N/2]);
    #calcul du coefficient de reflexion
    nbf=length(xf);
    if max(p) > 0 :
        #si pas de données de pression, jsute Sheremet
        #attention : on commence par le deuxieme point, le premier correspondant a frequence nulle
        iicutoff_xb=max(min(np.where(xf>0.5))) #length(Fu_xb)) ?
        #calcul de l'amplitude en deca de la frequence de coupure
        k_xb = []
        ii = 1
        while ii<iicutoff_xb :
            k_xb[ii] = newtonpplus(xf[ii],h,0);
            a1=Ampu[ii];
            a3=Ampp[ii];
            phi1=ThetaU[ii];
            phi3=ThetaP[ii];
            omega[ii]=2*pi*xf[ii];
            cc=omega[ii]*cosh(xf[ii]*(zmesU+h))/sinh(xf[ii]*h);
            ccp=omega[ii]*cosh(xf[ii]*(zmesP+h))/sinh(xf[ii]*h);
            cs=omega[ii]*sinh(xf[ii]*(zmesU+h))/sinh(xf[ii]*h);
            #Procedure de calcul des ai et ar sans courant
            ccc[ii]=cc;
            ccs[ii]=cs;
            cccp[ii]=ccp;
    #calcul des amplitudes des ondes incidentes a partir de uhoriz  et p
            aincident13[ii]=0.5*sqrt(a1*a1/(cc*cc)+a3*a3*g*g*xf[ii]*xf[ii]/(omega[ii]*omega[ii]*ccp*ccp)+2*a1*a3*g*k_xb[ii]*cos(phi3-phi1)/(cc*ccp*omega[ii]))
            areflechi13[ii]=0.5*sqrt(a1*a1/(cc*cc)+a3*a3*g*g*k_xb[ii]*k_xb[ii]/(omega[ii]*omega[ii]*ccp*ccp)-2*a1*a3*g*xf[ii]*cos(phi3-phi1)/(cc*ccp*omega[ii]))
            cv=g*xf[ii]/(omega[ii]*ccp)
            cp=1/cc
            aprog[ii]= a3/(g*xf[ii]/(omega[ii]*ccp)); #hypothese progressive Drevard et al |u|/Cv
    #aprog(ii)= a1/cp;
    #|p|/Cp
            if aincident13[ii]<0.18*ampliseuil:
                r13[ii]=0
            else:
                r13[ii]=areflechi13[ii]/aincident13[ii]
    #calcul des energies incidente et reflechie sans ponderation avec les voisins
    Eprog=0.5*aprog**2/deltaf;
    Eixb=0.5*aincident13**2/deltaf
    Erxb=0.5*areflechi13**2/deltaf
    F=Fu_xb[1:iicutoff_xb]
    return Eixb,Erxb,Eprog,F
    'test'

fs =2


# Calcul du vecteur d'onde en prÈsence d'un courant
# constant u de sens opposÈ ‡ celui de propagation de l'onde
# a partir de la frÈquence f, la profondeur d'eau h et
# la vitesse u du courant
#  kh : vecteur d'onde * profondeur d'eau
def newtonpplus(f,h,u) :
    # calcul de k:
    g = 9.81
    kh = 0.5
    x = 0.001
    u=-u
    while (abs((kh - x)/x) > 0.00000001) :
        x = kh
        fx = x*math.tanh(x) - (h/g)*(2*math.pi*f-(u/h)*x)*(2*math.pi*f-(u/h)*x)
        fprimx = math.tanh(x) + x*(1- (math.tanh(x))**2)+(2*u/g)*(2*math.pi*f-(u/h)*x)
        kh = x - (fx/fprimx)
    k = kh/h
    return k

# fin du calcul de k


u = signal.detrend(U[1])
p = signal.detrend(burstP[1])
ampliseuil = 0.001
N = len(u)
deltat = 1.0/fs
#transformée de fourrier
Yu = fft(u)
Yp = fft(p)
nyquist = 1/2.0
# h = profondeur locale
h = np.mean(burstP[1])
#Fu_xb = ((1:N/2)-1)/(N/2)/deltat*nyquist
xf = np.linspace(0.0, 1.0/(2.0*T), N//2)
Ampu = np.abs(Yu[1:N/2])/(N/2.0)
Ampp = np.abs(Yp[1:N/2])/(N/2.0)
#pas de frequence deltaf
deltaf=1.0/(N/2.0)/deltat*nyquist
#phase
ThetaU=np.angle(Yu[1:N/2])
ThetaP=np.angle(Yp[1:N/2])
#calcul du coefficient de reflexion
#fs = fréquence echantillonage
fs = 2
# zmesP = profondeur de mesure de la pression
zmesP = h - 0.4
# zmesU = profondeur de mesure de la vitesse
zmesU = zmesP
nbf=len(xf)
if max(p) > 0 :
    #si pas de données de pression, jsute Sheremet
    #attention : on commence par le deuxieme point, le premier correspondant a frequence nulle
    iicutoff_xb=max(min(np.where(xf>0.5))) #length(Fu_xb)) ?
    #calcul de l'amplitude en deca de la frequence de coupure
    k_xb = []
    omega = []
    ccc = []
    ccs = []
    cccp = []
    aincident13 =[]
    areflechi13 =[]
    r13 =[]
    aprog = []
    ii = 0
    while ii<iicutoff_xb :
        k_xb.append(newtonpplus(xf[ii],h,0))
        a1=Ampu[ii];
        a3=Ampp[ii];
        phi1=ThetaU[ii];
        phi3=ThetaP[ii];
        omega.append(2*math.pi*xf[ii])
        cc=omega[ii]*math.cosh(xf[ii]*(zmesU+h))/math.sinh(xf[ii]*h);
        ccp=omega[ii]*math.cosh(xf[ii]*(zmesP+h))/math.sinh(xf[ii]*h);
        cs=omega[ii]*math.sinh(xf[ii]*(zmesU+h))/math.sinh(xf[ii]*h);
        #Procedure de calcul des ai et ar sans courant
        ccc.append(cc)
        ccs.append(cs)
        cccp.append(ccp)
        #calcul des amplitudes des ondes incidentes a partir de uhoriz  et p
        aincident13.append(0.5*math.sqrt(a1*a1/(cc*cc)+a3*a3*g*g*xf[ii]*xf[ii]/(omega[ii]*omega[ii]*ccp*ccp)+2*a1*a3*g*k_xb[ii]*math.cos(phi3-phi1)/(cc*ccp*omega[ii])))
        areflechi13.append(0.5*math.sqrt(a1*a1/(cc*cc)+a3*a3*g*g*k_xb[ii]*k_xb[ii]/(omega[ii]*omega[ii]*ccp*ccp)-2*a1*a3*g*xf[ii]*math.cos(phi3-phi1)/(cc*ccp*omega[ii])))
        cv=g*xf[ii]/(omega[ii]*ccp)
        cp=1/cc
        aprog.append(a3/(g*xf[ii]/(omega[ii]*ccp))) #hypothese progressive Drevard et al |u|/Cv
        #aprog(ii)= a1/cp;
        #|p|/Cp
        if aincident13[ii]<0.18*ampliseuil:
            r13.append(0)
        else:
            r13.append(areflechi13[ii]/aincident13[ii])
        ii+=1