import os
from PyQt4.QtCore import *
from PyQt4.QtGui import *

from sfa.util.rspecHelper import RSpec
from sface.sfahelper import *
from sface.sficonfig import config
from sface.sfiprocess import SfiProcess
from sface.screens.sfascreen import SfaScreen

class NodeView(QTreeView):
    def __init__(self, parent):
        QTreeView.__init__(self, parent)

        self.setItemsExpandable(True)
        self.setRootIsDecorated(True)
        self.setAlternatingRowColors(True)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.setAttribute(Qt.WA_MacShowFocusRect, 0)

class ItemDelegate(QStyledItemDelegate):
    def __init__(self, parent):
        QStyledItemDelegate.__init__(self)

    def paint(self, painter, option, index):
        data = "%s" % index.data().toString()

        if data.startswith("*"): # already in the sliver
            data = " %s " % data[1:]

            rect = option.rect
            fm = QFontMetrics(option.font)
            w = fm.width(QString(data))
            rect.setWidth(w)

            painter.save()
            painter.fillRect(rect, QColor.fromRgb(0, 250, 0))
            painter.setPen(QColor.fromRgb(0, 0, 0))
            painter.drawText(option.rect, 0, QString(data))
            painter.restore()
        else: # others, fall back to default view
            QStyledItemDelegate.paint(self, painter, option, index)

class TreeItem:
    def __init__(self, data, parent=None):
        self.parentItem = parent
        self.itemData = data
        self.childItems = []

    def clear(self):
        for child in self.childItems:
            child.clear()
            del child
        del self.childItems
        self.childItems = []

    def appendChild(self, child):
        self.childItems.append(child)

    def child(self, row):
        return self.childItems[row]
    
    def childCount(self):
        return len(self.childItems)

    def columnCount(self):
        return len(self.itemData)

    def data(self, column):
        return self.itemData[column]

    def row(self):
        if (self.parentItem):
            try:
                return self.parentItem.childItems.index(self)
            except ValueError:
                return 0
        return 0
    
    def parent(self):
        return self.parentItem



class NodeModel(QAbstractItemModel):
    def __init__(self, parent):
        QAbstractItemModel.__init__(self, parent)
        self.__initRoot()

    def clear(self):
        self.rootItem.clear()
        self.__initRoot()

    def __initRoot(self):
        self.rootItem = TreeItem([QString("Testbed"), QString("Hostname"), QString("Selected")])

    def columnCount(self, parent):
        if parent.isValid():
            return parent.internalPointer().columnCount()
        else:
            return self.rootItem.columnCount()

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

        if role != Qt.DisplayRole:
            return QVariant()

        item = index.internalPointer()
        return item.data(index.column())

    def headerData(self, section, orientation, role):
        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
            return self.rootItem.data(section)
        return QVariant()

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

    def index(self, row, column, parent):
        if not self.hasIndex(row, column, parent):
            return QModelIndex()

        parentItem = None
        if not parent.isValid():
            parentItem = self.rootItem
        else:
            parentItem = parent.internalPointer()
            
        childItem = parentItem.child(row)
        if childItem:
            return self.createIndex(row, column, childItem)
        else:
            return QModelIndex()

    def parent(self, index):
        if not index.isValid():
            return QModelIndex()

        childItem = index.internalPointer()
        parentItem = childItem.parent()

        if not parentItem:
            return QModelIndex()

        if parentItem is self.rootItem:
            return QModelIndex()

        return self.createIndex(parentItem.row(), 0, parentItem)

    def rowCount(self, parent):
        if parent.column() > 0:
            return 0

        parentItem = None
        if not parent.isValid():
            parentItem = self.rootItem
        else:
            parentItem = parent.internalPointer()

        return parentItem.childCount()


class SliceWidget(QWidget):
    def __init__(self, parent):
        QWidget.__init__(self, parent)

        refresh = QLabel("<a href='refresh'>Update Slice Data</a>", self)
        refresh.setScaledContents(False)
        slicename = QLabel ("Slice : %s"%(config.getSlice() or "None"),self)
        slicename.setScaledContents(False)

        hlayout = QHBoxLayout()
        hlayout.addWidget(slicename)
        hlayout.addStretch()
        hlayout.addWidget(refresh)

        self.nodeView = NodeView(self)
        self.nodeModel = NodeModel(self)
        self.nodeView.setModel(self.nodeModel)

        submit = QPushButton("Submit", self)
        submit.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)

        layout = QVBoxLayout()
        layout.addLayout(hlayout)
        layout.addWidget(self.nodeView)
        layout.addWidget(submit, 0, Qt.AlignRight)
        self.setLayout(layout)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)

        self.connect(refresh, SIGNAL('linkActivated(QString)'), self.refresh)
        self.connect(submit, SIGNAL('clicked()'), self.submit)

        rspec_file = os.path.expanduser("~/.sfi/%s.rspec" % config.getSlice())
        if os.path.exists(rspec_file):
            self.updateView()

    def submit(self):
        self.parent().setStatus("TODO: Submit not implemented yet!", 3000)
        
    def readSliceRSpec(self):
        rspec_file = config.getSliceRSpecFile()
        xml = open(rspec_file).read()
        return xml

    def refresh(self, link=None):
        if not config.getSlice():
            self.parent().setStatus("<font color='red'>Slice not set yet!</font>", timeout=None)
            return

        self.process = SfiProcess()
        outfile = self.process.getRSpecFromSM()
        self.parent().setStatus("Updating slice data. This may take some time...", timeout=None)
        
        self.connect(self.process, SIGNAL('finished()'), self.refreshFinished)

    def refreshFinished(self):
        del self.process
        self.parent().setStatus("<font color='green'>Slice data updated.</font>", timeout=5000)
        self.updateView()

    def updateView(self):
        self.nodeModel.clear()
        rspec_string = self.readSliceRSpec()
        networks = rspec_get_networks(rspec_string)

        for network in networks:
            networkItem = TreeItem([QString(network), QString(""), QString("")], self.nodeModel.rootItem)

            all_nodes = rspec_get_nodes_from_network(rspec_string, network)
            sliver_nodes = rspec_get_sliver_nodes_from_network(rspec_string, network)
            available_nodes = filter(lambda x:x not in sliver_nodes, all_nodes)

            for node in sliver_nodes:
                nodeItem = TreeItem([QString(""), QString("*%s" % node), QString("Implement Checkbox")], networkItem)
                networkItem.appendChild(nodeItem)

            for node in available_nodes:
                nodeItem = TreeItem([QString(""), QString(node), QString("Implement Checkbox")], networkItem)
                networkItem.appendChild(nodeItem)

            self.nodeModel.rootItem.appendChild(networkItem)

        self.nodeView.expandAll()
        self.nodeView.resizeColumnToContents(1)

        self.delegate = ItemDelegate(self)
        self.nodeView.setItemDelegateForColumn(1, self.delegate)


class MainScreen(SfaScreen):
    def __init__(self, parent):
        SfaScreen.__init__(self, parent)

        slice = SliceWidget(self)
        self.init(slice, "Main Window", "OneLab Federation GUI")