#!/usr/bin/env python

import os

class ConfiguratorResource:

    # Standard attributes.

    resource_dir = os.path.join(os.path.split(__file__)[0], "Resources")

    design_resources = {

        "configuration" : "config.ui"

        }

    widget_resources = {

        "hard-disk" : ("config_hard_disk.ui", "hard_disk"),

        "memory-unit" : ("config_memory_unit.ui", "memory_unit"),

        "storage-unit" : ("config_storage_unit.ui", "storage_unit")

        #"hard-disks" : ("config_hard_disks.ui", "hard_disks"),

        #"memory-units" : ("config_memory_units.ui", "memory_units"),

        #"storage-units" : ("config_storage_units.ui", "storage_units")

        }

    document_resources = {

        "base-system" : "config_base_system.xml",

        "cpu" : "config_cpu.xml",

        "hard-disk" : "config_hard_disk.xml",

        "keyboard" : "config_keyboard.xml",

        "mouse" : "config_mouse.xml",

        "screen" : "config_screen.xml"

        }

    # Initialisation.

    def __init__(self, *args, **kw):

        # Get field data.

        # NOTE: This would be done for whole page updates in a Web application.

        self.populate_list(self.base_system, self.get_elements("base-system"))

        self.populate_list(self.keyboard, self.get_elements("keyboard"))

        self.populate_list(self.mouse, self.get_elements("mouse"))

        self.populate_list(self.screen, self.get_elements("screen"))

        self.reset_collection(self.hard_disks)

        self.reset_collection(self.memory_units)

        self.reset_collection(self.storage_units)

    # General functionality.

    def refresh(self, current_text=None):

        # Ensure consistency.

        # NOTE: This would be done for whole page updates in a Web application.

        # NOTE: This would also be done for page updates where the information

        # NOTE: involved was important.

        current_text = current_text or self.base_system.currentText()

        # Find the CPU socket and the interface of the current base system.

        cpu_socket = None

        interface = None

        for element in self.get_elements("base-system"):

            text = element.getAttribute("value")

            if text == current_text:

                cpu_socket = element.getAttribute("cpu-socket")

                interface = element.getAttribute("interface")

        # Find all valid CPUs.

        valid = []

        for element in self.get_elements("cpu"):

            if not element.hasAttribute("cpu-socket") or element.getAttribute("cpu-socket") == cpu_socket:

                valid.append(element)

        self.populate_list(self.cpu, valid)

        # Find all valid hard disks.

        valid = []

        for element in self.get_elements("hard-disk"):

            if not element.hasAttribute("interface") or element.getAttribute("interface") == interface:

                valid.append(element)

        for hard_disk_value in self.factory.find_widgets(self, "hard_disk_value"):

            self.populate_list(hard_disk_value, valid)

    # Slots.

    def baseSystemChanged(self, current_text):

        self.refresh(current_text)

    def addHardDisk(self):

        #hard_disks = self.prepare_widget("configuration", "hard-disks")

        #tab_pages = hard_disks.child("tab pages")

        #tab = tab_pages.child("tab")

        #self.hard_disks.addTab(tab, hard_disks.tabLabel(tab))

        #self.factory.connect(tab, self)

        hard_disk = self.prepare_widget("configuration", "hard-disk", self.hard_disks)

        self.hard_disks.layout().add(hard_disk)

        hard_disk.show()

        self.factory.connect(hard_disk, self)

        # Perform the consistency check.

        # NOTE: This is not as efficient as it could be since the general check

        # NOTE: refreshes all fields, not just newly added ones.

        self.refresh()

    def addMemoryUnit(self):

        #memory_units = self.prepare_widget("configuration", "memory-units")

        #tab_pages = memory_units.child("tab pages")

        #tab = tab_pages.child("tab")

        #self.memory_units.addTab(tab, memory_units.tabLabel(tab))

        #self.factory.connect(tab, self)

        memory_unit = self.prepare_widget("configuration", "memory-unit", self.memory_units)

        self.memory_units.layout().add(memory_unit)

        memory_unit.show()

        self.factory.connect(memory_unit, self)

        # Perform the consistency check.

        # NOTE: This is not as efficient as it could be since the general check

        # NOTE: refreshes all fields, not just newly added ones.

        self.refresh()

    def addStorageUnit(self):

        #storage_units = self.prepare_widget("configuration", "storage-units")

        #tab_pages = storage_units.child("tab pages")

        #tab = tab_pages.child("tab")

        #self.storage_units.addTab(tab, storage_units.tabLabel(tab))

        #self.factory.connect(tab, self)

        storage_unit = self.prepare_widget("configuration", "storage-unit", self.storage_units)

        self.storage_units.layout().add(storage_unit)

        storage_unit.show()

        self.factory.connect(storage_unit, self)

        # Perform the consistency check.

        # NOTE: This is not as efficient as it could be since the general check

        # NOTE: refreshes all fields, not just newly added ones.

        self.refresh()

    def removeHardDisk(self):

        #page = self.hard_disks.currentPage()

        #self.hard_disks.removePage(page)

        #page.deleteLater()

        remove_hard_disk = self.sender()

        hard_disk = remove_hard_disk.parent()

        self.hard_disks.layout().remove(hard_disk)

        hard_disk.deleteLater()

    def removeMemoryUnit(self):

        #page = self.memory_units.currentPage()

        #self.memory_units.removePage(page)

        #page.deleteLater()

        remove_memory_unit = self.sender()

        memory_unit = remove_memory_unit.parent()

        self.memory_units.layout().remove(memory_unit)

        memory_unit.deleteLater()

    def removeStorageUnit(self):

        #page = self.storage_units.currentPage()

        #self.storage_units.removePage(page)

        #page.deleteLater()

        remove_storage_unit = self.sender()

        storage_unit = remove_storage_unit.parent()

        self.storage_units.layout().remove(storage_unit)

        storage_unit.deleteLater()

    def updateConfig(self):

        self.refresh()

    def exportConfig(self):

        print "configuration.exportConfig(): Not implemented yet"

def get_resource_class(resource_type):

    if resource_type == "PyQt":

        import XSLForms.Resources.PyQtResources

        import QtConfigurator.Forms

        class Configurator(ConfiguratorResource, QtConfigurator.Forms.Configurator, XSLForms.Resources.PyQtResources.XSLFormsResource):

            def __init__(self, *args, **kw):

                QtConfigurator.Forms.Configurator.__init__(self, *args, **kw)

                self.factory = XSLForms.Resources.PyQtResources.Factory(self.prepare_design("configuration"))

                ConfiguratorResource.__init__(self, *args, **kw)

    else:

        import XSLForms.Resources.PyQtWebResources

        class Configurator(ConfiguratorResource, XSLForms.Resources.PyQtWebResources.XSLFormsResource):

            def __init__(self, *args, **kw):

                ConfiguratorResource.__init__(self, *args, **kw)

    return Configurator

# vim: tabstop=4 expandtab shiftwidth=4