from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QDialog, QMessageBox, QTableWidgetItem
from nufaceqt.ruleset_dialog_ui import Ui_Dialog
from nucentral.client import NuCentralError, tr
from nufaceqt.html import htmlValue, htmlTitle

class RulesetDialog(QDialog, Ui_Dialog):
    def __init__(self, window):
        QDialog.__init__(self, window)
        self.setupUi(self)
        self.setupDialog(window)
        self.run()

    def setupDialog(self, window):
        self.window = window
        self.nuface = window.nuface
        self.connect(self.ruleset_tab,
            SIGNAL("currentChanged(int)"), self.tabChanged)
        self.connect(self.delete_button,
            SIGNAL("clicked()"), self.deleteRuleset)
        self.setupTable(self.ruleset_table)
        self.setupTable(self.template_table)
        self.current_table = self.ruleset_table
        self.is_template = False
        if not self.fillTables():
            return
        self.selectRuleset()

    def run(self):
        ret = self.exec_()
        if not ret:
            return
        name = self.currentName()
        self.window.rulesetOpen(name, self.is_template)

    def tabChanged(self, tabindex):
        self.is_template = (tabindex == 1)
        if self.is_template:
            self.current_table = self.template_table
        else:
            self.current_table = self.ruleset_table
        self.selectRuleset()

    def setupTable(self, table):
        table.verticalHeader().hide()
        table.horizontalHeader().setStretchLastSection(True)
        self.connect(table,
            SIGNAL("itemSelectionChanged()"), self.selectRuleset)
        self.connect(table,
            SIGNAL("cellDoubleClicked(int, int)"), self.doubleClick)

    def doubleClick(self, row, cl):
        self.accept()

    def selectRuleset(self):
        name = self.currentName()
        has_name = bool(name)
        self.open_button.setEnabled(has_name)
        self.delete_button.setEnabled(
            has_name and name != self.nuface.ruleset_name)

    def currentName(self):
        table = self.current_table
        row = table.currentRow()
        try:
            item = table.item(row, 0)
            if not item:
                return None
        except IndexError:
            return None
        return unicode(item.text())

    def deleteRuleset(self):
        name = self.currentName()
        choice = QMessageBox.question(self,
            tr("NuFace"),
            tr('Would you really delete the ruleset "%s"?') % htmlValue(name),
            QMessageBox.Yes | QMessageBox.Cancel,
            QMessageBox.Cancel)
        if choice != QMessageBox.Yes:
            return
        try:
            self.nuface('rulesetDelete', name, self.is_template)
        except NuCentralError, err:
            self.window.nucentralError(err)
            return
        text = tr('Ruleset "%s" deleted.') % name
        self.window.setInfo(htmlTitle(text))
        self.fillTables()
        self.selectRuleset()

    def fillTable(self, table, template):
        if template:
            column_name = tr('Template')
            service = 'templateList'
        else:
            column_name = tr('Ruleset')
            service = 'rulesetList'
        try:
            rulesets = self.nuface(service)
        except NuCentralError, err:
            self.window.nucentralError(err)
            return False
        table.clear()
        table.sortItems(0)
        table.setHorizontalHeaderLabels([column_name, tr('Last edition')])
        table.setRowCount(len(rulesets))
        for no, (name, timestamp) in enumerate(rulesets):
            table.setItem(no, 1, QTableWidgetItem(timestamp))
            table.setItem(no, 0, QTableWidgetItem(name))
        table.resizeColumnsToContents()
        return True

    def fillTables(self):
        if not self.fillTable(self.ruleset_table, False):
            return False
        if not self.fillTable(self.template_table, True):
            return False
        return True