pragma ComponentBehavior: Bound
import QtQuick
import QtQuick.Controls
import QtQuick3D
import QtQuick3D.AssetUtils
import QtQuick3D.Helpers

Rectangle {
    id: root

    signal closeRequested()
    signal pointRequested(var pointNode)
    property var selectedNode: gtld.node
    property var routeModel: null
    readonly property string selectedNodeName:
        selectedNode
        ? String(selectedNode.name || "").trim()
        : ""
    readonly property string modelFileName:
        selectedNode
        ? String(selectedNode.model3DName || "").trim()
        : ""
    readonly property string modelFileExtension: {
        var dotIndex = modelFileName.lastIndexOf(".")
        return dotIndex >= 0
                ? modelFileName.substring(dotIndex + 1).toLowerCase() : ""
    }
    readonly property bool modelIs3D: modelFileExtension === "glb"
    readonly property bool modelIs2D:
        ["png", "jpg", "jpeg", "bmp", "webp", "svg"]
        .indexOf(modelFileExtension) >= 0
    readonly property bool modelFormatSupported: modelIs3D || modelIs2D
    readonly property bool modelEnabled:
        selectedNode && Boolean(selectedNode.scheme3DActive)
    readonly property bool modelFileEntered: modelFileName.length > 0
    property url modelSource: modelEnabled && modelFileName.length > 0
                              ? Qt.resolvedUrl("../../../media/" + modelFileName)
                              : ""
    property url activeModelSource: ""
    property url pendingModelSource: ""
    readonly property string selectedOwnerKey: nodeKey(selectedNode)
    readonly property bool pointPlacementEnabled:
        modelEnabled && modelFileEntered
        && ((modelIs3D
             && String(activeModelSource) === String(modelSource)
             && assetLoader.status === RuntimeLoader.Success)
            || (modelIs2D && schemeImage.status === Image.Ready))
    readonly property bool modelUnavailable:
        modelEnabled && modelFileEntered
        && (!modelFormatSupported
            || (modelIs3D
                && String(activeModelSource) === String(modelSource)
                && assetLoader.status === RuntimeLoader.Error)
            || (modelIs2D && schemeImage.status === Image.Error))
    readonly property bool modelLoading:
        modelEnabled && modelFileEntered && !modelUnavailable
        && ((modelIs3D
             && (String(activeModelSource) !== String(modelSource)
                 || assetLoader.status === RuntimeLoader.Empty))
            || (modelIs2D
                && (schemeImage.status === Image.Null
                    || schemeImage.status === Image.Loading)))
    readonly property bool modelSceneVisible:
        modelEnabled && modelFileEntered
        && ((modelIs3D
             && String(activeModelSource) === String(modelSource)
             && assetLoader.status === RuntimeLoader.Success)
            || (modelIs2D && schemeImage.status === Image.Ready))
    readonly property bool modelMessageVisible:
        !selectedNode || !modelEnabled || !modelFileEntered
        || modelUnavailable
    readonly property string modelMessage: {
        if (!selectedNode)
            return "Объект не выбран"
        if (!modelFileEntered)
            return "2D/3D-схема для объекта не задана"
        if (!modelEnabled)
            return "2D/3D-схема для объекта не задействована"
        if (!modelFormatSupported)
            return "Неподдерживаемый формат файла"
        if (modelUnavailable)
            return "Файл недоступен"
        return ""
    }

    color: "#F1F5F9"
    property string placementMessage: ""
    property int projectionRevision: 0
    property real modelDiameter: 100
    property var pinnedPointNodes: ({})
    property var restoredOwnerKeys: ({})
    property int markerVisibilityCursor: 0
    property bool markerDragActive: false
    function reloadModel() {
        if (!modelIs3D) {
            pendingModelSource = ""
            modelReloadTimer.stop()
            activeModelSource = ""
            return
        }
        var nextSource = String(modelSource)
        if (nextSource.length === 0) {
            pendingModelSource = ""
            modelReloadTimer.stop()
            activeModelSource = ""
            return
        }
        if (nextSource === String(activeModelSource)) {
            pendingModelSource = ""
            modelReloadTimer.stop()
            return
        }
        if (nextSource === String(pendingModelSource))
            return
        pendingModelSource = modelSource
        modelReloadTimer.restart()
    }

    function frameModel() {
        var minimum = assetLoader.bounds.minimum
        var maximum = assetLoader.bounds.maximum
        if (!isFinite(minimum.x) || !isFinite(minimum.y) || !isFinite(minimum.z)
                || !isFinite(maximum.x) || !isFinite(maximum.y)
                || !isFinite(maximum.z))
            return

        var sizeX = Math.abs(maximum.x - minimum.x)
        var sizeY = Math.abs(maximum.y - minimum.y)
        var sizeZ = Math.abs(maximum.z - minimum.z)
        var diameter = Math.max(sizeX, sizeY, sizeZ)
        if (!isFinite(diameter) || diameter <= 0)
            diameter = 100
        modelDiameter = diameter

        orbitOrigin.position = Qt.vector3d(
                    (minimum.x + maximum.x) / 2,
                    (minimum.y + maximum.y) / 2,
                    (minimum.z + maximum.z) / 2)
        sceneCamera.z = Math.max(10, diameter * 2.2)
        sceneCamera.clipNear = Math.max(0.01, diameter / 1000)
        sceneCamera.clipFar = Math.max(1000, diameter * 20)
    }

    function imageLeft() {
        return schemeImage.x + (schemeImage.width - schemeImage.paintedWidth) / 2
    }

    function imageTop() {
        return schemeImage.y + (schemeImage.height - schemeImage.paintedHeight) / 2
    }

    function pointInsideImage(viewX, viewY) {
        var left = imageLeft()
        var top = imageTop()
        return schemeImage.status === Image.Ready
                && viewX >= left && viewX <= left + schemeImage.paintedWidth
                && viewY >= top && viewY <= top + schemeImage.paintedHeight
    }

    function imagePointX(normalizedX) {
        return imageLeft() + Number(normalizedX) * schemeImage.paintedWidth
    }

    function imagePointY(normalizedY) {
        return imageTop() + Number(normalizedY) * schemeImage.paintedHeight
    }

    function makeModelsPickable(node) {
        if (!node)
            return

        if (node.pickable !== undefined)
            node.pickable = true

        var childNodes = node.children
        if (!childNodes)
            return

        for (var index = 0; index < childNodes.length; ++index)
            makeModelsPickable(childNodes[index])
    }

    function enableModelPicking() {
        view3D.setGlobalPickingEnabled(true)
        makeModelsPickable(assetLoader)
    }

    function nodeKey(node) {
        if (!node)
            return ""
        var value = node.uuid !== undefined ? node.uuid
                  : node.id !== undefined ? node.id
                  : node.nodeId !== undefined ? node.nodeId
                  : node.key !== undefined ? node.key : ""
        return value && typeof value.toString === "function"
                ? value.toString() : String(value || "")
    }

    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 nodeHas3DScheme(node) {
        return node
                && Boolean(node.scheme3DActive)
                && String(node.model3DName || "").trim().length > 0
    }

    function modelOwner(routeNode) {
        var current = parentNode(routeNode)
        while (current) {
            if (nodeHas3DScheme(current))
                return current
            current = parentNode(current)
        }
        return null
    }

    function routeNodeBelongsToSelectedModel(routeNode) {
        var owner = modelOwner(routeNode)
        return selectedOwnerKey.length > 0
                && nodeKey(owner) === selectedOwnerKey
    }

    function pinnedPointIndex(pointKey, ownerKey) {
        var wantedPointKey = canonicalPointKey(pointKey, null)
        for (var index = 0; index < pinnedPointsModel.count; ++index) {
            var marker = pinnedPointsModel.get(index)
            var markerPointKey = canonicalPointKey(marker.nodeKey, null)
            if (markerPointKey === wantedPointKey
                    && String(marker.ownerKey) === String(ownerKey)) {
                return index
            }
        }
        return -1
    }

    function pinnedPointNode(nodeKey, ownerKey) {
        var cacheKey = String(ownerKey) + "|" + String(nodeKey)
        var cachedNode = pinnedPointNodes[cacheKey] || null
        if (cachedNode)
            return cachedNode

        var routeNode = routeNodeByKey(nodeKey)
        if (routeNode)
            pinnedPointNodes[cacheKey] = routeNode
        return routeNode
    }

    function routeNodeByKey(key) {
        if (!routeModel)
            return null
        var rows = routeModel.allRows || []
        var wanted = String(key || "")
        for (var index = 0; index < rows.length; ++index) {
            var row = rows[index]
            if (!row)
                continue
            if (String(row.key || "") === wanted
                    || String(row.nodeId || "") === wanted)
                return row.sourceNode || null
        }
        return null
    }

    function canonicalPointKey(routeKey, routeNode) {
        // Row keys include the full tree path so one source node can appear in
        // every branch. A marker represents the source node itself and must
        // therefore use its stable UUID, independently of the dragged branch.
        var sourceNode = routeNode || routeNodeByKey(routeKey)
        var sourceKey = nodeKey(sourceNode)
        return sourceKey.length > 0 ? sourceKey : String(routeKey || "")
    }

    function ownerNodeByKey(ownerKey) {
        var wanted = String(ownerKey || "")
        if (nodeKey(selectedNode) === wanted)
            return selectedNode
        return routeNodeByKey(wanted)
    }

    function savePinnedPointsForOwner(ownerKey, knownOwnerNode) {
        var wantedOwnerKey = String(ownerKey || "")
        var ownerNode = knownOwnerNode || ownerNodeByKey(wantedOwnerKey)
        if (!ownerNode || wantedOwnerKey.length === 0)
            return false

        var placements = []
        for (var index = 0; index < pinnedPointsModel.count; ++index) {
            var marker = pinnedPointsModel.get(index)
            if (String(marker.ownerKey) !== wantedOwnerKey)
                continue
            placements.push({
                "nodeKey": String(marker.nodeKey),
                "label": String(marker.label || ""),
                "sceneX": Number(marker.sceneX),
                "sceneY": Number(marker.sceneY),
                "sceneZ": Number(marker.sceneZ)
            })
        }

        if (typeof ownerNode.set3DSchemePointPlacements === "function")
            ownerNode.set3DSchemePointPlacements(placements)
        else if (ownerNode.scheme3DPointPlacements !== undefined)
            ownerNode.scheme3DPointPlacements = placements
        else
            return false
        return true
    }

    function restorePinnedPointsForOwner(ownerNode) {
        var ownerKey = nodeKey(ownerNode)
        if (!ownerNode || ownerKey.length === 0
                || restoredOwnerKeys[ownerKey])
            return

        if (!routeModel || !(routeModel.allRows || []).length)
            return

        var placements = ownerNode.scheme3DPointPlacements
        restoredOwnerKeys[ownerKey] = true
        if (!placements || placements.length === undefined)
            return

        var normalized = false
        for (var index = 0; index < placements.length; ++index) {
            var placement = placements[index]
            if (!placement)
                continue

            var storedPointKey = String(placement.nodeKey || "")
            var sceneX = Number(placement.sceneX)
            var sceneY = Number(placement.sceneY)
            var sceneZ = Number(placement.sceneZ)
            if (storedPointKey.length === 0 || !isFinite(sceneX)
                    || !isFinite(sceneY) || !isFinite(sceneZ))
                continue

            var routeNode = routeNodeByKey(storedPointKey)
            if (!routeNode
                    || nodeKey(modelOwner(routeNode)) !== ownerKey)
                continue
            var pointKey = canonicalPointKey(storedPointKey, routeNode)
            if (pointKey !== storedPointKey)
                normalized = true
            if (pinnedPointIndex(pointKey, ownerKey) >= 0) {
                normalized = true
                continue
            }

            var label = String(placement.label || routeNode.name || pointKey)
            var pointState = routeStateForNode(pointKey)
            pinnedPointNodes[ownerKey + "|" + pointKey] = routeNode
            pinnedPointsModel.append({
                "nodeKey": pointKey,
                "ownerKey": ownerKey,
                "label": label,
                "sceneX": sceneX,
                "sceneY": sceneY,
                "sceneZ": sceneZ,
                "surfaceVisible": true,
                "stateColor": pointState.color,
                "stateText": pointState.state,
                "statePriority": pointState.priority,
                "stateKnown": pointState.known,
                "hasExceedance": pointState.hasExceedance
            })
        }
        refreshPinnedPointStates()
        if (normalized)
            savePinnedPointsForOwner(ownerKey, ownerNode)
    }

    function restoreSelectedOwnerPoints() {
        restorePinnedPointsForOwner(selectedNode)
    }

    function routeStateForNode(nodeKey) {
        var fallback = {
            color: "#788797",
            state: "Нет данных",
            priority: NaN,
            hasExceedance: false,
            known: false
        }
        if (!routeModel)
            return fallback
        var rows = routeModel.allRows || []
        var wanted = String(nodeKey || "")
        for (var index = 0; index < rows.length; ++index) {
            var row = rows[index]
            if (!row || (String(row.nodeId || "") !== wanted
                    && String(row.key || "") !== wanted))
                continue
            var known = Boolean(row.exceedanceKnown)
            return {
                color: known && String(row.stateColor || "").length > 0
                       ? String(row.stateColor) : "#788797",
                state: known && String(row.state || "").length > 0
                       ? String(row.state) : "Нет данных",
                priority: known ? Number(row.statePriority) : NaN,
                hasExceedance: known
                               && Boolean(row.hasExceedance),
                known: known
            }
        }
        return fallback
    }

    function refreshPinnedPointStates() {
        for (var index = 0; index < pinnedPointsModel.count; ++index) {
            var marker = pinnedPointsModel.get(index)
            var state = routeStateForNode(marker.nodeKey)
            if (String(marker.stateColor) !== String(state.color))
                pinnedPointsModel.setProperty(index, "stateColor",
                                              state.color)
            if (String(marker.stateText) !== String(state.state))
                pinnedPointsModel.setProperty(index, "stateText",
                                              state.state)
            if (Boolean(marker.stateKnown) !== Boolean(state.known))
                pinnedPointsModel.setProperty(index, "stateKnown",
                                              state.known)
            if (Boolean(marker.hasExceedance)
                    !== Boolean(state.hasExceedance)) {
                pinnedPointsModel.setProperty(index, "hasExceedance",
                                              state.hasExceedance)
            }
            var oldPriority = Number(marker.statePriority)
            var newPriority = Number(state.priority)
            if ((isNaN(oldPriority) && !isNaN(newPriority))
                    || (!isNaN(oldPriority) && isNaN(newPriority))
                    || oldPriority !== newPriority) {
                pinnedPointsModel.setProperty(index, "statePriority",
                                              newPriority)
            }
        }
    }

    function removePinnedPoint(nodeKey, ownerKey, label) {
        var markerIndex = pinnedPointIndex(nodeKey, ownerKey)
        if (markerIndex < 0)
            return false
        var ownerNode = ownerNodeByKey(ownerKey)
        pinnedPointsModel.remove(markerIndex)
        delete pinnedPointNodes[String(ownerKey) + "|" + String(nodeKey)]
        savePinnedPointsForOwner(ownerKey, ownerNode)
        markerVisibilityCursor = pinnedPointsModel.count > 0
                ? markerVisibilityCursor % pinnedPointsModel.count : 0
        showPlacementMessage("Узел «" + String(label || "")
                             + "» удалён с модели")
        return true
    }

    function showPlacementMessage(message) {
        placementMessage = message
        placementMessageTimer.restart()
    }

    function markerSurfaceVisible(sceneX, sceneY, sceneZ,
                                  screenX, screenY, screenZ) {
        if (screenZ <= 0.0001
                || screenX < 0 || screenX > width
                || screenY < 0 || screenY > height) {
            return false
        }

        var frontHit = view3D.pick(screenX, screenY)
        if (!frontHit || !frontHit.objectHit)
            return false

        // RuntimeLoader returns a reliable local triangle position in Qt 6.7.
        // qmllint disable missing-property
        var frontPosition = frontHit.objectHit.mapPositionToScene(
                    frontHit.position)
        // qmllint enable missing-property
        var markerPosition = Qt.vector3d(sceneX, sceneY, sceneZ)
        var cameraPosition = sceneCamera.scenePosition
        var frontDistance = frontPosition.minus(cameraPosition).length()
        var markerDistance = markerPosition.minus(cameraPosition).length()
        var tolerance = Math.max(0.01, modelDiameter * 0.001)
        return markerDistance <= frontDistance + tolerance
    }

    function pinRouteNode(nodeKey, label, ownerKey, routeNode, viewX, viewY) {
        var pointKey = canonicalPointKey(nodeKey, routeNode)
        var scenePosition
        if (modelIs2D) {
            if (!pointInsideImage(viewX, viewY)) {
                showPlacementMessage("Перетащите узел на изображение схемы")
                return false
            }
            scenePosition = Qt.vector3d(
                        (viewX - imageLeft()) / schemeImage.paintedWidth,
                        (viewY - imageTop()) / schemeImage.paintedHeight,
                        0)
        } else {
            var hit = view3D.pick(viewX, viewY)
            if (!hit || !hit.objectHit) {
                showPlacementMessage(
                            "Перетащите узел на поверхность 3D-модели")
                return false
            }

            // qmllint disable missing-property
            scenePosition = hit.objectHit.mapPositionToScene(hit.position)
            // qmllint enable missing-property
        }
        var markerIndex = pinnedPointIndex(pointKey, ownerKey)
        var pointState = routeStateForNode(pointKey)
        pinnedPointNodes[String(ownerKey) + "|" + pointKey] = routeNode
        if (markerIndex < 0) {
            pinnedPointsModel.append({
                "nodeKey": pointKey,
                "ownerKey": String(ownerKey),
                "label": String(label),
                "sceneX": scenePosition.x,
                "sceneY": scenePosition.y,
                "sceneZ": scenePosition.z,
                "surfaceVisible": true,
                "stateColor": pointState.color,
                "stateText": pointState.state,
                "statePriority": pointState.priority,
                "stateKnown": pointState.known,
                "hasExceedance": pointState.hasExceedance
            })
        } else {
            var previousPointKey = String(
                        pinnedPointsModel.get(markerIndex).nodeKey || "")
            if (previousPointKey !== pointKey) {
                delete pinnedPointNodes[String(ownerKey) + "|"
                                        + previousPointKey]
                pinnedPointsModel.setProperty(markerIndex, "nodeKey",
                                              pointKey)
            }
            pinnedPointsModel.setProperty(markerIndex, "label", String(label))
            pinnedPointsModel.setProperty(markerIndex, "sceneX", scenePosition.x)
            pinnedPointsModel.setProperty(markerIndex, "sceneY", scenePosition.y)
            pinnedPointsModel.setProperty(markerIndex, "sceneZ", scenePosition.z)
            pinnedPointsModel.setProperty(markerIndex, "surfaceVisible", true)
            pinnedPointsModel.setProperty(markerIndex, "stateColor",
                                          pointState.color)
            pinnedPointsModel.setProperty(markerIndex, "stateText",
                                          pointState.state)
            pinnedPointsModel.setProperty(markerIndex, "statePriority",
                                          pointState.priority)
            pinnedPointsModel.setProperty(markerIndex, "stateKnown",
                                          pointState.known)
            pinnedPointsModel.setProperty(markerIndex, "hasExceedance",
                                          pointState.hasExceedance)
        }

        var ownerNode = modelOwner(routeNode)
        if (!ownerNode && nodeKey(selectedNode) === String(ownerKey))
            ownerNode = selectedNode
        var saved = savePinnedPointsForOwner(ownerKey, ownerNode)
        showPlacementMessage(saved
                             ? "Узел «" + label + "» "
                               + (markerIndex < 0
                                  ? "закреплён" : "перемещён")
                             : "Не удалось сохранить положение узла «"
                               + label + "». Обновите gtld.dll")
        return true
    }

    function refreshMarkerVisibilityBatch() {
        var count = pinnedPointsModel.count
        if (count <= 0 || !pointPlacementEnabled)
            return
        if (modelIs2D)
            return

        // Keep ray casting bounded regardless of the number of pinned points.
        // Three picks per tick are enough for responsive occlusion updates
        // without N independent timers continuously loading the GUI thread.
        var batchSize = Math.min(3, count)
        for (var batchIndex = 0; batchIndex < batchSize; ++batchIndex) {
            var markerIndex = markerVisibilityCursor % count
            var marker = pinnedPointsModel.get(markerIndex)
            var screenPoint = view3D.mapFrom3DScene(Qt.vector3d(
                            Number(marker.sceneX), Number(marker.sceneY),
                            Number(marker.sceneZ)))
            var isVisible = markerSurfaceVisible(
                        Number(marker.sceneX), Number(marker.sceneY),
                        Number(marker.sceneZ), screenPoint.x,
                        screenPoint.y, screenPoint.z)
            if (Boolean(marker.surfaceVisible) !== isVisible)
                pinnedPointsModel.setProperty(markerIndex,
                                              "surfaceVisible", isVisible)
            markerVisibilityCursor = (markerIndex + 1) % count
        }
    }

    ListModel {
        id: pinnedPointsModel
    }

    Connections {
        target: root.routeModel
        ignoreUnknownSignals: true

        function onDataChanged() {
            root.refreshPinnedPointStates()
        }

        function onCountChanged() {
            root.refreshPinnedPointStates()
            Qt.callLater(root.restoreSelectedOwnerPoints)
        }

        function onModelReset() {
            root.refreshPinnedPointStates()
            Qt.callLater(root.restoreSelectedOwnerPoints)
        }

        function onAllRowsChanged() {
            root.refreshPinnedPointStates()
            Qt.callLater(root.restoreSelectedOwnerPoints)
        }
    }

    onRouteModelChanged: {
        refreshPinnedPointStates()
        Qt.callLater(restoreSelectedOwnerPoints)
    }
    onSelectedOwnerKeyChanged: Qt.callLater(restoreSelectedOwnerPoints)

    Image {
        id: schemeImage

        anchors.fill: parent
        anchors.margins: 24
        source: root.modelEnabled && root.modelIs2D
                ? root.modelSource : ""
        fillMode: Image.PreserveAspectFit
        asynchronous: true
        cache: true
        smooth: true
        mipmap: true
        visible: root.modelIs2D && root.modelSceneVisible
    }

    View3D {
        id: view3D

        anchors.fill: parent
        visible: root.modelIs3D && root.modelSceneVisible

        environment: SceneEnvironment {
            backgroundMode: SceneEnvironment.Color
            clearColor: "#F1F5F9"
            antialiasingMode: SceneEnvironment.MSAA
            antialiasingQuality: SceneEnvironment.High
        }

        Node {
            id: orbitOrigin

            PerspectiveCamera {
                id: sceneCamera
                z: 500
            }
        }

        DirectionalLight {
            eulerRotation.x: -35
            eulerRotation.y: -35
            brightness: 1.2
            castsShadow: true
        }

        DirectionalLight {
            eulerRotation.x: 145
            eulerRotation.y: 35
            brightness: 0.55
        }

        RuntimeLoader {
            id: assetLoader
            source: root.modelIs3D ? root.activeModelSource : ""
            onBoundsChanged: {
                if (status === RuntimeLoader.Success)
                    root.frameModel()
            }
            onStatusChanged: {
                if (status === RuntimeLoader.Success) {
                    Qt.callLater(root.frameModel)
                    delayedFrameTimer.restart()
                    Qt.callLater(root.enableModelPicking)
                }
            }
        }

        camera: sceneCamera
    }

    OrbitCameraController {
        anchors.fill: parent
        origin: orbitOrigin
        camera: sceneCamera
        enabled: root.modelIs3D && root.modelSceneVisible
    }

    DropArea {
        id: pointDropArea

        anchors.fill: parent
        z: 30
        enabled: root.pointPlacementEnabled
        keys: ["vibro-route-node", "vibro-route-point"]

        onDropped: function(drop) {
            if (!drop.source)
                return
            // qmllint disable missing-property
            var routeNodeKey = drop.source.draggedNodeKey
            var routeNodeName = drop.source.draggedNodeName
            var routeNode = drop.source.draggedNode
            // qmllint enable missing-property
            if (!root.routeNodeBelongsToSelectedModel(routeNode)) {
                root.showPlacementMessage(
                            "Этот узел принадлежит другой схеме")
                return
            }
            if (root.pinRouteNode(routeNodeKey, routeNodeName,
                                  root.selectedOwnerKey, routeNode,
                                  drop.x, drop.y)) {
                drop.acceptProposedAction()
            }
        }

        Rectangle {
            anchors.fill: parent
            visible: pointDropArea.containsDrag
            color: "transparent"
            border.width: 3
            border.color: "#005FCC"
        }
    }

    Repeater {
        model: pinnedPointsModel

        delegate: Item {
            id: pointMarker

            required property string nodeKey
            required property string ownerKey
            required property string label
            required property real sceneX
            required property real sceneY
            required property real sceneZ
            required property bool surfaceVisible
            required property color stateColor
            required property string stateText
            required property real statePriority
            required property bool stateKnown
            required property bool hasExceedance
            required property int projectionRevision

            required property View3D sceneView
            required property Rectangle workspace
            readonly property vector3d screenPoint3D:
                pointMarker.projectionRevision,
                pointMarker.sceneView.mapFrom3DScene(
                    Qt.vector3d(sceneX, sceneY, sceneZ))
            readonly property point screenPoint2D: Qt.point(
                root.imagePointX(sceneX), root.imagePointY(sceneY))
            property bool dragging: false
            property bool movedDuringPress: false
            property real dragItemX: 0
            property real dragItemY: 0

            z: 40
            x: dragging ? dragItemX
                        : (root.modelIs2D
                           ? screenPoint2D.x : screenPoint3D.x) - 7
            y: dragging ? dragItemY
                        : (root.modelIs2D
                           ? screenPoint2D.y : screenPoint3D.y) - 7
            width: Math.min(239, markerLabel.implicitWidth + 37)
            height: 32
            visible: root.pointPlacementEnabled
                     && ownerKey === root.selectedOwnerKey
                     && (root.modelIs2D
                         ? root.pointInsideImage(screenPoint2D.x,
                                                 screenPoint2D.y)
                         : screenPoint3D.z > 0.0001
                           && screenPoint3D.x >= 0
                           && screenPoint3D.x <= workspace.width
                           && screenPoint3D.y >= 0
                           && screenPoint3D.y <= workspace.height
                           && surfaceVisible)

            Rectangle {
                width: 14
                height: 14
                radius: 7
                color: pointMarker.stateKnown
                       ? pointMarker.stateColor : "#788797"
                border.width: 2
                border.color: "#FFFFFF"
            }

            Rectangle {
                x: 19
                y: -7
                width: Math.min(220, markerLabel.implicitWidth + 18)
                height: 28
                radius: 6
                color: "#EFFFFFFF"
                border.width: 1
                border.color: "#788797"

                Text {
                    renderType: Text.NativeRendering
                    id: markerLabel
                    anchors.fill: parent
                    anchors.leftMargin: 9
                    anchors.rightMargin: 9
                    text: pointMarker.label
                    color: "#111827"
                    verticalAlignment: Text.AlignVCenter
                    elide: Text.ElideRight
                }
            }

            MouseArea {
                id: markerDragArea

                x: 0
                y: -7
                width: parent.width
                height: 28
                acceptedButtons: Qt.LeftButton | Qt.RightButton
                cursorShape: Qt.PointingHandCursor
                preventStealing: true

                property int activeButton: Qt.NoButton

                property real pressWorkspaceX: 0
                property real pressWorkspaceY: 0
                property real pressOffsetX: 0
                property real pressOffsetY: 0

                onPressed: function(mouse) {
                    activeButton = mouse.button
                    if (mouse.button === Qt.RightButton) {
                        mouse.accepted = true
                        return
                    }
                    var workspacePosition = pointMarker.mapToItem(
                                root, mouse.x, mouse.y)
                    pressWorkspaceX = workspacePosition.x
                    pressWorkspaceY = workspacePosition.y
                    pressOffsetX = mouse.x
                    pressOffsetY = mouse.y
                    pointMarker.dragItemX = pointMarker.x
                    pointMarker.dragItemY = pointMarker.y
                    pointMarker.movedDuringPress = false
                    mouse.accepted = true
                }

                onPositionChanged: function(mouse) {
                    if (!pressed || activeButton !== Qt.LeftButton)
                        return
                    var workspacePosition = pointMarker.mapToItem(
                                root, mouse.x, mouse.y)
                    var deltaX = workspacePosition.x - pressWorkspaceX
                    var deltaY = workspacePosition.y - pressWorkspaceY
                    if (!pointMarker.movedDuringPress
                            && Math.sqrt(deltaX * deltaX + deltaY * deltaY) < 5) {
                        return
                    }
                    if (!pointMarker.dragging) {
                        pointMarker.dragging = true
                        pointMarker.movedDuringPress = true
                        root.markerDragActive = true
                    }
                    pointMarker.dragItemX = workspacePosition.x - pressOffsetX
                    pointMarker.dragItemY = workspacePosition.y - pressOffsetY
                }

                onReleased: function(mouse) {
                    if (mouse.button !== Qt.LeftButton) {
                        activeButton = Qt.NoButton
                        return
                    }
                    if (!pointMarker.movedDuringPress) {
                        activeButton = Qt.NoButton
                        return
                    }

                    // Place the centre of the circular marker on the model,
                    // regardless of whether dragging started on the circle or
                    // on its text label.
                    var modelX = pointMarker.dragItemX + 7
                    var modelY = pointMarker.dragItemY + 7
                    var pointNode = root.pinnedPointNode(
                                pointMarker.nodeKey, pointMarker.ownerKey)
                    root.pinRouteNode(pointMarker.nodeKey,
                                      pointMarker.label,
                                      pointMarker.ownerKey, pointNode,
                                      modelX, modelY)
                    pointMarker.dragging = false
                    root.markerDragActive = false
                    activeButton = Qt.NoButton
                    mouse.accepted = true
                }

                onCanceled: {
                    pointMarker.dragging = false
                    root.markerDragActive = false
                    activeButton = Qt.NoButton
                }

                onClicked: function(mouse) {
                    if (mouse.button === Qt.RightButton) {
                        var menuPosition = pointMarker.mapToItem(
                                    root, mouse.x, mouse.y)
                        pointContextMenu.targetNodeKey =
                                pointMarker.nodeKey
                        pointContextMenu.targetOwnerKey =
                                pointMarker.ownerKey
                        pointContextMenu.targetLabel =
                                pointMarker.label
                        pointContextMenu.popup(
                                    Math.round(menuPosition.x),
                                    Math.round(menuPosition.y))
                        return
                    }
                    if (pointMarker.movedDuringPress)
                        return
                    var pointNode = root.pinnedPointNode(
                                pointMarker.nodeKey, pointMarker.ownerKey)
                    if (pointNode)
                        root.pointRequested(pointNode)
                }
            }

            sceneView: view3D
            workspace: root
            projectionRevision: root.projectionRevision
        }
    }

    Menu {
        id: pointContextMenu

        property string targetNodeKey: ""
        property string targetOwnerKey: ""
        property string targetLabel: ""

        z: 1000
        width: 224
        topPadding: 5
        bottomPadding: 5

        background: Rectangle {
            color: "#FFFFFF"
            border.width: 1
            border.color: "#9AA8B7"
            radius: 6
        }

        MenuItem {
            id: deletePointMenuItem

            text: "Удалить с модели"
            height: 36

            contentItem: Text {
                renderType: Text.NativeRendering
                anchors.fill: parent
                anchors.leftMargin: 8
                text: deletePointMenuItem.text
                color: "#B91C1C"
                font.pixelSize: 12
                verticalAlignment: Text.AlignVCenter
            }

            background: Rectangle {
                color: deletePointMenuItem.highlighted
                       ? "#FEF2F2" : "transparent"
                radius: 4
            }

            onTriggered: root.removePinnedPoint(
                             pointContextMenu.targetNodeKey,
                             pointContextMenu.targetOwnerKey,
                             pointContextMenu.targetLabel)
        }
    }

    Rectangle {
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.bottom: parent.bottom
        anchors.bottomMargin: 18
        width: Math.min(parent.width - 36, helpLabel.implicitWidth + 28)
        height: 36
        radius: 18
        color: "#CC0F172A"
        visible: root.pointPlacementEnabled

        Label {
            renderType: Text.NativeRendering
            id: helpLabel
            anchors.centerIn: parent
            text: root.modelIs2D
                  ? "Перетащите дочерний узел из маршрута или перемещайте метку · "
                    + "ПКМ по метке — удалить"
                  : "Перетащите дочерний узел из маршрута или перемещайте метку · "
                    + "ПКМ по метке — удалить · ЛКМ — вращение · "
                    + "колёсико — масштаб"
            color: "#E2E8F0"
            font.pixelSize: 12
            elide: Text.ElideRight
            width: parent.width - 28
            horizontalAlignment: Text.AlignHCenter
        }
    }

    Rectangle {
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.top: parent.top
        anchors.topMargin: 18
        width: Math.min(parent.width - 40,
                        placementMessageLabel.implicitWidth + 28)
        height: 38
        radius: 19
        color: "#EFFFFFFF"
        border.width: 1
        border.color: "#788797"
        visible: root.placementMessage.length > 0
        z: 60

        Label {
            renderType: Text.NativeRendering
            id: placementMessageLabel
            anchors.centerIn: parent
            text: root.placementMessage
            color: "#111827"
        }
    }

    Timer {
        id: placementMessageTimer
        interval: 2400
        repeat: false
        onTriggered: root.placementMessage = ""
    }

    Timer {
        interval: 33
        repeat: true
        running: root.visible && root.modelIs3D
                 && pinnedPointsModel.count > 0
        onTriggered: root.projectionRevision =
                         (root.projectionRevision + 1) % 1000000
    }

    Timer {
        interval: 75
        repeat: true
        running: root.visible && root.pointPlacementEnabled
                 && !root.markerDragActive
                 && pinnedPointsModel.count > 0
        triggeredOnStart: true
        onTriggered: root.refreshMarkerVisibilityBatch()
    }

    Rectangle {
        anchors.fill: parent
        color: "#FFFFFF"
        visible: root.modelMessageVisible || root.modelLoading
        z: 50
    }

    Column {
        anchors.centerIn: parent
        width: Math.max(0, Math.min(parent.width - 80, 900))
        spacing: 14
        visible: root.modelMessageVisible
        z: 60

        Label {
            renderType: Text.NativeRendering
            width: parent.width
            text: root.selectedNodeName.length > 0
                  ? root.selectedNodeName : root.modelMessage
            color: "#1F2937"
            font.pixelSize: Math.max(28, Math.min(52, root.width / 18))
            font.weight: Font.DemiBold
            wrapMode: Text.WordWrap
            horizontalAlignment: Text.AlignHCenter
            verticalAlignment: Text.AlignVCenter
        }

        Label {
            renderType: Text.NativeRendering
            width: parent.width
            visible: root.selectedNodeName.length > 0
            text: root.modelMessage
            color: "#64748B"
            font.pixelSize: 15
            wrapMode: Text.WordWrap
            horizontalAlignment: Text.AlignHCenter
        }
    }

    BusyIndicator {
        anchors.centerIn: parent
        width: 64
        height: 64
        running: root.modelLoading
        visible: running
        z: 60
    }

    Label {
        renderType: Text.NativeRendering
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.top: parent.verticalCenter
        anchors.topMargin: 42
        visible: root.modelLoading
        text: root.modelIs2D ? "Загрузка изображения…"
                             : "Загрузка 3D-модели…"
        color: "#405164"
        z: 60
    }

    Timer {
        id: modelReloadTimer

        // Debounce rapid route selection changes and load only the last model.
        interval: 60
        repeat: false
        onTriggered: {
            var nextSource = root.pendingModelSource
            root.pendingModelSource = ""
            if (String(root.activeModelSource) !== String(nextSource))
                root.activeModelSource = nextSource
        }
    }

    Timer {
        id: delayedFrameTimer

        interval: 180
        repeat: false
        onTriggered: {
            if (assetLoader.status === RuntimeLoader.Success) {
                root.frameModel()
                root.enableModelPicking()
            }
        }
    }

    onModelSourceChanged: reloadModel()
    Component.onCompleted: {
        reloadModel()
        Qt.callLater(restoreSelectedOwnerPoints)
    }

    Shortcut {
        sequence: "Escape"
        onActivated: root.closeRequested()
    }
}
