import QtQuick
import QtQuick.Controls
import QtQuick.Layouts

import "../delegates"
import "../style"

Rectangle {
    id: root

    property var routeModel: null
    property var routeController: null
    property var selectedNode: null
    property string selectedNodeKey: ""
    property bool dragToDetachEnabled: false
    property bool pointPlacementEnabled: false
    property bool locked: false
    property bool lockButtonVisible: false

    signal object3DRequested()
    signal normalWorkspaceRequested()
    signal detachRequested(real globalX, real globalY,
                           real pressOffsetX, real pressOffsetY)
    signal lockToggled(bool locked)

    function visibleIndexByKey(key) {
        if (!root.routeModel || !key)
            return -1
        for (var i = 0; i < root.routeModel.count; ++i) {
            if (String(root.routeModel.get(i).key || "") === key)
                return i
        }
        return -1
    }

    function visibleIndexByNode(node, fallbackNodeId) {
        if (!root.routeModel || !node)
            return -1
        for (var i = 0; i < root.routeModel.count; ++i) {
            if (root.routeModel.get(i).sourceNode === node)
                return i
        }
        var wantedId = String(fallbackNodeId || "")
        if (wantedId.length === 0)
            return -1
        for (var fallbackIndex = 0;
             fallbackIndex < root.routeModel.count; ++fallbackIndex) {
            if (String(root.routeModel.get(fallbackIndex).nodeId || "")
                    === wantedId) {
                return fallbackIndex
            }
        }
        return -1
    }

    function nodeKey(node) {
        if (!node)
            return ""
        var value = node.uuid !== undefined ? node.uuid
                  : node.id !== undefined ? node.id
                  : node.nodeId !== undefined ? node.nodeId : ""
        return value && typeof value.toString === "function"
                ? value.toString() : String(value || "")
    }

    function syncSelectedNode() {
        var nodeId = nodeKey(selectedNode)
        var index = visibleIndexByKey(selectedNodeKey)
        if (index >= 0) {
            var selectedRow = routeModel.get(index)
            if (selectedRow.sourceNode !== selectedNode
                    && String(selectedRow.nodeId || "") !== nodeId) {
                index = -1
            }
        }
        if (index < 0)
            index = visibleIndexByNode(selectedNode, nodeId)
        if (index < 0 && root.routeModel
                && typeof root.routeModel.revealNode === "function") {
            var revealedKey = root.routeModel.revealNode(
                        selectedNode, nodeId, true)
            index = visibleIndexByKey(revealedKey)
        }
        if (index < 0)
            return
        var row = routeModel.get(index)
        selectedNodeKey = String(row.key || "")
        routeList.currentIndex = index
        routeList.positionViewAtIndex(index, ListView.Contain)
        if (row && nodeUsesObjectWorkspace(row.sourceNode))
            object3DRequested()
        else
            normalWorkspaceRequested()
    }

    function toggleRouteNode(visibleIndex, nodeKey, itemY) {
        if (!root.routeController)
            return

        routeViewportRestore.anchorKey = nodeKey
        routeViewportRestore.anchorViewportY = itemY - routeList.contentY
        routeViewportRestore.remainingPasses = 3
        root.routeController.toggleExpanded(visibleIndex)
        routeViewportRestore.restart()
    }

    function nodeHas3DSettings(node) {
        return node && node.model3DName !== undefined
    }

    function nodeIsPoint(node) {
        var adapter = routeController ? routeController.gtldAdapter : null
        return adapter && typeof adapter.nodeIsPoint === "function"
                ? adapter.nodeIsPoint(node) : false
    }

    function nodeUsesObjectWorkspace(node) {
        return nodeHas3DSettings(node) && !nodeIsPoint(node)
    }

    function parentNode(node) {
        if (!node)
            return null
        var parentValue = node.parent
        if (typeof parentValue === "function") {
            try {
                parentValue = parentValue.call(node)
            } catch (error) {
                return null
            }
        }
        return parentValue || null
    }

    function nodeHasActive3DScheme(node) {
        return node
                && Boolean(node.scheme3DActive)
                && String(node.model3DName || "").trim().length > 0
    }

    function modelOwner(routeNode) {
        var current = parentNode(routeNode)
        while (current) {
            if (nodeHasActive3DScheme(current))
                return current
            current = parentNode(current)
        }
        return null
    }

    function routeNodeBelongsToSelectedModel(routeNode) {
        if (!pointPlacementEnabled || !routeNode || !selectedNode)
            return false
        return nodeKey(modelOwner(routeNode)) === nodeKey(selectedNode)
    }

    color: "#F8FAFC"
    border.color: "#788797"
    radius: 8

    onSelectedNodeChanged: Qt.callLater(syncSelectedNode)
    onRouteModelChanged: Qt.callLater(syncSelectedNode)

    ColumnLayout {
        anchors.fill: parent
        anchors.margins: 8
        spacing: 7

        PanelTitleBar {
            Layout.fillWidth: true
            title: "Маршрут"
            counterText: root.routeModel ? String(root.routeModel.count) : "0"
            lockButtonVisible: root.lockButtonVisible
            locked: root.locked
            dragToDetachEnabled: root.dragToDetachEnabled && !root.locked
            onLockToggled: function(locked) {
                root.lockToggled(locked)
            }
            onDetachRequested: function(globalX, globalY,
                                         pressOffsetX, pressOffsetY) {
                root.detachRequested(globalX, globalY,
                                     pressOffsetX, pressOffsetY)
            }
        }

        RowLayout {
            Layout.fillWidth: true
            spacing: 6

            AppButton {
                Layout.fillWidth: true
                text: "Все превышения"
                enabled: root.routeController !== null
                onClicked: root.routeController.showAllExceedances()
            }

            AppButton {
                text: "Показать все"
                enabled: root.routeController !== null
                onClicked: root.routeController.showAllNodes()
            }
        }

        ListView {
            id: routeList

            Layout.fillWidth: true
            Layout.fillHeight: true
            clip: true
            spacing: 1
            model: root.routeModel
            currentIndex: -1
            reuseItems: true

            delegate: RouteNodeDelegate {
                id: routeNodeDelegate

                width: Math.max(
                           0,
                           routeList.width
                           - (routeScrollBar.visible
                              ? routeScrollBar.width + 4 : 0))
                nodeKey: String(model.key || "")
                sourceNode: model.sourceNode
                selectedNode: root.selectedNodeKey.length > 0
                              && root.selectedNodeKey
                                 === routeNodeDelegate.nodeKey
                treeDepth: model.depth
                nodeExpanded: model.expanded
                nodeHasChildren: model.hasChildren
                nodeName: model.name
                nodeType: model.nodeType
                nodeState: model.state
                nodeStateColor: model.stateColor
                                && String(model.stateColor).length > 0
                                ? model.stateColor : "#788797"
                nodeHasExceedance: model.hasExceedance
                // Любой узел можно перенести на 3D-схему его ближайшего
                // родителя: точку на объект, объект на группу, группу на
                // вышестоящую группу.
                pointDragEnabled: root.routeNodeBelongsToSelectedModel(
                                      model.sourceNode)

                onExpansionRequested: root.toggleRouteNode(
                                          index,
                                          routeNodeDelegate.nodeKey,
                                          routeNodeDelegate.y)
                onNodeRequested: {
                    root.selectedNodeKey = routeNodeDelegate.nodeKey
                    routeList.currentIndex = index
                    if (root.routeController)
                        root.routeController.activate(index)

                    var row = root.routeModel ? root.routeModel.get(index) : null
                    // Тип узла нельзя определять ни по наличию детей,
                    // ни по наличию картинки у объекта.
                    if (row && root.nodeUsesObjectWorkspace(row.sourceNode))
                        root.object3DRequested()
                    else
                        root.normalWorkspaceRequested()
                }
            }

            ScrollBar.vertical: ScrollBar {
                id: routeScrollBar
                policy: ScrollBar.AsNeeded
            }

            Label {
                renderType: Text.NativeRendering
                anchors.centerIn: parent
                width: Math.max(0, parent.width - 30)
                visible: routeList.count === 0
                text: "Маршрут пока недоступен"
                color: "#526274"
                horizontalAlignment: Text.AlignHCenter
                wrapMode: Text.WordWrap
            }
        }

        Timer {
            id: routeViewportRestore

            property string anchorKey: ""
            property real anchorViewportY: 0
            property int remainingPasses: 0

            interval: 16
            repeat: false
            onTriggered: {
                routeList.forceLayout()

                var anchorIndex = root.visibleIndexByKey(anchorKey)
                if (anchorIndex < 0) {
                    remainingPasses = 0
                    return
                }

                routeList.positionViewAtIndex(anchorIndex, ListView.Beginning)
                routeList.forceLayout()

                var anchorItem = routeList.itemAtIndex(anchorIndex)
                if (!anchorItem) {
                    if (--remainingPasses > 0)
                        restart()
                    return
                }

                var firstY = routeList.originY
                var lastY = firstY + Math.max(
                            0, routeList.contentHeight - routeList.height)
                var targetY = anchorItem.y - anchorViewportY
                routeList.contentY = Math.max(
                            firstY, Math.min(targetY, lastY))

                if (--remainingPasses > 0)
                    restart()
            }
        }

        Label {
            renderType: Text.NativeRendering
            Layout.fillWidth: true
            text: root.routeController
                  ? root.routeController.statusMessage : ""
            color: root.routeModel && root.routeModel.hierarchyComplete
                   ? "#087A36" : "#934900"
            font.pixelSize: 11
            wrapMode: Text.WordWrap
        }

        AppButton {
            id: createDocumentButton

            hoverEnabled: enabled
            focusPolicy: Qt.NoFocus
            Layout.fillWidth: true
            Layout.preferredHeight: 42
            text: "Создать протокол"
            enabled: false
            Keys.enabled: false
            opacity: enabled ? 1.0 : 0.45
            font.bold: true
            font.pixelSize: 12
            contentItem: Text {
                renderType: Text.NativeRendering
                text: createDocumentButton.text
                color: "#FFFFFF"
                font: createDocumentButton.font
                horizontalAlignment: Text.AlignHCenter
                verticalAlignment: Text.AlignVCenter
            }

            background: Rectangle {
                radius: 5
                color: createDocumentButton.down
                       ? "#B85B00"
                       : createDocumentButton.enabled && createDocumentButton.hovered
                         ? "#C25F00" : "#D96C00"

                Behavior on color {
                    ColorAnimation {
                        duration: createDocumentButton.hoverAnimationDuration
                    }
                }
            }
        }
    }

}
