# -*- encoding: utf8 -*-

from PyQt4.QtGui import QColor
import numpy as np

from libmath import yafflib

from libmath.BDSlib import id_to_color
from container_base import BaseContainer

import gui.container_widgets


__author__ = 'markusro'


class Conductivity(BaseContainer):
    def __init__( self, plt_imag=None, plt_real=None, limits=None ):
        super(Conductivity, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
        self.widget = gui.container_widgets.ConductivityWidget()
        self.color = QColor("blue")
        self.id_label = "Cond."
        self.id_string = "cond"

        self.param_number = 3

    def function( self, p, x ):
        om = 2*np.pi*x
        sgma, isgma, n = p
        cond = sgma/(om**n)+isgma/(1j*om**n)  # Jonscher (Universal Dielectric Response: e",e' prop sigma/omega**n
        cplx = np.array([cond.real, -cond.imag])
        return cplx


class PowerComplex(BaseContainer):
    def __init__( self, plt_real=None, plt_imag=None, limits=None ):
        super(PowerComplex, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
        self.widget = gui.container_widgets.PowerLawWidget()
        self.color = QColor("#ff44c4")
        self.id_label = 'Power Law'
        self.id_string = "pwr"
        self.param_number = 2

    def function( self, p, x ):
        om = 2*np.pi*x
        sgma, n = p
        power = sgma/(om*1j)**n
        cplx = np.array([power.real, -power.imag])
        return cplx


class Static(BaseContainer):
    def __init__( self, plt_real=None, plt_imag=None, limits=None ):
        super(Static, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
        self.widget = gui.container_widgets.StaticWidget()
        self.color = QColor('#FF0F13')
        self.id_label = u'ε(∞)'
        self.id_string = "eps_infty"
        self.param_number = 1

    def function( self, p, x ):
        eps_inf = p[0]
        static = np.ones((2, x.size))*eps_inf
        static[1, :] *= 0  # set imag part zero
        return static


class Peak(BaseContainer):
    def __init__( self, id_num=None, plt_real=None, plt_imag=None, limits=None ):
        super(Peak, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
        self.widget = gui.container_widgets.PeakWidget()
        self.widget.setId(id_num)
        self.color = id_to_color(id_num)
        self.widget.setColor(self.color)
        self.id_num = id_num
        self.id_label = "Hav-Neg"
        self.id_string = "hn"
        self.param_number = 4

    def function( self, p, x ):
        eps, t, a, b = p
        om = 2*np.pi*x
        hn = eps/(1+(1j*om*t)**a)**b
        cplx = np.array([hn.real, -hn.imag])
        return cplx


class YAFF(BaseContainer):
    def __init__( self, plt_real=None, plt_imag=None, limits=None ):
        super(YAFF, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
        self.widget = gui.container_widgets.YaffWidget()
        self.widget.on_model_changed.connect(self.change_model)
        self.widget.configuration_changed.connect(self.change_configuration)
        self.color = QColor(32, 120, 29, int(255*0.82))
        self._libyaff = yafflib.Yaff(self.widget.getYaffType())
        self.id_label = self._libyaff.label
        self.id_string = "yaff"
        self._param_number = self._libyaff.params
        self._selector_mask = self.widget.selector_mask

    @property
    def param_number( self ):
        return self._param_number

    @param_number.setter
    def param_number( self, num=None ):
        self._param_number = self._libyaff.params

    def change_configuration( self, t_list, tau_list ):
        self._libyaff.dist_tau = tau_list
        self._libyaff.time_points = t_list
        self.update_data()

    def change_model( self ):
        self._libyaff = yafflib.Yaff(self.widget.getYaffType())
        self._selector_mask = self.widget.selector_mask
        self.id_label = self._libyaff.label
        self.param_number = self._libyaff.params
        self.update_data()

    def function( self, p, x ):
        ya = self._libyaff.loss(p, x)
        cplx = np.array([ya.imag, ya.real])
        return cplx