// Copyright (c) 2018 Ultimaker B.V.
// Cura is released under the terms of the LGPLv3 or higher.

import QtQuick 2.10
import QtQuick.Controls 2.3
import QtQuick.Controls.Styles 1.4
import QtQuick.Layouts 1.3

import UM 1.4 as UM
import Cura 1.0 as Cura


/**
 * Menu that allows you to select the configuration of the current printer, such
 * as the nozzle sizes and materials in each extruder.
 */
Cura.ExpandablePopup
{
    id: base

    property var extrudersModel: CuraApplication.getExtrudersModel()

    UM.I18nCatalog
    {
        id: catalog
        name: "cura"
    }

    enum ConfigurationMethod
    {
        Auto,
        Custom
    }

    contentPadding: UM.Theme.getSize("default_lining").width
    enabled: Cura.MachineManager.activeMachine ? Cura.MachineManager.activeMachine.hasMaterials || Cura.MachineManager.activeMachine.hasVariants || Cura.MachineManager.activeMachine.hasVariantBuildplates : false; //Only let it drop down if there is any configuration that you could change.

    headerItem: Item
    {
        // Horizontal list that shows the extruders and their materials
        RowLayout
        {
            anchors.top: parent.top
            anchors.bottom: parent.bottom
            anchors.left: parent.left
            width: parent.width - UM.Theme.getSize("standard_arrow").width
            visible: Cura.MachineManager.activeMachine ? Cura.MachineManager.activeMachine.hasMaterials : false
            Repeater
            {
                model: extrudersModel
                delegate: Item
                {
                    id: extruderItem

                    Layout.preferredWidth: Math.round(parent.width / extrudersModel.count)
                    Layout.maximumWidth: Math.round(parent.width / extrudersModel.count)
                    Layout.fillHeight: true

                    property var extruderStack: Cura.MachineManager.activeMachine.extruders[model.index]
                    property bool valueWarning: !Cura.ExtruderManager.getExtruderHasQualityForMaterial(extruderStack)
                    property bool valueError: Cura.ContainerManager.getContainerMetaDataEntry(extruderStack.material.id, "compatible", "") != "True"

                    // Extruder icon. Shows extruder index and has the same color as the active material.
                    Cura.ExtruderIcon
                    {
                        id: extruderIcon
                        materialColor: model.color
                        extruderEnabled: model.enabled
                        anchors.verticalCenter: parent.verticalCenter
                    }

                    MouseArea // Connection status tooltip hover area
                    {
                        id: tooltipHoverArea
                        anchors.fill: parent
                        hoverEnabled: tooltip.text != ""
                        acceptedButtons: Qt.NoButton // react to hover only, don't steal clicks

                        onEntered:
                        {
                            base.mouseArea.entered() // we want both this and the outer area to be entered
                            tooltip.show()
                        }
                        onExited: { tooltip.hide() }
                    }

                    Cura.ToolTip
                    {
                        id: tooltip
                        x: 0
                        y: parent.height + UM.Theme.getSize("default_margin").height
                        width: UM.Theme.getSize("tooltip").width
                        targetPoint: Qt.point(Math.round(extruderIcon.width / 2), 0)
                        text:
                        {
                            if (!model.enabled)
                            {
                                return ""
                            }
                            if (extruderItem.valueError)
                            {
                                return catalog.i18nc("@tooltip", "The configuration of this extruder is not allowed, and prohibits slicing.")
                            }
                            if (extruderItem.valueWarning)
                            {
                                return catalog.i18nc("@tooltip", "There are no profiles matching the configuration of this extruder.")
                            }
                            return ""
                        }
                    }

                    // Warning icon that indicates if no qualities are available for the variant/material combination for this extruder
                    UM.RecolorImage
                    {
                        id: badge
                        anchors
                        {
                            top: parent.top
                            topMargin: - Math.round(height * 1 / 6)
                            left: parent.left
                            leftMargin: extruderIcon.width - Math.round(width * 5 / 6)
                        }

                        width: UM.Theme.getSize("icon_indicator").width
                        height: UM.Theme.getSize("icon_indicator").height

                        visible: model.enabled && (extruderItem.valueError || extruderItem.valueWarning)

                        source:
                        {
                            if (extruderItem.valueError)
                            {
                                return UM.Theme.getIcon("ErrorBadge", "low")
                            }
                            if (extruderItem.valueWarning)
                            {
                                return UM.Theme.getIcon("WarningBadge", "low")
                            }
                            return ""
                        }

                        color:
                        {
                            if (extruderItem.valueError)
                            {
                                return UM.Theme.getColor("error")
                            }
                            if (extruderItem.valueWarning)
                            {
                                return UM.Theme.getColor("warning")
                            }
                            return "transparent"
                        }

                        // Make a themable circle in the background so we can change it in other themes
                        Rectangle
                        {
                            id: iconBackground
                            anchors.centerIn: parent
                            width: parent.width - 1.5  //1.5 pixels smaller, (at least sqrt(2), regardless of screen pixel scale) so that the circle doesn't show up behind the icon due to anti-aliasing.
                            height: parent.height - 1.5
                            radius: width / 2
                            z: parent.z - 1
                            color:
                            {
                                if (extruderItem.valueError)
                                {
                                    return UM.Theme.getColor("error_badge_background")
                                }
                                if (extruderItem.valueWarning)
                                {
                                    return UM.Theme.getColor("warning_badge_background")
                                }
                                return "transparent"
                            }
                        }
                    }

                    Column
                    {
                        opacity: model.enabled ? 1 : UM.Theme.getColor("extruder_disabled").a
                        spacing: 0
                        visible: width > 0
                        anchors
                        {
                            left: extruderIcon.right
                            leftMargin: UM.Theme.getSize("default_margin").width
                            verticalCenter: parent.verticalCenter
                            right: parent.right
                            rightMargin:  UM.Theme.getSize("default_margin").width
                        }
                        // Label for the brand of the material
                        Label
                        {
                            id: materialBrandNameLabel

                            text:  model.material_brand + " " + model.material_name
                            elide: Text.ElideRight
                            font: UM.Theme.getFont("default")
                            color: UM.Theme.getColor("text")
                            renderType: Text.NativeRendering
                            width: parent.width
                            visible: !truncated
                        }

                        Label
                        {
                            id: materialNameLabel

                            text: model.material_name
                            elide: Text.ElideRight
                            font: UM.Theme.getFont("default")
                            color: UM.Theme.getColor("text")
                            renderType: Text.NativeRendering
                            width: parent.width
                            visible: !materialBrandNameLabel.visible && !truncated
                        }

                        Label
                        {
                            id: materialTypeLabel

                            text: model.material_type
                            elide: Text.ElideRight
                            font: UM.Theme.getFont("default")
                            color: UM.Theme.getColor("text")
                            renderType: Text.NativeRendering
                            width: parent.width
                            visible: !materialBrandNameLabel.visible && !materialNameLabel.visible
                        }
                        // Label that shows the name of the variant
                        Label
                        {
                            id: variantLabel

                            visible: Cura.MachineManager.activeMachine ? Cura.MachineManager.activeMachine.hasVariants : false

                            text: model.variant
                            elide: Text.ElideRight
                            font: UM.Theme.getFont("default_bold")
                            color: UM.Theme.getColor("text")
                            renderType: Text.NativeRendering
                            Layout.preferredWidth: parent.width
                        }
                    }
                }
            }
        }

        // Placeholder text if there is a configuration to select but no materials (so we can't show the materials per extruder).
        Label
        {
            text: catalog.i18nc("@label", "Select configuration")
            elide: Text.ElideRight
            font: UM.Theme.getFont("medium")
            color: UM.Theme.getColor("text")
            renderType: Text.NativeRendering

            visible: Cura.MachineManager.activeMachine ? !Cura.MachineManager.activeMachine.hasMaterials && (Cura.MachineManager.activeMachine.hasVariants || Cura.MachineManager.activeMachine.hasVariantBuildplates) : false

            anchors
            {
                left: parent.left
                leftMargin: UM.Theme.getSize("default_margin").width
                verticalCenter: parent.verticalCenter
            }
        }
    }

    contentItem: Column
    {
        id: popupItem
        width: UM.Theme.getSize("configuration_selector").width
        height: implicitHeight  // Required because ExpandableComponent will try to use this to determine the size of the background of the pop-up.
        padding: UM.Theme.getSize("default_margin").height
        spacing: UM.Theme.getSize("default_margin").height

        property bool is_connected: false  // If current machine is connected to a printer. Only evaluated upon making popup visible.
        property int configuration_method: ConfigurationMenu.ConfigurationMethod.Custom  // Type of configuration being used. Only evaluated upon making popup visible.
        property int manual_selected_method: -1  // It stores the configuration method selected by the user. By default the selected method is

        onVisibleChanged:
        {
            is_connected = Cura.MachineManager.activeMachine.hasRemoteConnection && Cura.MachineManager.printerConnected && Cura.MachineManager.printerOutputDevices[0].uniqueConfigurations.length > 0 //Re-evaluate.

            // If the printer is not connected or does not have configurations, we switch always to the custom mode. If is connected instead, the auto mode
            // or the previous state is selected
            configuration_method = is_connected ? (manual_selected_method == -1 ? ConfigurationMenu.ConfigurationMethod.Auto : manual_selected_method) : ConfigurationMenu.ConfigurationMethod.Custom
        }

        Item
        {
            width: parent.width - 2 * parent.padding
            height:
            {
                var height = 0
                if (autoConfiguration.visible)
                {
                    height += autoConfiguration.height
                }
                if (customConfiguration.visible)
                {
                    height += customConfiguration.height
                }
                return height
            }

            AutoConfiguration
            {
                id: autoConfiguration
                visible: popupItem.configuration_method == ConfigurationMenu.ConfigurationMethod.Auto
            }

            CustomConfiguration
            {
                id: customConfiguration
                visible: popupItem.configuration_method == ConfigurationMenu.ConfigurationMethod.Custom
            }
        }

        Rectangle
        {
            id: separator
            visible: buttonBar.visible
            x: -parent.padding

            width: parent.width
            height: UM.Theme.getSize("default_lining").height

            color: UM.Theme.getColor("lining")
        }

        //Allow switching between custom and auto.
        Item
        {
            id: buttonBar
            visible: popupItem.is_connected //Switching only makes sense if the "auto" part is possible.

            width: parent.width - 2 * parent.padding
            height: childrenRect.height

            Cura.SecondaryButton
            {
                id: goToCustom
                visible: popupItem.configuration_method == ConfigurationMenu.ConfigurationMethod.Auto
                text: catalog.i18nc("@label", "Custom")

                anchors.right: parent.right

                iconSource: UM.Theme.getIcon("ChevronSingleRight")
                isIconOnRightSide: true

                onClicked:
                {
                    popupItem.configuration_method = ConfigurationMenu.ConfigurationMethod.Custom
                    popupItem.manual_selected_method = popupItem.configuration_method
                }
            }

            Cura.SecondaryButton
            {
                id: goToAuto
                visible: popupItem.configuration_method == ConfigurationMenu.ConfigurationMethod.Custom
                text: catalog.i18nc("@label", "Configurations")

                iconSource: UM.Theme.getIcon("ChevronSingleLeft")

                onClicked:
                {
                    popupItem.configuration_method = ConfigurationMenu.ConfigurationMethod.Auto
                    popupItem.manual_selected_method = popupItem.configuration_method
                }
            }
        }
    }

    Connections
    {
        target: Cura.MachineManager
        function onGlobalContainerChanged() { popupItem.manual_selected_method = -1 }  // When switching printers, reset the value of the manual selected method
    }
}
