import QtQml
import QtQuick
import QtQuick.Window

import "../charts"
import "../controllers"
import "../models"
import "../style"

Window {
    id: root

    property var recordData: null
    property var gtldAdapter: null
    property var resultAdapter: null
    property var activeRequestId: null
    property bool locked: false
    property var comparisonOwnerController: null
    property string comparisonSpectrumKey: ""
    property string spectrumColor: "#005FCC"
    property var initialMarkerState: null
    readonly property bool detachedComparisonMode:
        comparisonSpectrumKey.length > 0

    width: 1180
    height: 700
    minimumWidth: 480
    minimumHeight: 300
    visible: false
    transientParent: null
    flags: Qt.Window | Qt.CustomizeWindowHint | Qt.WindowTitleHint
           | Qt.WindowSystemMenuHint | Qt.WindowMinimizeButtonHint
           | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint
    color: "#E7ECF2"
    title: detachedComparisonMode
           ? "Откреплённый спектр — "
             + String(recordData ? recordData.pointName || "Спектр"
                                 : "Спектр")
           : recordData
             ? "Спектр — " + String(recordData.pointName || "Точка")
               + " — " + String(recordData.recordTime || "")
             : "Спектр"

    function openRecord() {
        if (!recordData)
            return
        show()
        raise()
        requestActivate()
        // A Window has no usable chart geometry until it is shown. Loading
        // the series on the next event-loop turn prevents the chart from
        // caching its initial 0x0 viewport and remaining on the 0..1 axes.
        Qt.callLater(loadRecordData)
    }

    function loadRecordData() {
        if (!recordData || !visible)
            return
        localAnalysis.setRecord(recordData)
        if (detachedComparisonMode && initialMarkerState) {
            localAnalysis.replaceMarkerStateForRecordKey(
                        localAnalysis.currentRecordKey,
                        initialMarkerState)
        }
        var embedded = recordData.spectrumPoints || []
        if (embedded.length > 1) {
            localAnalysis.useEmbeddedSpectrum(embedded)
        } else {
            localAnalysis.spectrumLoading = true
            localAnalysis.spectrumError = ""
            requestSpectrum(recordData.spectrumMinimumFrequency,
                            recordData.spectrumMaximumFrequency,
                            localAnalysis.spectrumPointBudget)
        }
    }

    function requestSpectrum(minimumFrequency, maximumFrequency,
                             pointLimit) {
        var rawResult = recordData ? recordData.rawResult : null
        if (!gtldAdapter || !rawResult)
            return false
        gtldAdapter.cancelPreview("spectrum", activeRequestId)
        activeRequestId = gtldAdapter.requestSpectrumPreview(
                    rawResult, pointLimit,
                    maximumFrequency, minimumFrequency)
        if (activeRequestId === null) {
            localAnalysis.failPreview(
                        "spectrum", gtldAdapter.errorMessage)
            return false
        }
        return true
    }

    BandMarkersModel {
        id: localBandMarkers
    }

    HarmonicMarkersModel {
        id: localHarmonicMarkers
    }

    AnalysisController {
        id: localAnalysis

        resultAdapter: root.resultAdapter
        primarySpectrumColor: root.spectrumColor
        bandModel: localBandMarkers
        harmonicModel: localHarmonicMarkers
        selectedResultTag: root.recordData
                           ? String(root.recordData.tag || "") : ""

        onSpectrumRangeRequested: function(minimumFrequency,
                                           maximumFrequency,
                                           pointLimit) {
            root.requestSpectrum(minimumFrequency, maximumFrequency,
                                 pointLimit)
        }
    }

    Connections {
        target: root.gtldAdapter

        function onSpectrumPreviewLoaded(requestId, sourceResult,
                                         points, metadata) {
            if (root.activeRequestId === null
                    || String(requestId)
                       !== String(root.activeRequestId)) {
                return
            }
            root.activeRequestId = null
            localAnalysis.applySpectrumPreview(points, metadata)
        }

        function onPreviewFailed(previewType, requestId, message) {
            if (previewType !== "spectrum"
                    || root.activeRequestId === null
                    || (requestId !== null
                        && String(requestId)
                           !== String(root.activeRequestId))) {
                return
            }
            root.activeRequestId = null
            localAnalysis.failPreview("spectrum", message)
        }
    }

    SpectrumChart {
        anchors.fill: parent
        anchors.margins: 10
        points: root.visible ? localAnalysis.spectrumPoints : []
        bandModel: localBandMarkers
        harmonicModel: localHarmonicMarkers
        analysisController: root.visible ? localAnalysis : null
        locked: root.locked
        lockButtonVisible: true
        comparisonSpectraEnabled: false
        spectrumLegendEnabled: !root.detachedComparisonMode
        markersEnabled: true
        onLockToggled: function(locked) { root.locked = locked }
        cursorMetricsProvider: function(frequency) {
            return localAnalysis.spectrumCursorMetrics(frequency)
        }
    }

    WindowGeometryLock {
        targetWindow: root
        locked: root.locked
    }

    onClosing: function(close) {
        if (comparisonOwnerController && detachedComparisonMode) {
            localAnalysis.saveCurrentMarkers()
            comparisonOwnerController.replaceMarkerStateForRecordKey(
                        comparisonSpectrumKey,
                        localAnalysis.markerStateForRecordKey(
                            localAnalysis.currentRecordKey))
            comparisonOwnerController.restoreDetachedComparisonSpectrum(
                        comparisonSpectrumKey)
        }
        if (gtldAdapter)
            gtldAdapter.cancelPreview("spectrum", activeRequestId)
        activeRequestId = null
        Qt.callLater(function() {
            root.destroy()
        })
    }
}
