from UM.Workspace.WorkspaceReader import WorkspaceReader
from UM.Application import Application

from UM.Logger import Logger
from UM.Settings.ContainerStack import ContainerStack
from UM.Settings.DefinitionContainer import DefinitionContainer
from UM.Settings.InstanceContainer import InstanceContainer
from UM.Settings.ContainerRegistry import ContainerRegistry

from UM.Preferences import Preferences

import zipfile
import io

##    Base implementation for reading 3MF workspace files.
class ThreeMFWorkspaceReader(WorkspaceReader):
    def __init__(self):
        super().__init__()
        self._supported_extensions = [".3mf"]

        self._3mf_mesh_reader = None

    def preRead(self, file_name):
        self._3mf_mesh_reader = Application.getInstance().getMeshFileHandler().getReaderForFile(file_name)
        if self._3mf_mesh_reader and self._3mf_mesh_reader.preRead(file_name) == WorkspaceReader.PreReadResult.accepted:
            pass
        else:
            Logger.log("w", "Could not find reader that was able to read the scene data for 3MF workspace")
            return WorkspaceReader.PreReadResult.failed
        # TODO: Ask user if it's  okay for the scene to be cleared
        return WorkspaceReader.PreReadResult.accepted

    def read(self, file_name):
        # Load all the nodes / meshdata of the workspace
        nodes = self._3mf_mesh_reader.read(file_name)
        if nodes is None:
            nodes = []

        container_registry = ContainerRegistry.getInstance()
        archive = zipfile.ZipFile(file_name, "r")

        cura_file_names = [name for name in archive.namelist() if name.startswith("Cura/")]

        # Create a shadow copy of the preferences (we don't want all of the preferences, but we do want to re-use its
        # parsing code.
        temp_preferences = Preferences()
        temp_preferences.readFromFile(io.TextIOWrapper(archive.open("Cura/preferences.cfg")))  # We need to wrap it, else the archive parser breaks.

        # Copy a number of settings from the temp preferences to the global
        global_preferences = Preferences.getInstance()
        global_preferences.setValue("general/visible_settings", temp_preferences.getValue("general/visible_settings"))
        global_preferences.setValue("cura/categories_expanded", temp_preferences.getValue("cura/categories_expanded"))
        Application.getInstance().expandedCategoriesChanged.emit()  # Notify the GUI of the change

        # TODO: For the moment we use pretty naive existence checking. If the ID is the same, we assume in quite a few
        # TODO: cases that the container loaded is the same (most notable in materials & definitions).
        # TODO: It might be possible that we need to add smarter checking in the future.

        # Get all the definition files & check if they exist. If not, add them.
        definition_container_suffix = ContainerRegistry.getMimeTypeForContainer(DefinitionContainer).suffixes[0]
        definition_container_files = [name for name in cura_file_names if name.endswith(definition_container_suffix)]
        for definition_container_file in definition_container_files:
            container_id = definition_container_file.replace("Cura/", "")
            container_id = container_id.replace(".%s" % definition_container_suffix, "")
            definitions = container_registry.findDefinitionContainers(id=container_id)
            if not definitions:
                definition_container = DefinitionContainer(container_id)
                definition_container.deserialize(archive.open(definition_container_file).read().decode("utf-8"))
                container_registry.addContainer(definition_container)

        # Get all the material files and check if they exist. If not, add them.
        xml_material_profile = None
        for type_name, container_type in container_registry.getContainerTypes():
            if type_name == "XmlMaterialProfile":
                xml_material_profile = container_type
                break

        if xml_material_profile:
            material_container_suffix = ContainerRegistry.getMimeTypeForContainer(xml_material_profile).suffixes[0]
            material_container_files = [name for name in cura_file_names if name.endswith(material_container_suffix)]
            for material_container_file in material_container_files:
                container_id = material_container_file.replace("Cura/", "")
                container_id = container_id.replace(".%s" % material_container_suffix, "")
                materials = container_registry.findInstanceContainers(id=container_id)
                if not materials:
                    material_container = xml_material_profile(container_id)
                    material_container.deserialize(archive.open(material_container_file).read().decode("utf-8"))
                    container_registry.addContainer(material_container)

        # Get quality_changes and user profiles saved in the workspace
        instance_container_suffix = ContainerRegistry.getMimeTypeForContainer(InstanceContainer).suffixes[0]
        instance_container_files = [name for name in cura_file_names if name.endswith(instance_container_suffix)]
        user_instance_containers = []
        quality_changes_instance_containers = []
        for instance_container_file in instance_container_files:
            container_id = instance_container_file.replace("Cura/", "")
            container_id = container_id.replace(".%s" % instance_container_suffix, "")
            instance_container = InstanceContainer(container_id)

            # Deserialize InstanceContainer by converting read data from bytes to string
            instance_container.deserialize(archive.open(instance_container_file).read().decode("utf-8"))
            container_type = instance_container.getMetaDataEntry("type")
            if container_type == "user":
                user_instance_containers.append(instance_container)
            elif container_type == "quality_changes":
                # Check if quality changes already exists.
                quality_changes = container_registry.findInstanceContainers(id = container_id)
                if not quality_changes:
                    container_registry.addContainer(instance_container)
                quality_changes_instance_containers.append(instance_container)
            else:
                continue


        # Get the stack(s) saved in the workspace.
        '''container_stack_suffix = ContainerRegistry.getMimeTypeForContainer(ContainerStack).suffixes[0]
        container_stack_files = [name for name in cura_file_names if name.endswith(container_stack_suffix)]
        global_stack = None
        extruder_stacks = []
        for container_stack_file in container_stack_files:
            container_id = container_stack_file.replace("Cura/", "")
            container_id = container_id.replace(".%s" % container_stack_suffix, "")

            # Check if a stack by this ID already exists;
            container_stacks = container_registry.findContainerStacks(id = container_id)
            if container_stacks:
                print("CONTAINER ALREADY EXISTSSS")

            #stack = ContainerStack(container_id)

            # Deserialize stack by converting read data from bytes to string
            stack.deserialize(archive.open(container_stack_file).read().decode("utf-8"))

            if stack.getMetaDataEntry("type") == "extruder_train":
                extruder_stacks.append(stack)
            else:
                global_stack = stack'''

        return nodes