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(False)
        self.setAlternatingRowColors(True)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)

class TreeItem:
    def __init__(self, data, parent=None):
        self.parentItem = parent
        self.itemData = data
        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):
        print len(self.itemData)
        return len(self.itemData)

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

    def row(self):
        if (self.parentItem):
            for i in self.parentItem.childItems:
                if i is self:
                    return i
    
    def parent(self):
        return self.parentItem



class NodeModel(QAbstractItemModel):
    def __init__(self, parent):
        QAbstractItemModel.__init__(self, parent)
        self.rootItem = TreeItem([QString("Testbed"), QString("Hostname")])

    def addToRoot(self, item):
        self.rootItem.appendChild(item)

    def columnCount(self, parent):
        if parent.isValid():
            print "toto"
            parent.internalPointer().columnCount()
        else:
            print "lala"
            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 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 == 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)

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

        refresh = QLabel("<a href='refresh'>Refresh</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)

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

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

        rspec_file = os.path.expanduser("~/.sfi/%s.rspec" % config.getSlice())
        if os.path.exists(rspec_file):
            self.updateView()
        
    def readSliceRSpec(self):
        rspec_file = os.path.expanduser("~/.sfi/%s.rspec" % config.getSlice())
        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>")
            return

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

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

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

        for network in networks:
            networkItem = TreeItem([QString(network), QString("")])

            all_nodes = rspec_get_nodes_from_network(rspec_string, network)
            for node in all_nodes:
                nodeItem = TreeItem([QString(""), QString(node)])
                networkItem.appendChild(nodeItem)

            self.nodeModel.addToRoot(networkItem)


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

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