# -*- coding: utf-8 -*-

from PyQt4 import QtGui, QtCore


class Edge(QtCore.QObject):
    def __init__(self, from_tl, to_tl, duration=None, rate=None):
        super(Edge, self).__init__(None)
        self.from_tl = from_tl
        self.to_tl = to_tl
        self.duration = duration
        self.rate = rate

    def contains(self, temp_level):
        return (
          (self.from_tl.temp < temp_level.temp < self.to_tl.temp) or
          (self.from_tl.temp > temp_level.temp > self.to_tl.temp))

    def __repr__(self):
        return "Edge(%r, %r, %r, %r)" % (self.from_tl, self.to_tl, self.duration, self.rate)


class EdgeModel(QtCore.QAbstractTableModel):
    edge_changed = QtCore.pyqtSignal()

    def __init__(self, parent):
        super(EdgeModel, self).__init__(parent)
        self.edges = list()
        self.headerdata = [
            u"From Temperature (°C)",
            u"To Temperature (°C)",
            u"Duration (s)",
            u"Rate (°C/s)"]

    def headerData(self, col, orientation, role):
        if orientation == QtCore.Qt.Horizontal and role == QtCore.Qt.DisplayRole:
            return QtCore.QVariant(self.headerdata[col])
        return QtCore.QVariant()

    def rowCount(self, parent):
        return len(self.edges)

    def columnCount(self, parent):
        return 4

    def data(self, index, role):
        if not index.isValid():
            return QtCore.QVariant()

        col = index.column()
        if role == QtCore.Qt.DisplayRole:
            if col == 0:
                return QtCore.QVariant(self.edges[index.row()].from_tl.name)
            elif col == 1:
                return QtCore.QVariant(self.edges[index.row()].to_tl.name)
            elif col == 2:
                return QtCore.QVariant(self.edges[index.row()].duration)
            elif col == 3:
                return QtCore.QVariant(self.edges[index.row()].rate)

        if index.column() < 2 and role == QtCore.Qt.DecorationRole:
            p = QtGui.QPixmap(10,10)
            if col == 0:
                p.fill(self.edges[index.row()].from_tl.color)
            elif col == 1:
                p.fill(self.edges[index.row()].to_tl.color)
            return p

        return QtCore.QVariant()

    def flags(self, index):
        if not index.isValid():
            return 0
        return QtCore.Qt.ItemFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable)

    def setData(self, index, variant, role):
        if index.isValid() and role == QtCore.Qt.EditRole:
            col = index.column()
            if col == 2:
                self.edges[index.row()].duration = variant.toFloat()[0]
            elif col == 3:
                self.edges[index.row()].rate = variant.toFloat()[0]
            self.edge_changed.emit()
            return True
        return False

    def remove_edge(self, index):
        tmp = self.edges[index]
        del self.edges[index]
        self.reset()
        self.edge_changed.emit()
        return tmp

    def add_edge(self, index, edge):
        self.edges.insert(index.row() + 1, edge)
        self.reset()
        self.edge_changed.emit()

    def setTempLevels(self, edges):
        assert isinstance(edges, list)
        self.edges = edges
        self.reset()

    def clear(self):
        self.edges = list()
        self.reset()

    def get_edge(self, ix):
        return self.edges[ix]

class ConstraintWidget(QtGui.QWidget):
    edge_changed = QtCore.pyqtSignal()
    def __init__(self, name):
        super(ConstraintWidget, self).__init__()
        self.name = name

        self.edge_model = EdgeModel(self) # temp_level selection pool

        self.edge_view = QtGui.QTableView(self)
        self.edge_view.setModel(self.edge_model)
        self.edge_view.verticalHeader().setVisible(False)
        self.edge_view.resizeColumnsToContents()
        self.edge_view.horizontalHeader().setStretchLastSection(True)
        self.edge_view.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)


        h = QtGui.QHBoxLayout(self)
        h.addWidget(self.edge_view)

    def edge_picked(self, ix):
        print self.edge_picked
        self.edge_view.setCurrentIndex(self.edge_model.index(ix, 0))

    def setData(self, solder):
        print self.setData
        self.solder = solder
        self.edge_model.setTempLevels(solder.edges)
        self.edge_view.setCurrentIndex(self.edge_model.index(0,0))

        self.connect(
            self.edge_model,
            QtCore.SIGNAL("edge_changed()"),
            self._edge_changed)

    def _edge_changed(self):
        print self.temp_level_added
        self.edge_changed.emit()

    def temp_level_added(self, new_tl):
        print self.temp_level_added, len(self.edge_model.edges)
        new_edges = list()
        ix = 0
        batch = list()
        for edge in self.edge_model.edges:
            if edge.contains(new_tl):
                batch.append(edge)

        for edge in batch:
            if edge.from_tl < new_tl:
                duration = None if edge.duration is None else edge.duration / 2
                new_edge = Edge(new_tl, edge.to_tl, duration, edge.rate)
                edge.duration = duration
                edge.to_tl = new_tl
                ix = self.edge_model.edges.index(edge)
                self.edge_model.edges.insert(ix+1, new_edge)
            else:
                duration = None if edge.duration is None else edge.duration / 2
                new_edge = Edge(new_tl, edge.to_tl, duration, edge.rate)
                edge.duration = duration
                edge.to_tl = new_tl
                ix = self.edge_model.edges.index(edge)
                self.edge_model.edges.insert(ix+1, new_edge)

        #for i in new_edges:
            #print repr(i)
        #for edge, new_edge in new_edges:

        self.edge_model.reset()