'''

$Author$
$Id$
'''

import os, sys
import numpy
import time
import datetime
path = os.path.split(os.getcwd())[0]
sys.path.append(path)

from Data.JROData import Spectra, SpectraHeis
from IO.SpectraIO import SpectraWriter
from Graphics.schainPlotTypes import ScopeFigure, SpcFigure, RTIFigure
#from JRONoise import Noise

class SpectraProcessor:
    '''
    classdocs
    '''
    
    dataInObj = None        
    
    dataOutObj = None
        
    noiseObj = None
    
    integratorObjList = []
    
    writerObjList = []
    
    integratorObjIndex = None
    
    writerObjIndex = None
    
    profIndex = 0 # Se emplea cuando el objeto de entrada es un Voltage

    firstdatatime = None
    
    def __init__(self):
        '''
        Constructor
        '''
        
        self.integratorObjIndex = None
        self.writerObjIndex = None
        self.plotObjIndex = None
        self.integratorOst = []
        self.plotObjList = []
        self.noiseObj = []
        self.writerObjList = []
        self.buffer = None
        self.firstdatatime = None
        self.profIndex = 0
        
    def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairsList=None):
        
        if dataInObj == None:
            raise ValueError, "This SpectraProcessor.setup() function needs dataInObj input variable"
        
        if dataInObj.type == "Voltage":
            if nFFTPoints == None: 
                raise ValueError, "This SpectraProcessor.setup() function needs nFFTPoints input variable"
            
            
        
        if dataInObj.type == "Spectra":
            if nFFTPoints != None: 
                raise ValueError, "The nFFTPoints cannot be selected to this object type"
            
            nFFTPoints = dataInObj.nFFTPoints
            
            if pairsList == None:
                pairsList = dataInObj.pairsList
        
        if pairsList == None:
            nPairs = 0
        else:
            nPairs = len(pairsList)
        
        self.dataInObj = dataInObj        
        
        if dataOutObj == None:
            dataOutObj = Spectra()
            
        self.dataOutObj = dataOutObj
        self.dataOutObj.nFFTPoints = nFFTPoints
        self.dataOutObj.pairsList = pairsList
        self.dataOutObj.nPairs = nPairs
        
        return self.dataOutObj
    
    def init(self):
        
        self.dataOutObj.flagNoData = True
        
        if self.dataInObj.flagNoData:
            return 0
        
        self.integratorObjIndex = 0
        self.writerObjIndex = 0
        self.plotObjIndex = 0
        
        
        if self.dataInObj.type == "Spectra":
            
            self.dataOutObj.copy(self.dataInObj)
            self.dataOutObj.flagNoData = False
            return
        
        if self.dataInObj.type == "Voltage":
            
            if self.buffer == None:
                self.buffer = numpy.zeros((self.dataInObj.nChannels,
                                           self.dataOutObj.nFFTPoints,
                                           self.dataInObj.nHeights), 
                                          dtype='complex')
            
            self.buffer[:,self.profIndex,:] = self.dataInObj.data
            self.profIndex += 1
            
            if self.firstdatatime == None:
                self.firstdatatime = self.dataInObj.utctime
                
            if self.profIndex == self.dataOutObj.nFFTPoints:
                
                self.__updateObjFromInput()
                self.__getFft()
                
                self.dataOutObj.flagNoData = False
                
                self.buffer = None
                self.firstdatatime = None
                self.profIndex = 0
            
            return
        
        #Other kind of data        
        raise ValueError, "The type object %(s) is not valid " %(self.dataOutObj.type)

    def __getFft(self):
        """
        Convierte valores de Voltaje a Spectra
        
        Affected:
            self.dataOutObj.data_spc
            self.dataOutObj.data_cspc
            self.dataOutObj.data_dc
            self.dataOutObj.heightList
            self.dataOutObj.m_BasicHeader
            self.dataOutObj.m_ProcessingHeader
            self.dataOutObj.radarControllerHeaderObj
            self.dataOutObj.systemHeaderObj
            self.profIndex  
            self.buffer
            self.dataOutObj.flagNoData
            self.dataOutObj.dtype
            self.dataOutObj.nPairs
            self.dataOutObj.nChannels
            self.dataOutObj.nProfiles
            self.dataOutObj.systemHeaderObj.numChannels
            self.dataOutObj.m_ProcessingHeader.totalSpectra 
            self.dataOutObj.m_ProcessingHeader.profilesPerBlock
            self.dataOutObj.m_ProcessingHeader.numHeights
            self.dataOutObj.m_ProcessingHeader.spectraComb
            self.dataOutObj.m_ProcessingHeader.shif_fft
        """
            
        fft_volt = numpy.fft.fft(self.buffer,axis=1)
        dc = fft_volt[:,0,:]
        
        #calculo de self-spectra
        fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
        spc = fft_volt * numpy.conjugate(fft_volt)
        spc = spc.real
        
        blocksize = 0
        blocksize += dc.size
        blocksize += spc.size
        
        cspc = None
        pairIndex = 0
        if self.dataOutObj.pairsList != None:
            #calculo de cross-spectra
            cspc = numpy.zeros((self.dataOutObj.nPairs, self.dataOutObj.nFFTPoints, self.dataOutObj.nHeights), dtype='complex')
            for pair in self.dataOutObj.pairsList:
                cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
                pairIndex += 1
            blocksize += cspc.size
        
        self.dataOutObj.data_spc = spc
        self.dataOutObj.data_cspc = cspc
        self.dataOutObj.data_dc = dc
        self.dataOutObj.blockSize = blocksize
        
#        self.getNoise()

    def __updateObjFromInput(self):
        
        self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
        self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
        self.dataOutObj.channelList = self.dataInObj.channelList
        self.dataOutObj.heightList = self.dataInObj.heightList
        self.dataOutObj.dtype = self.dataInObj.dtype
        self.dataOutObj.nHeights = self.dataInObj.nHeights
        self.dataOutObj.nChannels = self.dataInObj.nChannels
        self.dataOutObj.nBaud = self.dataInObj.nBaud
        self.dataOutObj.nCode = self.dataInObj.nCode
        self.dataOutObj.code = self.dataInObj.code
        self.dataOutObj.nProfiles = self.dataOutObj.nFFTPoints
        self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
        self.dataOutObj.flagTimeBlock = self.dataInObj.flagTimeBlock
        self.dataOutObj.utctime = self.firstdatatime
        self.dataOutObj.flagDecodeData = self.dataInObj.flagDecodeData #asumo q la data esta decodificada
        self.dataOutObj.flagDeflipData = self.dataInObj.flagDeflipData #asumo q la data esta sin flip
        self.dataOutObj.flagShiftFFT = self.dataInObj.flagShiftFFT
        self.dataOutObj.nCohInt = self.dataInObj.nCohInt
        self.dataOutObj.nIncohInt = 1
        self.dataOutObj.ippSeconds = self.dataInObj.ippSeconds
        self.dataOutObj.timeInterval = self.dataInObj.timeInterval*self.dataOutObj.nFFTPoints
        
    def addWriter(self, wrpath, blocksPerFile):
        
        objWriter = SpectraWriter(self.dataOutObj)
        objWriter.setup(wrpath, blocksPerFile)
        self.writerObjList.append(objWriter)
                    
    def addIntegrator(self,N,timeInterval):
        
        objIncohInt = IncoherentIntegration(N,timeInterval)
        self.integratorObjList.append(objIncohInt)
        
    def addCrossSpc(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
        crossSpcObj = CrossSpcFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
        self.plotObjList.append(crossSpcObj)
        
    def plotCrossSpc(self, idfigure=None,
                    xmin=None,
                    xmax=None,
                    ymin=None,
                    ymax=None,
                    minvalue=None,
                    maxvalue=None,
                    wintitle='',
                    driver='plplot',
                    colormap='br_green',
                    colorbar=True,
                    showprofile=False,
                    save=False,
                    gpath=None,
                    pairsList = None):
        
        if self.dataOutObj.flagNoData:
            return 0
        
        if pairsList == None:
            pairsList = self.dataOutObj.pairsList
        
        nframes = len(pairsList)
        
        x = numpy.arange(self.dataOutObj.nFFTPoints)
                
        y = self.dataOutObj.heightList
        
        data_spc = self.dataOutObj.data_spc
        data_cspc = self.dataOutObj.data_cspc
        
        data = []
        
        
        if len(self.plotObjList) <= self.plotObjIndex:
            self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
            
            
            

        
    def addRti(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
        rtiObj = RTIFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
        self.plotObjList.append(rtiObj)
        
    def plotRti(self, idfigure=None,
                    starttime=None,
                    endtime=None,
                    rangemin=None,
                    rangemax=None,
                    minvalue=None,
                    maxvalue=None,
                    wintitle='',
                    driver='plplot',
                    colormap='br_greeen',
                    colorbar=True,
                    showprofile=False,
                    xrangestep=None,
                    save=False,
                    gpath=None,
                    ratio=1,
                    channelList=None):
        
        if self.dataOutObj.flagNoData:
            return 0
        
        if channelList == None:
            channelList = self.dataOutObj.channelList
            
        nframes = len(channelList)
        
        if len(self.plotObjList) <= self.plotObjIndex:
            self.addRti(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
        
        data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])
        
        data = numpy.average(data, axis=1)
        
        currenttime = self.dataOutObj.utctime - time.timezone
        
        range = self.dataOutObj.heightList
        
        
        figuretitle = "RTI Plot for Spectra Data" #+ date
        
        cleardata = False
        
        deltax = self.dataOutObj.timeInterval
        
        plotObj = self.plotObjList[self.plotObjIndex]
        
        plotObj.plotPcolor(data=data, 
                           x=currenttime, 
                           y=range, 
                           channelList=channelList, 
                           xmin=starttime, 
                           xmax=endtime, 
                           ymin=rangemin, 
                           ymax=rangemax,
                           minvalue=minvalue, 
                           maxvalue=maxvalue, 
                           figuretitle=figuretitle, 
                           xrangestep=xrangestep,
                           deltax=deltax,
                           save=save, 
                           gpath=gpath,
                           ratio=ratio,
                           cleardata=cleardata
                           )
        
        
        
        self.plotObjIndex += 1
        
        
        
        
        
        
    
    def addSpc(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
        
        spcObj = SpcFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
        self.plotObjList.append(spcObj)
    
    def plotSpc(self, idfigure=None,
                    xmin=None,
                    xmax=None,
                    ymin=None,
                    ymax=None,
                    minvalue=None,
                    maxvalue=None,
                    wintitle='',
                    driver='plplot',
                    colormap='br_green',
                    colorbar=True,
                    showprofile=False,
                    save=False,
                    gpath=None,
                    ratio=1,
                    channelList=None):
        
        if self.dataOutObj.flagNoData:
            return 0
        
        if channelList == None:
            channelList = self.dataOutObj.channelList
        
        nframes = len(channelList)
        
        if len(self.plotObjList) <= self.plotObjIndex:
            self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
            
        x = numpy.arange(self.dataOutObj.nFFTPoints)
                
        y = self.dataOutObj.heightList
        
        data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])    
#        noisedB = 10.*numpy.log10(noise)
        noisedB = numpy.arange(len(channelList)+1)
        noisedB = noisedB *1.2
        titleList = []
        for i in range(len(noisedB)):
            title = "%.2f"%noisedB[i]
            titleList.append(title)
        
        thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
        dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
        figuretitle = "Spc Radar Data: %s"%dateTime
        
        cleardata = True
        
        plotObj = self.plotObjList[self.plotObjIndex]
        
        plotObj.plotPcolor(data=data, 
                            x=x, 
                            y=y, 
                            channelList=channelList, 
                            xmin=xmin, 
                            xmax=xmax, 
                            ymin=ymin, 
                            ymax=ymax,
                            minvalue=minvalue, 
                            maxvalue=maxvalue, 
                            figuretitle=figuretitle,
                            xrangestep=None,
                            deltax=None, 
                            save=save, 
                            gpath=gpath,
                            cleardata=cleardata
                            )
        
        self.plotObjIndex += 1
    
    
    def writeData(self, wrpath, blocksPerFile):
        
        if self.dataOutObj.flagNoData:
            return 0
            
        if len(self.writerObjList) <= self.writerObjIndex:
            self.addWriter(wrpath, blocksPerFile)
        
        self.writerObjList[self.writerObjIndex].putData()
        
        self.writerObjIndex += 1
                
    def integrator(self, N=None, timeInterval=None):
        
        if self.dataOutObj.flagNoData:
                return 0
        
        if len(self.integratorObjList) <= self.integratorObjIndex:
            self.addIntegrator(N,timeInterval)
        
        myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
        myIncohIntObj.exe(data=self.dataOutObj.data_spc,datatime=self.dataOutObj.utctime)
        
        if myIncohIntObj.isReady:
            self.dataOutObj.data_spc = myIncohIntObj.data
            self.dataOutObj.timeInterval *= myCohIntObj.nIncohInt
            self.dataOutObj.nIncohInt = myIncohIntObj.navg * self.dataInObj.nIncohInt
            self.dataOutObj.utctime = myIncohIntObj.firstdatatime
            self.dataOutObj.flagNoData = False
            
            """Calcular el ruido"""
            self.getNoise()
        else:
            self.dataOutObj.flagNoData = True
        
        self.integratorObjIndex += 1
        
 
class SpectraHeisProcessor:
    
    def __init__(self):
        
        self.integratorObjIndex = None
        self.writerObjIndex = None
        self.plotObjIndex = None
        self.integratorObjList = []
        self.writerObjList = []
        self.plotObjList = []
        #self.noiseObj = Noise()
    
    def setup(self, dataInObj, dataOutObj=None, nFFTPoints=None, pairList=None):
        
        if nFFTPoints == None:
            nFFTPoints = self.dataInObj.nHeights 
            
        self.dataInObj = dataInObj        
        
        if dataOutObj == None:
            dataOutObj = SpectraHeis()
            
        self.dataOutObj = dataOutObj
        
        return self.dataOutObj
    
    def init(self):
        
        self.dataOutObj.flagNoData = True
        
        if self.dataInObj.flagNoData:
            return 0
        
        self.integratorObjIndex = 0
        self.writerObjIndex = 0
        self.plotObjIndex = 0
        
        if self.dataInObj.type == "Voltage":
            self.__updateObjFromInput()
            self.__getFft()
            self.dataOutObj.flagNoData = False
            return
            
        #Other kind of data
        if self.dataInObj.type == "SpectraHeis":
            self.dataOutObj.copy(self.dataInObj)
            self.dataOutObj.flagNoData = False
            return
        
        raise ValueError, "The type is not valid"
    
    def __updateObjFromInput(self):
        
        self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
        self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
        self.dataOutObj.channelList = self.dataInObj.channelList
        self.dataOutObj.heightList = self.dataInObj.heightList
        self.dataOutObj.dtype = self.dataInObj.dtype
        self.dataOutObj.nHeights = self.dataInObj.nHeights
        self.dataOutObj.nChannels = self.dataInObj.nChannels
        self.dataOutObj.nBaud = self.dataInObj.nBaud
        self.dataOutObj.nCode = self.dataInObj.nCode
        self.dataOutObj.code = self.dataInObj.code
        self.dataOutObj.nProfiles = 1
        self.dataOutObj.nFFTPoints = self.dataInObj.nHeights
        self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
        self.dataOutObj.flagNoData = self.dataInObj.flagNoData
        self.dataOutObj.flagTimeBlock = self.dataInObj.flagTimeBlock
        self.dataOutObj.utctime = self.dataInObj.utctime
        self.dataOutObj.flagDecodeData = self.dataInObj.flagDecodeData #asumo q la data esta decodificada
        self.dataOutObj.flagDeflipData = self.dataInObj.flagDeflipData #asumo q la data esta sin flip
        self.dataOutObj.flagShiftFFT = self.dataInObj.flagShiftFFT
        self.dataOutObj.nIncohInt = 1
        self.dataOutObj.ippSeconds= self.dataInObj.ippSeconds
    
  #  def addWriter(self,wrpath,blocksPerfile):
    def addWriter(self,wrpath):
        objWriter=SpectraHeisWriter(self.dataOutObj)
        objWriter.setup(wrpath)
        #objWriter.setup(wrpath,blocksPerfile)
        self.writerObjList.append(objWriter)
    
   # def writedata(self,wrpath,blocksPerfile):
    def writedata(self,wrpath): 
        if self.dataOutObj.flagNoData:
            return 0
            
        if len(self.writerObjList) <= self.writerObjIndex:
            #self.addWriter(wrpath, blocksPerFile)
            self.addWriter(wrpath)
        
        self.writerObjList[self.writerObjIndex].putData()
        
        self.writerObjIndex += 1 
                 
    def __getFft(self):
           
        fft_volt = numpy.fft.fft(self.dataInObj.data, axis=1)        
        #print fft_volt
        #calculo de self-spectra
        fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
        
        spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
        self.dataOutObj.data_spc = spc
    
    def getSpectra(self):
        
        return self.dataOutObj.data_spc
    
    def getFrecuencies(self):
        
        print self.nFFTPoints
        return numpy.arange(int(self.nFFTPoints))
    
    def addIntegrator(self,N,timeInterval):
        
        objIncohInt = IncoherentIntegration(N,timeInterval)
        self.integratorObjList.append(objIncohInt)
    
    def integrator(self, N=None, timeInterval=None):
        
        if self.dataOutObj.flagNoData:
                return 0
        
        if len(self.integratorObjList) <= self.integratorObjIndex:
            self.addIntegrator(N,timeInterval)
        
        myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
        myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.utctime)
        
        if myIncohIntObj.isReady:
            self.dataOutObj.data_spc = myIncohIntObj.data
            self.dataOutObj.nIncohInt = self.dataOutObj.nIncohInt*myIncohIntObj.navg
            self.dataOutObj.flagNoData = False
            
            #self.getNoise(type="hildebrand",parm=myIncohIntObj.navg)
#            self.getNoise(type="sort", parm=16)
            
        else:
            self.dataOutObj.flagNoData = True
        
        self.integratorObjIndex += 1

        
    def addScope(self, idfigure, nframes, wintitle, driver):
        
        if idfigure==None:
            idfigure = self.plotObjIndex
            
        scopeObj = ScopeFigure(idfigure, nframes, wintitle, driver)
        self.plotObjList.append(scopeObj)
    
    def plotScope(self,
                    idfigure=None,
                    minvalue=None,
                    maxvalue=None,
                    xmin=None,
                    xmax=None,
                    wintitle='',
                    driver='plplot',
                    save=False,
                    gpath=None,
                    titleList=None,
                    xlabelList=None,
                    ylabelList=None):
        
        if self.dataOutObj.flagNoData:
            return 0
        
        nframes = len(self.dataOutObj.channelList)
        
        if len(self.plotObjList) <= self.plotObjIndex:
            self.addScope(idfigure, nframes, wintitle, driver)
            
            
        data1D = self.dataOutObj.data_spc
        
        x = numpy.arange(self.dataOutObj.nHeights)
        
        thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
        
        dateTime = "%s"%(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
        date = "%s"%(thisDatetime.strftime("%d-%b-%Y"))
        
        figureTitle = "Scope Plot Radar Data: " + date
        
        plotObj = self.plotObjList[self.plotObjIndex]
        
        plotObj.plot1DArray(data1D, 
                             x, 
                             self.dataOutObj.channelList, 
                             xmin, 
                             xmax, 
                             minvalue, 
                             maxvalue,
                             figureTitle,
                             save, 
                             gpath)
                
        self.plotObjIndex += 1

    def rti(self):
        if self.dataOutObj.flagNoData:
           return 0
        
        data=numpy.average(self.dataOutObj.data_spc,axis=1)
        data[0]
        print data[0]
        x = numpy.arange(100000)
        
        print "test"
        #print self.dataOutObj.data_spc.average(axis=1)
       
class IncoherentIntegration:

    integ_counter = None
    data = None
    navg = None
    buffer = None
    nIncohInt = None
    firstdatatime = None
    
    def __init__(self, N = None, timeInterval = None):
        """
        N 
        timeInterval - interval time [min], integer value
        """
        
        self.data = None
        self.navg = None
        self.buffer = None
        self.timeOut = None
        self.exitCondition = False
        self.isReady = False
        self.nIncohInt = N
        self.integ_counter = 0
        self.firstdatatime = None
        
        if timeInterval!=None:
            self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
        
        if ((timeInterval==None) and (N==None)):
             print 'N = None ; timeInterval = None'
             sys.exit(0)
        elif timeInterval == None:
            self.timeFlag = False
        else:
            self.timeFlag = True
            
            
    def exe(self,data,datatime):
        """
        data
        
        datatime [seconds]
        """
        if self.firstdatatime == None or self.isReady:
            self.firstdatatime = datatime

        if self.timeFlag:
            if self.timeOut == None:
                self.timeOut = datatime + self.timeIntervalInSeconds
            
            if datatime < self.timeOut:
                if self.buffer == None:
                    self.buffer = data
                else:
                    self.buffer = self.buffer + data
                self.integ_counter += 1
            else:
                self.exitCondition = True
                
        else:
            if self.integ_counter < self.nIncohInt:
                if self.buffer == None:
                    self.buffer = data
                else:
                    self.buffer = self.buffer + data
            
                self.integ_counter += 1

            if self.integ_counter == self.nIncohInt:
                self.exitCondition = True
                
        if self.exitCondition:
            self.data = self.buffer
            self.navg = self.integ_counter
            self.isReady = True
            self.buffer = None
            self.timeOut = None
            self.integ_counter = 0
            self.exitCondition = False
            
            if self.timeFlag:
                self.buffer = data
                self.timeOut = datatime + self.timeIntervalInSeconds
        else:
            self.isReady = False