import QtQml
import QtQuick
import QtQuick.Controls
import QtQuick.Layouts
import QtQuick.Window

import "adapters"
import "analysis"
import "charts"
import "controllers"
import "docking"
import "models"
import "style"
import "views"
import "windows"

Item {
    id: root

    property string densityMode: "normal"
    property alias workspaceDockLayoutObject: workspaceDockLayout
    property alias routeWindowObject: routeWindow
    property alias recordsWindowObject: recordsWindow
    property alias spectrumWindowObject: spectrumWindow
    property alias trendWindowObject: trendWindow
    property alias signalWindowObject: signalWindow
    property alias markersPanelWindowObject: markersPanelWindow
    property alias periodResultsWindowObject: periodResultsWindow
    property alias markersWindowObject: markersWindow
    property alias shortcutsHelpObject: shortcutsHelp

    WorkspaceController {
        id: workspaceController
        view: root
    }
    readonly property bool compactMode: densityMode === "compact"

    anchors.fill: parent
    focus: true

    signal gameSelected(string gameId)

    property var normalizedMasterValues: []
    property bool gamesMenuVisible: false
    property string lastGtldRefreshKey: ""
    property bool routeDetached: false
    property bool periodDetached: false
    property bool recordsDetached: false
    property bool spectrumDetached: false
    property bool trendsDetached: false
    property bool signalDetached: false
    property bool markersPanelDetached: false
    property bool object3DActive: false
    property bool object3DInitialized: false
    property var object3DSelectedNode: null
    property var panelLocks: ({
        "route": false,
        "records": false,
        "spectrum": false,
        "trends": false,
        "signal": false,
        "markers": false
    })
    property var workspaceDockTreeBefore3D: null
    readonly property bool pointPlacementEnabled:
        object3DActive && object3DWorkspaceLoader.item
        && Boolean(object3DWorkspaceLoader.item.pointPlacementEnabled)
    readonly property bool pointPanelShortcutsEnabled:
        !object3DActive && recordsController.pointNodeSelected
    property var savedDockPlacements: ({})
    property var detachedDockOrder: []
    property string toolbarClosingPanel: ""
    property int recordChartWindowSequence: 0
    readonly property var sharedGtldAdapter: gtldAdapter
    readonly property var sharedResultAdapter: resultAdapter

    readonly property bool allWorkspaceDetached: routeDetached && recordsDetached && spectrumDetached && trendsDetached && signalDetached && markersPanelDetached
    property var comparisonSpectrumRequestId: null
    property var activeSignalPreviewRequestId: null
    property var activeSpectrumPreviewRequestId: null

    function panelLocked(panelName) {
        return Boolean(panelLocks && panelLocks[String(panelName)])
    }

    function setPanelLocked(panelName, locked) {
        var updated = ({})
        var key = ""
        for (key in panelLocks)
            updated[key] = Boolean(panelLocks[key])
        updated[String(panelName)] = Boolean(locked)
        panelLocks = updated
    }
    readonly property var defaultWorkspaceDockTree: ({
            "type": "split",
            "orientation": Qt.Horizontal,
            "ratio": 0.15,
            "first": {
                "type": "panel",
                "panel": "route"
            },
            "second": {
                "type": "split",
                "orientation": Qt.Horizontal,
                "ratio": 0.2,
                "first": {
                    "type": "panel",
                    "panel": "records"
                },
                "second": {
                    "type": "split",
                    "orientation": Qt.Horizontal,
                    "ratio": 0.78,
                    "first": {
                        "type": "split",
                        "orientation": Qt.Vertical,
                        "ratio": 0.34,
                        "first": {
                            "type": "panel",
                            "panel": "spectrum"
                        },
                        "second": {
                            "type": "split",
                            "orientation": Qt.Vertical,
                            "ratio": 0.5,
                            "first": {
                                "type": "panel",
                                "panel": "trends"
                            },
                            "second": {
                                "type": "panel",
                                "panel": "signal"
                            }
                        }
                    },
                    "second": {
                        "type": "panel",
                        "panel": "markers"
                    }
                }
            }
        })
    property var workspaceDockTree: null
    property var chartPanelSizes: ({
            "spectrum": {
                "width": 640,
                "height": 260
            },
            "trends": {
                "width": 640,
                "height": 260
            },
            "signal": {
                "width": 640,
                "height": 260
            }
        })
    property bool dockDropPreviewVisible: false
    property string dockDropPanel: ""
    property int dockDropOrientation: Qt.Vertical
    property string dockDropTargetPanel: ""
    property bool dockDropBefore: true
    property real dockDropTargetWidth: 1
    property real dockDropTargetHeight: 1
    property real dockDropX: 0
    property real dockDropY: 0
    property real dockDropWidth: 0
    property real dockDropHeight: 0

    function openGamesMenu() {
        gamesMenuVisible = true
        gamesMenu.openMenu()

        var hostWindow = root.Window.window
        if (hostWindow) {
            hostWindow.show()
            hostWindow.raise()
            hostWindow.requestActivate()
        }
    }

    function closeGamesMenu() {
        gamesMenuVisible = false
        forceActiveFocus()
    }

    function toggleGamesMenu() {
        if (gamesMenuVisible)
            closeGamesMenu()
        else
            openGamesMenu()
    }

    function object3DLayoutTree() {
        var content = {
            "type": "panel",
            "panel": "object3d"
        };
        if (!routeDetached) {
            content = {
                "type": "split",
                "orientation": Qt.Horizontal,
                "ratio": 0.15,
                "first": {
                    "type": "panel",
                    "panel": "route"
                },
                "second": content
            };
        }
        return content;
    }

    function showObject3DWorkspace() {
        var nextNode = selectionController.selectedNode || gtld.node;
        if (nextNode)
            object3DSelectedNode = nextNode;
        if (object3DActive)
            return;
        object3DInitialized = true;
        workspaceDockTreeBefore3D = workspaceDockTree;
        object3DActive = true;
        workspaceDockTree = object3DLayoutTree();
    }

    function hideObject3DWorkspace() {
        if (!object3DActive)
            return;
        var previousTree = workspaceDockTreeBefore3D;
        object3DActive = false;
        workspaceDockTreeBefore3D = null;
        workspaceDockTree = previousTree;
    }

    function openPointWorkspace(node) {
        if (!recordsController.isPointNode(node))
            return;

        if (object3DActive)
            hideObject3DWorkspace();

        var panels = [
            "route", "records", "spectrum",
            "trends", "signal", "markers"
        ];
        for (var index = 0; index < panels.length; ++index)
            openWorkspacePanel(panels[index]);
    }

    function previewBelongsToSelectedRecord(sourceResult) {
        var selected = analysisController.selectedRecord;
        if (!selected || !sourceResult)
            return false;
        if (selected.rawResult === sourceResult)
            return true;
        return String(selected.key || "") === String(resultAdapter.resultKey(sourceResult, selected.pointName || ""));
    }

    function cancelActivePreviewRequests() {
        gtldAdapter.cancelPreview("signal",
                                  activeSignalPreviewRequestId);
        gtldAdapter.cancelPreview("spectrum",
                                  activeSpectrumPreviewRequestId);
        gtldAdapter.cancelPreview("spectrum",
                                  comparisonSpectrumRequestId);
        activeSignalPreviewRequestId = null;
        activeSpectrumPreviewRequestId = null;
        comparisonSpectrumRequestId = null;
    }

    ApplicationStyle {
        id: applicationStyle
        densityMode: root.densityMode
    }

    GtldAdapter {
        id: gtldAdapter
    }

    ResultAdapter {
        id: resultAdapter
        masterValuesAdapter: masterValuesAdapter
    }

    MasterValuesAdapter {
        id: masterValuesAdapter
    }

    RouteAdapter {
        id: routeAdapter
    }

    RouteTreeModel {
        id: routeTreeModel
    }

    RecordsModel {
        id: recordsModel
    }

    BandMarkersModel {
        id: bandMarkersModel
    }

    HarmonicMarkersModel {
        id: harmonicMarkersModel
    }

    SelectionController {
        id: selectionController
    }

    RouteController {
        id: routeController
        gtldAdapter: gtldAdapter
        routeAdapter: routeAdapter
        masterValuesAdapter: masterValuesAdapter
        selectionController: selectionController
        model: routeTreeModel
    }

    RecordsController {
        id: recordsController
        gtldAdapter: gtldAdapter
        resultAdapter: resultAdapter
        selectionController: selectionController
        model: recordsModel
    }

    AnalysisController {
        id: analysisController
        resultAdapter: resultAdapter
        bandModel: bandMarkersModel
        harmonicModel: harmonicMarkersModel
        selectedResultTag: recordsController.resultTag
    }

    TrendController {
        id: trendController
        recordsModel: recordsModel
        recordsController: recordsController
        resultAdapter: resultAdapter
    }

    SpectrumWindow {
        id: spectrumWindow
        analysisController: analysisController
        bandModel: bandMarkersModel
        harmonicModel: harmonicMarkersModel
        locked: root.panelLocked("spectrum")
        onLockToggled: function(locked) {
            root.setPanelLocked("spectrum", locked)
        }
        onDockRequested: root.handleDockWindowClosed("spectrum")
        onComparisonSpectrumDetachRequested: function(index) {
            root.openDetachedComparisonSpectrum(index)
        }
        onWindowDragUpdated: function (globalX, globalY) {
            root.updateDockDropPreview("spectrum", globalX, globalY);
        }
        onWindowDragFinished: function (globalX, globalY) {
            root.finishDockDrop("spectrum", globalX, globalY);
        }
    }

    TrendWindow {
        id: trendWindow
        trendController: trendController
        locked: root.panelLocked("trends")
        onLockToggled: function(locked) {
            root.setPanelLocked("trends", locked)
        }
        onDockRequested: root.handleDockWindowClosed("trends")
        onAdditionalWindowRequested: function(metricKey) {
            root.openAdditionalTrendWindow(metricKey)
        }
        onWindowDragUpdated: function (globalX, globalY) {
            root.updateDockDropPreview("trends", globalX, globalY);
        }
        onWindowDragFinished: function (globalX, globalY) {
            root.finishDockDrop("trends", globalX, globalY);
        }
    }

    SignalWindow {
        id: signalWindow
        analysisController: analysisController
        locked: root.panelLocked("signal")
        onLockToggled: function(locked) {
            root.setPanelLocked("signal", locked)
        }
        onDockRequested: root.handleDockWindowClosed("signal")
        onWindowDragUpdated: function (globalX, globalY) {
            root.updateDockDropPreview("signal", globalX, globalY);
        }
        onWindowDragFinished: function (globalX, globalY) {
            root.finishDockDrop("signal", globalX, globalY);
        }
    }

    MarkersPanelWindow {
        id: markersPanelWindow
        analysisController: analysisController
        bandModel: bandMarkersModel
        harmonicModel: harmonicMarkersModel
        signalBandModel: analysisController.signalBandControllerObject.bandModel
        locked: root.panelLocked("markers")
        onLockToggled: function(locked) {
            root.setPanelLocked("markers", locked)
        }
        onDockRequested: root.handleDockWindowClosed("markers")
        onOpenSettingsRequested: root.openMarkerSettings()
        onWindowDragUpdated: function (globalX, globalY) {
            root.updateDockDropPreview("markers", globalX, globalY);
        }
        onWindowDragFinished: function (globalX, globalY) {
            root.finishDockDrop("markers", globalX, globalY);
        }
    }

    MarkersWindow {
        id: markersWindow
        analysisController: analysisController
        bandModel: bandMarkersModel
        harmonicModel: harmonicMarkersModel
        signalBandModel: analysisController.signalBandControllerObject.bandModel
        routeModel: routeTreeModel
        routeController: routeController
        gtldAdapter: gtldAdapter
        resultAdapter: resultAdapter
    }

    PeriodResultsWindow {
        id: periodResultsWindow
        recordsController: recordsController
        onDockRequested: root.periodDetached = false
        onWindowDragUpdated: function (globalX, globalY) {
            root.updateDockDropPreview("period", globalX, globalY);
        }
        onWindowDragFinished: function (globalX, globalY) {
            root.finishDockDrop("period", globalX, globalY);
        }
    }

    RouteWindow {
        id: routeWindow
        routeModel: routeTreeModel
        routeController: routeController
        selectedNode: selectionController.selectedNode
        pointPlacementEnabled: root.pointPlacementEnabled
        locked: root.panelLocked("route")
        onLockToggled: function(locked) {
            root.setPanelLocked("route", locked)
        }
        onDockRequested: root.handleDockWindowClosed("route")
        onObject3DRequested: root.showObject3DWorkspace()
        onNormalWorkspaceRequested: root.hideObject3DWorkspace()
        onWindowDragUpdated: function (globalX, globalY) {
            root.updateDockDropPreview("route", globalX, globalY);
        }
        onWindowDragFinished: function (globalX, globalY) {
            root.finishDockDrop("route", globalX, globalY);
        }
    }

    RecordsWindow {
        id: recordsWindow
        recordsController: recordsController
        recordsModel: recordsModel
        analysisController: analysisController
        masterValues: root.normalizedMasterValues
        locked: root.panelLocked("records")
        onLockToggled: function(locked) {
            root.setPanelLocked("records", locked)
        }
        onRecordSpectrumRequested: function(record) {
            root.openRecordSpectrum(record)
        }
        onRecordSignalRequested: function(record) {
            root.openRecordSignal(record)
        }
        onDockRequested: root.handleDockWindowClosed("records")
        onWindowDragUpdated: function (globalX, globalY) {
            root.updateDockDropPreview("records", globalX, globalY);
        }
        onWindowDragFinished: function (globalX, globalY) {
            root.finishDockDrop("records", globalX, globalY);
        }
    }

    ShortcutsHelpView {
        id: shortcutsHelp
    }

    Component {
        id: recordSpectrumWindowComponent

        RecordSpectrumWindow {}
    }

    Component {
        id: recordSignalWindowComponent

        RecordSignalWindow {}
    }

    Component {
        id: additionalTrendWindowComponent

        TrendWindow {
            property var comparisonOwner: null

            independentMetricSelection: true
            panelLockButtonVisible: false
            onAdditionalWindowRequested: function(metricKey) {
                if (comparisonOwner)
                    comparisonOwner.openAdditionalTrendWindow(metricKey)
            }
            onDockRequested: function() {
                Qt.callLater(function() { destroy() })
            }
        }
    }

    function nextRecordChartWindowPosition(windowWidth, windowHeight) {
        var center = root.mapToGlobal(root.width / 2, root.height / 2)
        var cascade = (recordChartWindowSequence % 8) * 28
        ++recordChartWindowSequence
        return {
            x: Math.max(20, Math.round(center.x - windowWidth / 2
                                      + cascade)),
            y: Math.max(20, Math.round(center.y - windowHeight / 2
                                      + cascade))
        }
    }

    function openAdditionalTrendWindow(metricKey) {
        if (!trendController || !trendController.pointNodeSelected)
            return
        var window = additionalTrendWindowComponent.createObject(root, {
            trendController: trendController,
            localSelectedMetricKey: String(metricKey || ""),
            comparisonOwner: root
        })
        if (!window)
            return
        var position = nextRecordChartWindowPosition(window.width,
                                                     window.height)
        window.x = position.x
        window.y = position.y
        window.openTrendsAtCurrentPosition()
    }

    function comparisonRecord(series) {
        var points = series && series.points ? series.points : []
        var minimum = NaN
        var maximum = NaN
        for (var index = 0; index < points.length; ++index) {
            var frequency = Number(points[index].x)
            if (!isFinite(frequency))
                continue
            minimum = isFinite(minimum)
                    ? Math.min(minimum, frequency) : frequency
            maximum = isFinite(maximum)
                    ? Math.max(maximum, frequency) : frequency
        }
        return {
            key: String(series.key || ""),
            pointName: String(series.pointName
                              || series.label || "Спектр"),
            recordTime: String(series.recordTime || ""),
            recordFileName: String(series.fileName || ""),
            tag: String(series.tag || ""),
            spectrumPoints: points,
            spectrumMinimumFrequency: minimum,
            spectrumMaximumFrequency: maximum,
            rmsValue: Number(series.rmsValue),
            spectrumExceedanceThreshold:
                Number(series.exceedanceThreshold),
            hasExceedance: Boolean(series.hasExceedance),
            stateColor: String(series.exceedanceColor || ""),
            statePriority: Number(series.statePriority),
            measurementType: String(series.measurementType || ""),
            scalarValues: series.scalarValues || []
        }
    }

    function openDetachedComparisonSpectrum(index) {
        var series = analysisController.detachComparisonSpectrum(index)
        if (!series)
            return
        var window = recordSpectrumWindowComponent.createObject(root, {
            recordData: comparisonRecord(series),
            resultAdapter: root.sharedResultAdapter,
            comparisonOwnerController: analysisController,
            comparisonSpectrumKey: String(series.key || ""),
            initialMarkerState: analysisController.markerStateForRecordKey(
                                    String(series.key || "")),
            spectrumColor: String(series.color || "#005FCC")
        })
        if (!window) {
            analysisController.restoreDetachedComparisonSpectrum(
                        series.key)
            return
        }
        var position = nextRecordChartWindowPosition(window.width,
                                                     window.height)
        window.x = position.x
        window.y = position.y
        window.openRecord()
    }

    function openRecordSpectrum(record) {
        if (!record)
            return
        var window = recordSpectrumWindowComponent.createObject(root, {
            recordData: record,
            gtldAdapter: root.sharedGtldAdapter,
            resultAdapter: root.sharedResultAdapter
        })
        if (!window)
            return
        var position = nextRecordChartWindowPosition(window.width,
                                                     window.height)
        window.x = position.x
        window.y = position.y
        window.openRecord()
    }

    function openRecordSignal(record) {
        if (!record)
            return
        var window = recordSignalWindowComponent.createObject(root, {
            recordData: record,
            gtldAdapter: root.sharedGtldAdapter,
            resultAdapter: root.sharedResultAdapter
        })
        if (!window)
            return
        var position = nextRecordChartWindowPosition(window.width,
                                                     window.height)
        window.x = position.x
        window.y = position.y
        window.openRecord()
    }

    function detachRoute(globalX, globalY, pressOffsetX, pressOffsetY) {
        if (root.panelLocked("route"))
            return;
        root.prepareDockWindow(routeWindow, "route");
        root.rememberDockPlacement("route");
        workspaceDockTree = workspaceDockLayout.treeWithoutPanel("route");
        if (arguments.length >= 4) {
            routeWindow.openPanelForDrag(globalX, globalY, pressOffsetX, pressOffsetY);
        } else {
            routeWindow.openPanel();
        }
        routeDetached = true;
    }

    function detachRecords(globalX, globalY, pressOffsetX, pressOffsetY) {
        if (root.panelLocked("records"))
            return;
        root.prepareDockWindow(recordsWindow, "records");
        root.rememberDockPlacement("records");
        workspaceDockTree = workspaceDockLayout.treeWithoutPanel("records");
        if (arguments.length >= 4) {
            recordsWindow.openPanelForDrag(globalX, globalY, pressOffsetX, pressOffsetY);
        } else {
            recordsWindow.openPanel();
        }
        recordsDetached = true;
    }

    function detachPeriod() {
        periodDetached = true;
        periodResultsWindow.openPanel();
    }

    function toggleRouteWindow() {
        if (object3DActive)
            return;
        if (routeDetached)
            routeWindow.close();
        else
            detachRoute();
    }

    function toggleRecordsWindow() {
        if (!pointPanelShortcutsEnabled)
            return;
        if (recordsDetached)
            recordsWindow.close();
        else
            detachRecords();
    }

    function togglePeriodWindow() {
        if (periodDetached)
            periodResultsWindow.close();
        else
            detachPeriod();
    }

    function detachSpectrum(globalX, globalY, pressOffsetX, pressOffsetY) {
        if (root.panelLocked("spectrum"))
            return;
        root.prepareDockWindow(spectrumWindow, "spectrum");
        root.rememberDockPlacement("spectrum");
        workspaceDockTree = workspaceDockLayout.treeWithoutPanel("spectrum");
        if (arguments.length >= 4) {
            spectrumWindow.openSpectrumForDrag(globalX, globalY, pressOffsetX, pressOffsetY);
        } else {
            spectrumWindow.openSpectrum();
        }
        spectrumDetached = true;
    }

    function detachTrends(globalX, globalY, pressOffsetX, pressOffsetY) {
        if (root.panelLocked("trends"))
            return;
        root.prepareDockWindow(trendWindow, "trends");
        root.rememberDockPlacement("trends");
        workspaceDockTree = workspaceDockLayout.treeWithoutPanel("trends");
        if (arguments.length >= 4) {
            trendWindow.openTrendsForDrag(globalX, globalY, pressOffsetX, pressOffsetY);
        } else {
            trendWindow.openTrends();
        }
        trendsDetached = true;
    }

    function detachSignal(globalX, globalY, pressOffsetX, pressOffsetY) {
        if (root.panelLocked("signal"))
            return;
        root.prepareDockWindow(signalWindow, "signal");
        root.rememberDockPlacement("signal");
        workspaceDockTree = workspaceDockLayout.treeWithoutPanel("signal");
        if (arguments.length >= 4) {
            signalWindow.openSignalForDrag(globalX, globalY, pressOffsetX, pressOffsetY);
        } else {
            signalWindow.openSignal();
        }
        signalDetached = true;
    }

    function openMarkerSettings() {
        markersWindow.openMarkers();
    }

    function detachMarkersPanel(globalX, globalY, pressOffsetX, pressOffsetY) {
        if (root.panelLocked("markers"))
            return;
        root.prepareDockWindow(markersPanelWindow, "markers");
        root.rememberDockPlacement("markers");
        workspaceDockTree = workspaceDockLayout.treeWithoutPanel("markers");
        if (arguments.length >= 4) {
            markersPanelWindow.openPanelForDrag(globalX, globalY, pressOffsetX, pressOffsetY);
        } else {
            markersPanelWindow.openPanel();
        }
        markersPanelDetached = true;
    }

    function dockDropTarget(panelName) { return workspaceController.dockDropTarget(panelName); }

    function updateStoredGraphSize(panelName, width, height) { workspaceController.updateStoredGraphSize(panelName, width, height); }

    function prepareDockWindow(targetWindow, panelName) { workspaceController.prepareDockWindow(targetWindow, panelName); }

    function setPanelDetached(panelName, detached) { workspaceController.setPanelDetached(panelName, detached); }

    function panelDetached(panelName) { return workspaceController.panelDetached(panelName); }

    function workspacePanelOpen(panelName) { return workspaceController.workspacePanelOpen(panelName); }

    function openWorkspacePanel(panelName) { workspaceController.openWorkspacePanel(panelName); }

    function closeWorkspacePanel(panelName) { workspaceController.closeWorkspacePanel(panelName); }

    function toggleWorkspacePanel(panelName) { workspaceController.toggleWorkspacePanel(panelName); }

    function handleDockWindowClosed(panelName) { workspaceController.handleDockWindowClosed(panelName); }

    function rememberDockPlacement(panelName) { workspaceController.rememberDockPlacement(panelName); }

    function forgetDockPlacement(panelName) { workspaceController.forgetDockPlacement(panelName); }

    function restoredDockTree(baseTree, panelName, placements) { return workspaceController.restoredDockTree(baseTree, panelName, placements); }

    function restoreDockPanel(panelName) { workspaceController.restoreDockPanel(panelName); }

    function dockWindow(panelName) { return workspaceController.dockWindow(panelName); }

    function panelDockRatio(panelName, orientation, targetWidth, targetHeight) { return workspaceController.panelDockRatio(panelName, orientation, targetWidth, targetHeight); }

    function updateDockDropPreview(panelName, globalX, globalY) { workspaceController.updateDockDropPreview(panelName, globalX, globalY); }

    function finishDockDrop(panelName, globalX, globalY) { workspaceController.finishDockDrop(panelName, globalX, globalY); }

    function toggleSpectrumWindow() { workspaceController.toggleSpectrumWindow(); }

    function toggleTrendWindow() { workspaceController.toggleTrendWindow(); }

    function toggleSignalWindow() { workspaceController.toggleSignalWindow(); }

    function toggleMarkersWindow() { workspaceController.toggleMarkersWindow(); }

    function dockAllPanels() { workspaceController.dockAllPanels(); }

    function addBandFromShortcut() {
        if (!pointPanelShortcutsEnabled)
            return;
        if (analysisController.addBand() >= 0)
            root.detachSpectrum();
    }

    function addHarmonicFromShortcut() {
        if (!pointPanelShortcutsEnabled)
            return;
        if (analysisController.addHarmonic() >= 0)
            root.detachSpectrum();
    }

    function removeSelectedMarker() {
        if (!pointPanelShortcutsEnabled)
            return;
        if (analysisController.selectedBandIndex >= 0) {
            analysisController.removeBand(analysisController.selectedBandIndex);
        } else if (analysisController.selectedHarmonicIndex >= 0) {
            analysisController.removeHarmonic(analysisController.selectedHarmonicIndex);
        }
    }

    function toggleShortcutsHelp() {
        if (shortcutsHelp.visible)
            shortcutsHelp.close();
        else
            shortcutsHelp.openHelp();
    }

    Shortcut {
        sequence: "F1"
        context: Qt.ApplicationShortcut
        autoRepeat: false
        onActivated: root.toggleShortcutsHelp()
    }

    Shortcut {
        sequence: "F2"
        context: Qt.ApplicationShortcut
        enabled: !root.object3DActive
        onActivated: root.toggleRouteWindow()
    }

    Shortcut {
        sequence: "F3"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: root.toggleRecordsWindow()
    }

    Shortcut {
        sequence: "F4"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: root.toggleSpectrumWindow()
    }

    Shortcut {
        sequence: "F5"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: root.toggleTrendWindow()
    }

    Shortcut {
        sequence: "F6"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: root.toggleSignalWindow()
    }

    Shortcut {
        sequence: "F8"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: root.toggleMarkersWindow()
    }

    Shortcut {
        sequence: "F9"
        context: Qt.ApplicationShortcut
        autoRepeat: false
        onActivated: root.toggleGamesMenu()
    }

    Shortcut {
        sequence: "Alt+Left"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: recordsController.previous()
    }

    Shortcut {
        sequence: "Alt+Right"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: recordsController.next()
    }

    Shortcut {
        sequence: "Ctrl+B"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: root.addBandFromShortcut()
    }

    Shortcut {
        sequence: "Ctrl+H"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: root.addHarmonicFromShortcut()
    }

    Shortcut {
        sequence: "Ctrl+Delete"
        context: Qt.ApplicationShortcut
        enabled: root.pointPanelShortcutsEnabled
        onActivated: root.removeSelectedMarker()
    }

    Shortcut {
        sequence: "Ctrl+0"
        context: Qt.ApplicationShortcut
        enabled: !root.object3DActive
        onActivated: root.dockAllPanels()
    }

    function refreshMasterValues(result) {
        normalizedMasterValues = masterValuesAdapter.normalize(resultAdapter.extractMasterValues(result));
    }

    function gtldRefreshKey() {
        var nodeKey = gtldAdapter.nodeUuid(gtldAdapter.node);
        var result = gtldAdapter.currentLastResult;
        var resultKey = result ? resultAdapter.resultKey(result, gtldAdapter.nodeName(gtldAdapter.node)) : "no-result";
        return nodeKey + "|" + resultKey;
    }

    Connections {
        target: gtldAdapter

        function onRefreshed() {
            var refreshKey = root.gtldRefreshKey();
            if (refreshKey === root.lastGtldRefreshKey)
                return;
            root.lastGtldRefreshKey = refreshKey;
            routeController.refresh(gtldAdapter.node);
            root.openPointWorkspace(gtldAdapter.node);
            root.normalizedMasterValues = [];
            recordsController.load(gtldAdapter.node, "", "", recordsController.resultTag, 5000);
        }
    }

    Connections {
        target: routeController

        function onNodeActivated(node) {
            root.openPointWorkspace(node);
            recordsController.load(node, recordsController.dateFrom, recordsController.dateTo, recordsController.resultTag, recordsController.loadLimit);
        }
    }

    Connections {
        target: selectionController

        function onRecordSelected(record, index) {
            root.cancelActivePreviewRequests();
            analysisController.setRecord(record);
            var rawResult = record ? record.rawResult : null;
            gtldAdapter.setCurrentResult(rawResult);
            root.refreshMasterValues(rawResult);
            if (rawResult) {
                var embeddedSpectrum = record && record.spectrumPoints
                        ? record.spectrumPoints : [];
                var hasEmbeddedSpectrum = embeddedSpectrum.length > 1;
                if (hasEmbeddedSpectrum) {
                    analysisController.beginSignalPreviewLoading();
                    analysisController.useEmbeddedSpectrum(
                                embeddedSpectrum);
                } else {
                    analysisController.beginPreviewLoading();
                }
                root.activeSignalPreviewRequestId = gtldAdapter.requestSignalPreview(
                            rawResult,
                            analysisController.signalPointBudget,
                            0, NaN, "auto");
                if (!hasEmbeddedSpectrum) {
                    root.activeSpectrumPreviewRequestId =
                            gtldAdapter.requestSpectrumPreview(
                                rawResult,
                                analysisController.spectrumPointBudget,
                                record.spectrumMaximumFrequency,
                                record.spectrumMinimumFrequency);
                }
            }
        }
    }

    Connections {
        target: gtldAdapter

        function onSignalPreviewLoaded(requestId, sourceResult, points, metadata) {
            if (root.activeSignalPreviewRequestId === null || String(requestId) !== String(root.activeSignalPreviewRequestId) || !root.previewBelongsToSelectedRecord(sourceResult))
                return;
            root.activeSignalPreviewRequestId = null;
            analysisController.applySignalPreview(points, metadata);
        }

        function onSpectrumPreviewLoaded(requestId, sourceResult, points, metadata) {
            if (markersWindow.isMarkerPreviewRequest(requestId))
                return;
            if (root.comparisonSpectrumRequestId !== null && String(requestId) === String(root.comparisonSpectrumRequestId)) {
                root.comparisonSpectrumRequestId = null;
                analysisController.applyComparisonSpectrumPreview(points, metadata);
                return;
            }
            if (root.activeSpectrumPreviewRequestId === null || String(requestId) !== String(root.activeSpectrumPreviewRequestId) || !root.previewBelongsToSelectedRecord(sourceResult))
                return;
            root.activeSpectrumPreviewRequestId = null;
            analysisController.applySpectrumPreview(points, metadata);
        }

        function onPreviewFailed(previewType, requestId, message) {
            if (previewType === "spectrum" && markersWindow.isMarkerPreviewRequest(requestId)) {
                return;
            }
            if (previewType === "spectrum" && root.comparisonSpectrumRequestId !== null && (requestId === null || String(requestId) === String(root.comparisonSpectrumRequestId))) {
                root.comparisonSpectrumRequestId = null;
                analysisController.failComparisonSpectrumPreview(message);
                return;
            }
            if (!analysisController.selectedRecord)
                return;
            if (previewType === "signal") {
                if (requestId !== null
                        && (root.activeSignalPreviewRequestId === null
                            || String(requestId)
                               !== String(root.activeSignalPreviewRequestId))) {
                    return;
                }
                root.activeSignalPreviewRequestId = null;
            } else if (previewType === "spectrum") {
                if (requestId !== null
                        && (root.activeSpectrumPreviewRequestId === null
                            || String(requestId)
                               !== String(root.activeSpectrumPreviewRequestId))) {
                    return;
                }
                root.activeSpectrumPreviewRequestId = null;
            }
            analysisController.failPreview(previewType, message);
        }
    }

    Connections {
        target: analysisController

        function onSignalRangeRequested(startSample, sampleCount,
                                        pointLimit) {
            var record = analysisController.selectedRecord;
            var rawResult = record ? record.rawResult : null;
            if (!rawResult)
                return;
            gtldAdapter.cancelPreview(
                        "signal", root.activeSignalPreviewRequestId);
            root.activeSignalPreviewRequestId =
                    gtldAdapter.requestSignalPreview(
                        rawResult, pointLimit, startSample,
                        sampleCount, "auto");
        }

        function onSpectrumRangeRequested(minimumFrequency,
                                          maximumFrequency,
                                          pointLimit) {
            var record = analysisController.selectedRecord;
            var rawResult = record ? record.rawResult : null;
            if (!rawResult)
                return;
            gtldAdapter.cancelPreview(
                        "spectrum", root.activeSpectrumPreviewRequestId);
            root.activeSpectrumPreviewRequestId =
                    gtldAdapter.requestSpectrumPreview(
                        rawResult, pointLimit, maximumFrequency,
                        minimumFrequency);
        }

        function onComparisonSpectrumRequested(rawResult, pointName, maximumFrequency) {
            gtldAdapter.cancelPreview(
                        "spectrum", root.comparisonSpectrumRequestId);
            root.comparisonSpectrumRequestId = gtldAdapter.requestSpectrumPreview(
                        rawResult,
                        analysisController.spectrumPointBudget,
                        maximumFrequency);
            if (root.comparisonSpectrumRequestId === null) {
                analysisController.failComparisonSpectrumPreview(gtldAdapter.errorMessage);
            }
        }
    }

    Connections {
        target: recordsController

        function onLoaded(visibleCount, sourceCount) {
            routeController.refreshAllPointExceedances(resultAdapter, recordsController.resultTag);
            trendController.rebuild();
        }
    }

    Rectangle {
        anchors.fill: parent
        color: applicationStyle.backgroundColor
    }

    ColumnLayout {
        anchors.fill: parent
        visible: true
        anchors.margins: applicationStyle.outerMargin
        spacing: applicationStyle.panelSpacing

        Rectangle {
            id: mainHeaderPanel

            readonly property real inlineFixedWidth: 24 + 24 + 250 + 730
            readonly property real inlineActionsReserve: 232
            readonly property bool compactLayout: width < inlineFixedWidth + inlineActionsReserve
            readonly property real actionsPreferredWidth: Math.max(220, Math.min(inlineActionsReserve, width - inlineFixedWidth))
            readonly property real requiredHeight: compactLayout && mainPeriodToolbar.visible ? mainPeriodToolbar.implicitHeight + 74 : 68

            Layout.fillWidth: true
            Layout.preferredHeight: requiredHeight
            Layout.minimumHeight: requiredHeight
            Layout.maximumHeight: requiredHeight
            radius: 10
            color: applicationStyle.panelColor
            border.color: applicationStyle.borderColor

            GridLayout {
                anchors.fill: parent
                anchors.margins: 12
                columns: mainHeaderPanel.compactLayout ? 2 : 3
                columnSpacing: 12
                rowSpacing: mainHeaderPanel.compactLayout ? 8 : 0

                Item {
                    Layout.row: 0
                    Layout.column: 0
                    Layout.fillWidth: mainHeaderPanel.compactLayout
                    Layout.preferredWidth: mainHeaderPanel.compactLayout ? 1 : 250
                    Layout.preferredHeight: 42
                    Layout.minimumWidth: 0

                    Row {
                        anchors.left: parent.left
                        anchors.verticalCenter: parent.verticalCenter
                        spacing: 9

                        Repeater {
                            model: [
                                {
                                    "panel": "route",
                                    "title": "Маршрут",
                                    "icon": "assets/window-route.svg"
                                },
                                {
                                    "panel": "records",
                                    "title": "Записи",
                                    "icon": "assets/window-records.svg"
                                },
                                {
                                    "panel": "spectrum",
                                    "title": "Спектр",
                                    "icon": "assets/window-spectrum.svg"
                                },
                                {
                                    "panel": "trends",
                                    "title": "Мастер-значения",
                                    "icon": "assets/window-trends.svg"
                                },
                                {
                                    "panel": "signal",
                                    "title": "Временной сигнал",
                                    "icon": "assets/window-signal.svg"
                                },
                                {
                                    "panel": "markers",
                                    "title": "Маркеры",
                                    "icon": "assets/window-markers.svg"
                                }
                            ]

                            delegate: AppToolButton {
                                id: panelButton

                                width: 34
                                height: 34
                                enabled: !root.object3DActive
                                checked: root.workspacePanelOpen(modelData.panel)
                                onClicked: root.toggleWorkspacePanel(modelData.panel)

                                contentItem: Image {
                                    source: modelData.icon
                                    sourceSize.width: 26
                                    sourceSize.height: 26
                                    fillMode: Image.PreserveAspectFit
                                    smooth: true
                                    opacity: panelButton.enabled ? 1 : 0.45
                                }

                                background: Rectangle {
                                    radius: 5
                                    color: !panelButton.enabled
                                           ? applicationStyle.disabledControlColor
                                           : panelButton.down
                                             ? applicationStyle.selectedPressedColor
                                             : panelButton.checked
                                               ? applicationStyle.selectedHoverColor
                                               : panelButton.hovered
                                                 ? applicationStyle.controlHoverColor
                                                 : applicationStyle.controlColor
                                    border.width: panelButton.checked
                                                  ? applicationStyle.focusBorderWidth
                                                  : applicationStyle.borderWidth
                                    border.color: !panelButton.enabled
                                                  ? applicationStyle.disabledBorderColor
                                                  : panelButton.checked
                                                    ? applicationStyle.focusColor
                                                    : applicationStyle.controlBorderColor
                                }

                                AppToolTip {
                                    target: panelButton
                                    text: (panelButton.checked
                                           ? "Закрыть: " : "Открыть: ")
                                          + modelData.title
                                }
                            }
                        }
                    }
                }

                RoutePeriodToolbarView {
                    id: mainPeriodToolbar

                    visible: !root.periodDetached && !root.recordsDetached
                    Layout.row: mainHeaderPanel.compactLayout ? 1 : 0
                    Layout.column: mainHeaderPanel.compactLayout ? 0 : 1
                    Layout.columnSpan: mainHeaderPanel.compactLayout ? 2 : 1
                    Layout.fillWidth: true
                    Layout.preferredWidth: mainHeaderPanel.compactLayout ? 1 : 730
                    Layout.minimumWidth: 0
                    recordsController: recordsController
                }

                RowLayout {
                    Layout.row: 0
                    Layout.column: mainHeaderPanel.compactLayout ? 1 : 2
                    Layout.rightMargin: mainHeaderPanel.compactLayout && mainPeriodToolbar.visible ? mainPeriodToolbar.contentRightInset : 0
                    Layout.preferredWidth: mainHeaderPanel.actionsPreferredWidth
                    Layout.minimumWidth: 0
                    Layout.maximumWidth: mainHeaderPanel.inlineActionsReserve
                    Layout.preferredHeight: 42
                    spacing: 8

                    AppButton {
                        id: shortcutsButton

                        accentButton: true
                        accentColor: applicationStyle.accentColor
                        Layout.fillWidth: true
                        Layout.preferredHeight: 42
                        hoverEnabled: true
                        leftPadding: 6
                        rightPadding: 6
                        text: "Горячие клавиши"
                        font.bold: true
                        font.pixelSize: applicationStyle.fontSizeBody
                        onClicked: root.toggleShortcutsHelp()

                        contentItem: Text {
                            renderType: Text.NativeRendering
                            text: shortcutsButton.text
                            color: shortcutsButton.enabled
                                   ? applicationStyle.inverseTextColor
                                   : applicationStyle.stronglyDisabledTextColor
                            font: shortcutsButton.font
                            horizontalAlignment: Text.AlignHCenter
                            verticalAlignment: Text.AlignVCenter
                            elide: Text.ElideRight
                        }

                    }
                }
            }
        }

        DockLayout {
            id: workspaceDockLayout

            Layout.fillWidth: true
            Layout.fillHeight: true
            layoutTree: root.workspaceDockTree
            lockedPanels: root.panelLocks
        }
    }

    RouteTreeView {
        id: routePane

        parent: workspaceDockLayout.slotForPanel("route")
        anchors.fill: parent
        visible: !root.routeDetached
        routeModel: routeTreeModel
        routeController: routeController
        selectedNode: selectionController.selectedNode
        pointPlacementEnabled: root.pointPlacementEnabled
        locked: root.panelLocked("route")
        lockButtonVisible: true
        dragToDetachEnabled: !root.object3DActive
        onLockToggled: function(locked) {
            root.setPanelLocked("route", locked)
        }
        onObject3DRequested: root.showObject3DWorkspace()
        onNormalWorkspaceRequested: root.hideObject3DWorkspace()
        onDetachRequested: function (globalX, globalY, pressOffsetX, pressOffsetY) {
            root.detachRoute(globalX, globalY, pressOffsetX, pressOffsetY);
        }
    }

    RecordsBrowserView {
        id: recordsPane

        parent: workspaceDockLayout.slotForPanel("records")
        anchors.fill: parent
        visible: !root.recordsDetached
        recordsController: recordsController
        recordsModel: recordsModel
        analysisController: analysisController
        masterValues: root.normalizedMasterValues
        showPeriodToolbar: false
        locked: root.panelLocked("records")
        lockButtonVisible: true
        dragToDetachEnabled: !root.object3DActive
        onLockToggled: function(locked) {
            root.setPanelLocked("records", locked)
        }
        onRecordSpectrumRequested: function(record) {
            root.openRecordSpectrum(record)
        }
        onRecordSignalRequested: function(record) {
            root.openRecordSignal(record)
        }
        onDetachRequested: function (globalX, globalY, pressOffsetX, pressOffsetY) {
            root.detachRecords(globalX, globalY, pressOffsetX, pressOffsetY);
        }
    }

    SpectrumChart {
        densityMode: root.densityMode
        parent: workspaceDockLayout.slotForPanel("spectrum")
        anchors.fill: parent
        visible: !root.spectrumDetached
        points: analysisController.spectrumPoints
        bandModel: bandMarkersModel
        harmonicModel: harmonicMarkersModel
        analysisController: analysisController
        locked: root.panelLocked("spectrum")
        lockButtonVisible: true
        dragToDetachEnabled: true
        onLockToggled: function(locked) {
            root.setPanelLocked("spectrum", locked)
        }
        cursorMetricsProvider: function (frequency) {
            return analysisController.spectrumCursorMetrics(frequency);
        }
        onDetachRequested: function (globalX, globalY, pressOffsetX, pressOffsetY) {
            root.detachSpectrum(globalX, globalY, pressOffsetX, pressOffsetY);
        }
        onComparisonSpectrumDetachRequested: function(index) {
            root.openDetachedComparisonSpectrum(index)
        }
    }

    TrendsWorkspaceView {
        parent: workspaceDockLayout.slotForPanel("trends")
        anchors.fill: parent
        visible: !root.trendsDetached
        trendController: trendController
        locked: root.panelLocked("trends")
        lockButtonVisible: true
        dragToDetachEnabled: true
        onLockToggled: function(locked) {
            root.setPanelLocked("trends", locked)
        }
        onDetachRequested: function (globalX, globalY, pressOffsetX, pressOffsetY) {
            root.detachTrends(globalX, globalY, pressOffsetX, pressOffsetY);
        }
        onAdditionalWindowRequested: function(metricKey) {
            root.openAdditionalTrendWindow(metricKey)
        }
    }

    SignalChart {
        parent: workspaceDockLayout.slotForPanel("signal")
        anchors.fill: parent
        visible: !root.signalDetached
        points: analysisController.signalPoints
        analysisController: analysisController
        locked: root.panelLocked("signal")
        lockButtonVisible: true
        dragToDetachEnabled: true
        onLockToggled: function(locked) {
            root.setPanelLocked("signal", locked)
        }
        onDetachRequested: function (globalX, globalY, pressOffsetX, pressOffsetY) {
            root.detachSignal(globalX, globalY, pressOffsetX, pressOffsetY);
        }
    }

    AnalysisWorkspace {
        id: markersPane

        densityMode: root.densityMode

        parent: workspaceDockLayout.slotForPanel("markers")
        anchors.fill: parent
        visible: !root.markersPanelDetached
        color: applicationStyle.panelColor
        border.width: applicationStyle.borderWidth
        border.color: applicationStyle.borderColor
        radius: 8
        analysisController: analysisController
        bandModel: bandMarkersModel
        harmonicModel: harmonicMarkersModel
        signalBandModel: analysisController.signalBandControllerObject.bandModel
        locked: root.panelLocked("markers")
        lockButtonVisible: true
        dragToDetachEnabled: true
        onLockToggled: function(locked) {
            root.setPanelLocked("markers", locked)
        }
        onDetachRequested: function (globalX, globalY, pressOffsetX, pressOffsetY) {
            root.detachMarkersPanel(globalX, globalY, pressOffsetX, pressOffsetY);
        }
        onSettingsRequested: root.openMarkerSettings()
    }

    Loader {
        id: object3DWorkspaceLoader

        parent: workspaceDockLayout.slotForPanel("object3d")
        anchors.fill: parent
        active: root.object3DInitialized
        visible: root.object3DActive
        z: 500
        sourceComponent: Object3DWorkspace {
            // Keep the owning object stable while a point is selected.  The
            // loaded GLB therefore remains cached instead of being unloaded
            // during every transition from 3D to a route point.
            selectedNode: root.object3DSelectedNode
            routeModel: routeTreeModel
            onCloseRequested: root.hideObject3DWorkspace()
            onPointRequested: function(pointNode) {
                root.hideObject3DWorkspace()
                // Yield one frame so the lightweight analysis layout is
                // visible before GTLd starts selecting and loading the point.
                Qt.callLater(function() {
                    routeController.activateNode(pointNode)
                })
            }
        }
    }

    Rectangle {
        id: dockDropPreview

        visible: root.dockDropPreviewVisible
        x: root.dockDropX
        y: root.dockDropY
        width: root.dockDropWidth
        height: root.dockDropHeight
        z: 10000
        radius: 8
        color: applicationStyle.dropTargetOverlayColor
        border.width: applicationStyle.focusBorderWidth
        border.color: applicationStyle.focusColor
    }

    GamesMenuView {
        id: gamesMenu

        anchors.fill: parent
        visible: root.gamesMenuVisible
        z: 20000
        onCloseRequested: root.closeGamesMenu()
        onGameSelected: function(gameId) {
            root.gameSelected(gameId)
        }
    }
}
