import frappy.core as fc
import frappy

from frappy_psi.network_analysers.ZVL.ZVLDriver import ZVLNetAnalyzer

class ZVLNode(fc.Readable):
    """A ZVL Network Analyser.

    Use
    ---
        Set the center (target) and the analyser will be in a BUSY (3XX) state until the output is up to date (at that frequency).
        
    Attributes
    ----------
        value: the magnitude (in dB) of the signal at the set frequency.
        status: status tuple (see frappy docs)
        pollinterval: see frappy docs
        central_freq: the center frequency (in Hz) to be probing
        freq_span: the frequency span (in Hz) to be probing
        analyser_ip: the IP address of the network analyser. Best to set in the config!
    """
    
    value = fc.Parameter('value', 
                         fc.StructOf(magnitudes=fc.ArrayOf(fc.FloatRange(unit='dB'), minlen=1000, maxlen=1000), 
                                     frequencies=fc.ArrayOf(fc.FloatRange(unit='Hz'), minlen=1000, maxlen=1000)), 
                         readonly=True)
    status = fc.Parameter(datatype=frappy.datatypes.StatusType(fc.Readable, "DISABLED", 'PREPARED', 'BUSY'), default=('IDLE', 'idle'))
    pollinterval = fc.Parameter(default=1)
    central_freq = fc.Parameter('central_freq', fc.FloatRange(min=9_000, max=13_600_000_000, unit='Hz'), default=10_000_000, readonly=False)
    freq_span = fc.Parameter('freq_span', fc.FloatRange(unit='Hz'), default=1_000_000, readonly=False)
    calibration = fc.Parameter('calibration filename', fc.StringType(), default='None', readonly=False)
    
    analyser_ip = fc.Parameter('analyser_ip', fc.StringType())

    def initialReads(self):
        self.connect()

    def connect(self):
        self.NA = ZVLNetAnalyzer(self.analyser_ip)
        self.NA.reset()
        self.acq()

    @fc.Command(description="Update data") 
    def acq(self):
        self.status = ('BUSY', 'acquiring')
        #print('acq')
        self.NA.set_freq_span(self.central_freq, self.freq_span)
        freq, vals = self.NA.get_data()
        self.value = { 'frequencies': freq, 'magnitudes': vals }
        self.status = ('IDLE', 'idle')
    
    #@fc.Command(description='Save current calibration')
    #def write_calibration(self, f):
    #    self.calibration = f
    #    self.NA.load_calibration(self.calibration)
    #    return self.read_calibration()
    
    @fc.Command(description='Reload last used calibration')
    def reload_calibration(self):
        self.NA.reload_calibration()
        freq_start, freq_stop = self.NA.get_freq_range()
        self.freq_span = freq_stop - freq_start
        self.central_freq = freq_start + self.freq_span/2.0

    def write_central_freq(self, f):
        self.central_freq = (f)
        self.acq()
        return self.read_central_freq()
        
    def write_freq_span(self, f):
        self.freq_span = f
        self.acq()
        return self.read_freq_span()
        
    def write_analyser_ip(self, ip):
        self.analyser_ip = ip
        self.connect()
        return self.read_analyser_ip()

    def read_value(self):
        #self.acq()
        return self.value