#! /usr/bin/env python
# -*- coding: iso-8859-15 -*-
"""
Created on Fri Oct  2 12:29:36 2015

@author: kervella
"""

# gravi_visual_class.py import in other directory
import sys
#sys.path.insert(0, '../../gravi_visual')
import gravi_visual_class
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

import os
from glob import glob
from optparse import OptionParser

def gravi_movie_rawdata(filename):
    #filename = "/Users/kervella/Pipelines/python_tools/GRAVITY.2015-09-14T15-03-39.fits"
    filename = "/Volumes/GRAVITY-1TB/2015-10-15/onsky/GRAVITY.2015-10-16T03-35-01.fits"
    title_ft = "Achernar (GRAVITY, 2015-10-16)"
    title_sc = "Achernar (GRAVITY, 2015-10-16)"
    moviefile_ft = 'gravity-ft-achernar.mp4'
    moviefile_sc = "gravity-sc-achernar.mp4"
    
    plt.close('all')
    
    #preproc = gravi_visual_class.Preproc("/Users/kervella/Pipelines/python_tools/gravi_preproc_GRAVITY.2015-09-16T00-50-06-MR.fits")
    #raw = gravi_visual_class.Rawdata("/Users/kervella/Pipelines/python_tools/GRAVITY.2015-09-14T14-11-18.fits")
    raw = gravi_visual_class.Rawdata(filename)
        
    fig1=plt.figure(figsize=(5,12))
    #fig1.tight_layout()
    plt.title(title_ft)
    plt.xlabel("Spectral channel",fontsize=15)
    plt.ylabel("Fringe Tracker output",fontsize=15)
    
    ims=[]
    step = 40
    maxl = np.percentile(raw.data_ft,97)
    minl = np.percentile(raw.data_ft,1)
    for add in range(0,1000):
        ims.append((plt.imshow(raw.data_ft[add*step,:,:],aspect='auto',interpolation='none',cmap='afmhot',vmin=minl,vmax=maxl),))
    
    im_ani = animation.ArtistAnimation(fig1, ims, interval=100, repeat_delay=3000, blit=True)
    im_ani.save(moviefile_ft, dpi=150, bitrate=3000, metadata={'artist':'Pierre Kervella'})
    
    #plt.show()
    
    fig2=plt.figure(figsize=(20,10))
    plt.title(title_sc)
    plt.xlabel("Spectral channel",fontsize=15)
    plt.ylabel("Science Combiner 48 ouptuts",fontsize=15)
    
    ims=[]
    maxl = np.percentile(raw.data_sc,98)
    minl = np.percentile(raw.data_sc,1)
    for add in range(0,raw.nframe_sc):
        ims.append((plt.imshow(raw.data_sc[add,:,:],aspect='auto',interpolation='none',cmap='afmhot',vmin=minl,vmax=maxl),))
    
    #plt.imshow(preproc.spectrum_ft[16,0:5000,:],aspect='auto',interpolation='none')
    #plt.imshow(raw.data_ft[0,:,:],aspect='auto',interpolation='none')
    
    im_ani = animation.ArtistAnimation(fig2, ims, interval=150, repeat_delay=3000, blit=True)
    im_ani.save(moviefile_sc, dpi=150, bitrate=3000, metadata={'artist':'Pierre Kervella'})



def gravi_movie_preproc(filename):
    
    plt.close('all')
    
    preproc = gravi_visual_class.Preproc(filename+'.fits')

    target_name = preproc.header['HIERARCH ESO FT ROBJ NAME']
    obs_date = preproc.header['DATE-OBS']
    kmag = str(preproc.header['HIERARCH ESO FT ROBJ MAG'])
    title_ft = target_name+" - K="+kmag+" (GRAVITY FT)"#, "+obs_date+")"
    title_sc = target_name+" - K="+kmag+" (GRAVITY Science Combiner, "+obs_date+")"
    moviefile_ft = filename+'-FT.mp4'
    moviefile_sc = filename+'-SC.mp4'    
    
    baseline = 5        # To avoid the back line at the end, the last baseline is treated separately

    #==============================================================================
    # Fringe tracker
    #==============================================================================
    image_rate = 200 # milliseconds per frame
    step_ft = int(image_rate/(1000*preproc.header['HIERARCH ESO DET3 SEQ1 DIT']))
    nimages_ft = int(preproc.nframe_ft/step_ft)

    if False:
        if preproc.polarsplit == True:
            
            max_ft_spectra = np.zeros((6,nimages_ft))
            min_ft_spectra = np.zeros((preproc.spectrum_ft.shape[0],preproc.nwave_ft))
            
            # computation of background per pixel
            for output in range(0,preproc.spectrum_ft.shape[0]):
                for wave in range(0,preproc.nwave_ft):
                    min_ft_spectra[output,wave] = np.nanpercentile(preproc.spectrum_ft[output,:,wave],1)
    
            for baseline in range(0,6): # max level per baseline
                for image in range(0,nimages_ft):
                    max_ft_spectra[baseline,image] = np.nanpercentile(preproc.spectrum_ft[baseline*8:(1+baseline)*8,image*step_ft,:],98)
        
            for output in range(0,preproc.spectrum_sc.shape[0]): # subtraction of dark and normalization by amplitude per baseline
                for image in range(0,nimages_ft):
                    preproc.spectrum_ft[output,step_ft*image,:] -= min_ft_spectra[output,:]
                    preproc.spectrum_ft[output,step_ft*image,:] /= (max_ft_spectra[output//8,image]-min_ft_spectra[output,:])
        
            for image in range(0,nimages_ft): # second normalization per wavelength channel
                for wave in range(0,preproc.nwave_ft):
                    preproc.spectrum_ft[:,step_ft*image,wave] /= np.nanpercentile(preproc.spectrum_ft[:,step_ft*image,wave],98,axis=0)
        
            sorted_spectrum_ft = np.zeros((48+5,nimages_ft,preproc.nwave_ft))
        
            # Sort to have ABCD outputs in this order
            for baseline in range(0,5):
                sorted_spectrum_ft[0+baseline*9,:,:] = preproc.spectrum_ft[0+baseline*8,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[1+baseline*9,:,:] = preproc.spectrum_ft[1+baseline*8,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[2+baseline*9,:,:] = preproc.spectrum_ft[4+baseline*8,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[3+baseline*9,:,:] = preproc.spectrum_ft[5+baseline*8,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[4+baseline*9,:,:] = preproc.spectrum_ft[2+baseline*8,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[5+baseline*9,:,:] = preproc.spectrum_ft[3+baseline*8,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[6+baseline*9,:,:] = preproc.spectrum_ft[6+baseline*8,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[7+baseline*9,:,:] = preproc.spectrum_ft[7+baseline*8,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[8+baseline*9,:,:] = 0.0 # dark line between baselines
    
            baseline = 5        # To avoid the back line at the end, the last baseline is treated separately
            sorted_spectrum_ft[0+baseline*9,:,:] = preproc.spectrum_ft[0+baseline*8,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[1+baseline*9,:,:] = preproc.spectrum_ft[1+baseline*8,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[2+baseline*9,:,:] = preproc.spectrum_ft[4+baseline*8,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[3+baseline*9,:,:] = preproc.spectrum_ft[5+baseline*8,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[4+baseline*9,:,:] = preproc.spectrum_ft[2+baseline*8,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[5+baseline*9,:,:] = preproc.spectrum_ft[3+baseline*8,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[6+baseline*9,:,:] = preproc.spectrum_ft[6+baseline*8,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[7+baseline*9,:,:] = preproc.spectrum_ft[7+baseline*8,0:step_ft*nimages_ft:step_ft,:]
        
            fig1=plt.figure(figsize=(5,12))
            #fig1.tight_layout()
            plt.title(title_ft)
            plt.xlabel("Spectral channel",fontsize=15)
            plt.ylabel("Fringe Tracker output",fontsize=15)
        
        if preproc.polarsplit == False:
            
            max_ft_spectra = np.zeros((6,nimages_ft))
            min_ft_spectra = np.zeros((preproc.nregion,preproc.nwave_ft))
            
            # computation of background per pixel
            for output in range(0,preproc.nregion):
                for wave in range(0,preproc.nwave_ft):
                    min_ft_spectra[output,wave] = np.nanpercentile(preproc.spectrum_ft[output,:,wave],1)
    
            for baseline in range(0,6): # max level per baseline
                for image in range(0,nimages_ft):
                    max_ft_spectra[baseline,image] = np.nanpercentile(preproc.spectrum_ft[baseline*4:(1+baseline)*4,image*step_ft,:],98)
        
            for output in range(0,preproc.nregion): # subtraction of dark and normalization by amplitude per baseline
                for image in range(0,nimages_ft):
                    preproc.spectrum_ft[output,step_ft*image,:] -= min_ft_spectra[output,:]
                    preproc.spectrum_ft[output,step_ft*image,:] /= (max_ft_spectra[output//4,image]-min_ft_spectra[output,:])
        
            for image in range(0,nimages_ft): # second normalization per wavelength channel
                for wave in range(0,preproc.nwave_ft):
                    preproc.spectrum_ft[:,step_ft*image,wave] /= np.nanpercentile(preproc.spectrum_ft[:,step_ft*image,wave],98,axis=0)
        
            baseline = 5        # To avoid the back line at the end, the last baseline is treated separately
    
            # Sort to have ABCD outputs in this order
            sorted_spectrum_ft = np.zeros((24+5,nimages_ft,preproc.nwave_ft))
        
            for baseline in range(0,5):
                sorted_spectrum_ft[0+baseline*5,:,:] = preproc.spectrum_ft[0+baseline*4,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[1+baseline*5,:,:] = preproc.spectrum_ft[2+baseline*4,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[2+baseline*5,:,:] = preproc.spectrum_ft[1+baseline*4,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[3+baseline*5,:,:] = preproc.spectrum_ft[3+baseline*4,0:step_ft*nimages_ft:step_ft,:]
                sorted_spectrum_ft[4+baseline*5,:,:] = 0.0 # dark line between baselines
    
            baseline = 5        # To avoid the back line at the end, the last baseline is treated separately
            sorted_spectrum_ft[0+baseline*5,:,:] = preproc.spectrum_ft[0+baseline*4,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[1+baseline*5,:,:] = preproc.spectrum_ft[2+baseline*4,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[2+baseline*5,:,:] = preproc.spectrum_ft[1+baseline*4,0:step_ft*nimages_ft:step_ft,:]
            sorted_spectrum_ft[3+baseline*5,:,:] = preproc.spectrum_ft[3+baseline*4,0:step_ft*nimages_ft:step_ft,:]
    
            fig1=plt.figure(figsize=(4,12))
            #fig1.tight_layout()
            plt.title(title_ft)
            plt.xlabel("Spectral channel",fontsize=15)
            plt.ylabel("Fringe Tracker output",fontsize=15)
        
        ims=[]
        maxl = np.percentile(sorted_spectrum_ft,99)
        minl = np.percentile(sorted_spectrum_ft,1)
        for add in range(0,nimages_ft):
            ims.append((plt.imshow(sorted_spectrum_ft[:,add,:],aspect='auto',interpolation='none',cmap='gray',vmin=minl,vmax=maxl),)) # Add time in seconds
        
        im_ani = animation.ArtistAnimation(fig1, ims, interval=image_rate, repeat_delay=3000, blit=True)
        im_ani.save(moviefile_ft, dpi=150, bitrate=3000, metadata={'artist':'Pierre Kervella'})


    #==============================================================================
    # Science combiner
    #==============================================================================

    if preproc.polarsplit == True:
        
        min_sc_spectra = np.zeros((6,preproc.nframe_sc))
        max_sc_spectra = np.zeros((6,preproc.nframe_sc))
        
        for baseline in range(0,6): # Computation of the background and maximum per baseline
            for image in range(0,preproc.nframe_sc):
                min_sc_spectra[baseline,image] = np.nanpercentile(preproc.spectrum_sc[baseline*8:(1+baseline)*8,image,:],1)
                max_sc_spectra[baseline,image] = np.nanpercentile(preproc.spectrum_sc[baseline*8:(1+baseline)*8,image,:],99)
    
        for output in range(0,preproc.nregion):
            for image in range(0,preproc.nframe_sc):
                preproc.spectrum_sc[output,image,:] -= min_sc_spectra[output//8,image]
                preproc.spectrum_sc[output,image,:] /= (max_sc_spectra[output//8,image]-min_sc_spectra[output//8,image])
    
        for image in range(0,preproc.nframe_sc):
            for wave in range(0,preproc.nwave_sc):
                preproc.spectrum_sc[:,image,wave] /= np.nanmedian(preproc.spectrum_sc[:,image,wave],axis=0)

        # Sort to have ABCD outputs in this order
        sorted_spectrum_sc = np.zeros((48+5,preproc.nframe_sc,preproc.nwave_sc))
        for baseline in range(0,5):
            sorted_spectrum_sc[0+baseline*9,:,:] = preproc.spectrum_sc[0+baseline*8,:,:]
            sorted_spectrum_sc[1+baseline*9,:,:] = preproc.spectrum_sc[1+baseline*8,:,:]
            sorted_spectrum_sc[2+baseline*9,:,:] = preproc.spectrum_sc[4+baseline*8,:,:]
            sorted_spectrum_sc[3+baseline*9,:,:] = preproc.spectrum_sc[5+baseline*8,:,:]
            sorted_spectrum_sc[4+baseline*9,:,:] = preproc.spectrum_sc[2+baseline*8,:,:]
            sorted_spectrum_sc[5+baseline*9,:,:] = preproc.spectrum_sc[3+baseline*8,:,:]
            sorted_spectrum_sc[6+baseline*9,:,:] = preproc.spectrum_sc[6+baseline*8,:,:]
            sorted_spectrum_sc[7+baseline*9,:,:] = preproc.spectrum_sc[7+baseline*8,:,:]
            sorted_spectrum_sc[8+baseline*9,:,:] = 0.0 # dark line between baselines
    
        baseline = 5        # To avoid the back line at the end, the last baseline is treated separately
        sorted_spectrum_sc[0+baseline*9,:,:] = preproc.spectrum_sc[0+baseline*8,:,:]
        sorted_spectrum_sc[1+baseline*9,:,:] = preproc.spectrum_sc[1+baseline*8,:,:]
        sorted_spectrum_sc[2+baseline*9,:,:] = preproc.spectrum_sc[4+baseline*8,:,:]
        sorted_spectrum_sc[3+baseline*9,:,:] = preproc.spectrum_sc[5+baseline*8,:,:]
        sorted_spectrum_sc[4+baseline*9,:,:] = preproc.spectrum_sc[2+baseline*8,:,:]
        sorted_spectrum_sc[5+baseline*9,:,:] = preproc.spectrum_sc[3+baseline*8,:,:]
        sorted_spectrum_sc[6+baseline*9,:,:] = preproc.spectrum_sc[6+baseline*8,:,:]
        sorted_spectrum_sc[7+baseline*9,:,:] = preproc.spectrum_sc[7+baseline*8,:,:]

        fig2=plt.figure(figsize=(15,10))
        plt.title(title_sc)
        plt.xlabel("Spectral channel",fontsize=15)
        # plt.ylabel("Science Combiner (6 baselines, 48 ouptuts)",fontsize=15)
        plt.ylabel("Science Combiner (6 baselines, 48 ouptuts)",fontsize=15)

    if preproc.polarsplit == False:
        
        min_sc_spectra = np.zeros((6,preproc.nframe_sc))
        max_sc_spectra = np.zeros((6,preproc.nframe_sc))
        
        for baseline in range(0,6): # Computation of the background and maximum per baseline
            for image in range(0,preproc.nframe_sc):
                min_sc_spectra[baseline,image] = np.nanpercentile(preproc.spectrum_sc[baseline*4:(1+baseline)*4,image,:],1)
                max_sc_spectra[baseline,image] = np.nanpercentile(preproc.spectrum_sc[baseline*4:(1+baseline)*4,image,:],99)
    
        for output in range(0,preproc.nregion):
            for image in range(0,preproc.nframe_sc):
                preproc.spectrum_sc[output,image,:] -= min_sc_spectra[output//4,image]
                preproc.spectrum_sc[output,image,:] /= (max_sc_spectra[output//4,image]-min_sc_spectra[output//4,image])
    
        for image in range(0,preproc.nframe_sc):
            for wave in range(0,preproc.nwave_sc):
                preproc.spectrum_sc[:,image,wave] /= np.nanmedian(preproc.spectrum_sc[:,image,wave],axis=0)

        # Sort to have ABCD outputs in this order
        sorted_spectrum_sc = np.zeros((24+5,preproc.nframe_sc,preproc.nwave_sc))
        for baseline in range(0,5):
            sorted_spectrum_sc[0+baseline*5,:,:] = preproc.spectrum_sc[0+baseline*4,:,:]
            sorted_spectrum_sc[1+baseline*5,:,:] = preproc.spectrum_sc[2+baseline*4,:,:]
            sorted_spectrum_sc[2+baseline*5,:,:] = preproc.spectrum_sc[1+baseline*4,:,:]
            sorted_spectrum_sc[3+baseline*5,:,:] = preproc.spectrum_sc[3+baseline*4,:,:]
            sorted_spectrum_sc[4+baseline*5,:,:] = 0.0 # dark line between baselines
    
        baseline = 5        # To avoid the back line at the end, the last baseline is treated separately
        sorted_spectrum_sc[0+baseline*5,:,:] = preproc.spectrum_sc[0+baseline*4,:,:]
        sorted_spectrum_sc[1+baseline*5,:,:] = preproc.spectrum_sc[2+baseline*4,:,:]
        sorted_spectrum_sc[2+baseline*5,:,:] = preproc.spectrum_sc[1+baseline*4,:,:]
        sorted_spectrum_sc[3+baseline*5,:,:] = preproc.spectrum_sc[3+baseline*4,:,:]

        fig2=plt.figure(figsize=(20,10))
        plt.title(title_sc)
        plt.xlabel("Spectral channel",fontsize=15)
        # plt.ylabel("Science Combiner (6 baselines, 48 ouptuts)",fontsize=15)
        plt.ylabel("Science Combiner (6 baselines, 24 ouptuts)",fontsize=15)
    
    minl = 0
    maxl = np.percentile(sorted_spectrum_sc,98) # output, time, wavelength
    
    ims=[]
    for add in range(0,preproc.nframe_sc): # gray
        ims.append((plt.imshow(sorted_spectrum_sc[:,add,:],aspect='auto',interpolation='none',cmap='cubehelix',vmin=minl,vmax=maxl),))
    
    im_ani = animation.ArtistAnimation(fig2, ims, interval=500, repeat_delay=3000, blit=True)
    im_ani.save(moviefile_sc, dpi=150, bitrate=3000, metadata={'artist':'Pierre Kervella'})

    plt.close('all')

#==============================================================================
# MAIN PROGRAM    
#==============================================================================

# Add options
usage = """
        usage:  %prog
"""
parser = OptionParser(usage)
parser.add_option("-o","--overwrite", action="store_true", dest="overwrite_flag",default=False,
                  help="Overwrite existing PDFs")

(argoptions, args) = parser.parse_args()

filelist=[]
## If the user specifies a file name or wild cards ("*_0001.fits")
if len(sys.argv) > 1 :
    longnames = [f for files in sys.argv[1:] for f in glob(files)]
    filelist = [os.path.splitext(f)[0] for f in longnames]
## Processing of the full current directory
else :
    for file in os.listdir("."):
        if file.endswith(".fits"):
            filelist.append(os.path.splitext(file)[0])

filelist.sort() # process the files in alphabetical order
    
for filename in filelist:
    fullname = os.getcwd()+'/'+filename
    gravi_movie_preproc(fullname)





#if __name__ == '__main__':
#
#    #gravi_movie_preproc('/Users/kervella/Pipelines/python_tools/gravi_preproc_GRAVITY.2015-11-05T00-16-53')
#    #gravi_movie_preproc('/Users/kervella/Pipelines/python_tools/gravi_preproc_GRAVITY.2015-11-05T03-40-02')
#    #gravi_movie_preproc('/Users/kervella/Pipelines/python_tools/gravi_preproc_GRAVITY.2015-11-05T04-06-21')
#    #gravi_movie_preproc('/Volumes/GRAVITY-1TB/2016-03-17-GRAVITY-workshop/1_AlfCru_swap/reduced/GRAVI.2016-01-21T07:01:57.790_preproc')
#    gravi_movie_preproc('/Volumes/GRAVITY-1TB/2016-03-17-GRAVITY-workshop/2_EtaCar_High-Split/reduced/GRAVITY.2016-02-25T02-46-42_preproc')



