from PyQt4.QtCore import QObject, pyqtSignal
import numpy as N
import conductivityWidget


class Data:
    def __init__(self, frequency, die_real, die_imag):
        self.frequency = frequency
        self.epsilon = die_real + 1j * die_imag
        self.data_curve = None # mpl object
        self.fitted_curve = None # mpl object
        self.length = len(frequency)
        self.meta = dict()
        self.fit_limits = (frequency.min(), frequency.max(), die_imag.min(), die_imag.max())

    def __del__(self):
        #self.remove_curves()
        pass
    #def set_fit_limits(self, limits=(None,None,None,None)):
    def get_data(self):
        """
        
        """
        mask = N.ones(len(self.frequency), dtype='bool')
        mask = (self.frequency > self.fit_limits[0]) & (self.frequency < self.fit_limits[1])
        mask &= (self.epsilon.imag > self.fit_limits[2]) & (self.epsilon.imag < self.fit_limits[1])
        return self.frequency[mask], self.epsilon[mask]

    def remove_curves(self):
        print "remove data_curve"
        if self.data_curve is not None: self.data_curve.remove()
        print "remove fitted_curve"
        if self.fitted_curve is not None: self.fitted_curve.remove()


class Conductivity(QObject):
    changedData = pyqtSignal()

    def __init__(self, mpl=None):
        QObject.__init__(self)
        super(Conductivity, self)
        self.widget = conductivityWidget.ConductivityWidget()
        self.widget.changedTable.connect(self.updateData)
        self.mpl_line = None
        self.mpl_line_static = None
        self.mpl = mpl


    def getParameter(self):
        p = self.widget.getTable()
        return p

    def getFixed(self):
        p = self.widget.fixedParameter()
        return p

    def setParameter(self, eps_static=None, sigma=None, sigma_N=None):
        self.widget.updateTable(eps_static, sigma, sigma_N)
        self.updateData()

    def updateData(self):
        # get current axis limits
        x_min, x_max = self.mpl.canvas.axes.get_xlim()
        y_min, y_max = self.mpl.canvas.axes.get_ylim()

        nu = N.logspace(N.log10(x_min), N.log10(x_max), 1024)
        eps_static, sigma, sigma_N = self.getParameter()
        y = conductivity([sigma, sigma_N], nu)
        y_static = N.ones(len(nu)) * eps_static
        # clip data to axes limits
        mask_static = (y_static < y_max) & (y_static > y_min)
        # clip data to axes limits
        mask = (y < y_max) & (y > y_min)
        #mask = mask_static = N.ones(1024, dtype='bool')
        if self.mpl_line == None:
            self.mpl_line, = self.mpl.canvas.axes.loglog(nu[mask], y[mask], 'k--', label="Cond.", animated=True) # peak
        else:
            self.mpl_line.set_xdata(nu[mask])
            self.mpl_line.set_ydata(y[mask])

        if self.mpl_line_static == None:
            self.mpl_line_static, = self.mpl.canvas.axes.loglog(nu[mask_static],
                                                                y_static[mask_static],
                                                                'k:',
                                                                label=r"$\epsilon_S$",
                                                                animated=True) # peak
        else:
            self.mpl_line_static.set_xdata(nu[mask_static])
            self.mpl_line_static.set_ydata(y_static[mask_static])

        self.changedData.emit()


def conductivity(p, nu):
    c = p[0] / (2 * N.pi * nu) ** p[1]
    return c