import QtQml

import "../models"

QtObject {
    id: controller

    property var comparisonControllerObject: ComparisonSpectrumController {
        id: comparisonSpectrumController
        analysis: controller
    }

    property var markerControllerObject: SpectrumMarkerController {
        id: spectrumMarkerController
        analysis: controller
    }

    // Signal bands use time boundaries and must never modify spectrum bands.
    property var signalBandControllerObject: QtObject {
        id: signalBandController

        property var bandModel: BandMarkersModel {}
        property var harmonicModel: null
        property var bandsByRecord: ({})
        property string activeRecordKey: ""
        property string markerCreationMode: "band"
        property int selectedBandIndex: -1
        readonly property string amplitudeUnit: controller.amplitudeUnit

        signal markersUpdated()
        signal markerSelected(string markerType, int index)

        function copyBands() {
            var result = []
            for (var index = 0; index < bandModel.count; ++index) {
                var source = bandModel.get(index)
                var copy = ({})
                for (var key in source)
                    copy[key] = source[key]
                result.push(copy)
            }
            return result
        }

        function saveCurrentMarkers() {
            if (!activeRecordKey)
                return
            var states = ({})
            for (var key in bandsByRecord)
                states[key] = bandsByRecord[key]
            states[activeRecordKey] = copyBands()
            bandsByRecord = states
        }

        function switchRecord(recordKey) {
            saveCurrentMarkers()
            activeRecordKey = String(recordKey || "")
            bandModel.clear()
            selectedBandIndex = -1
            var bands = bandsByRecord[activeRecordKey] || []
            for (var index = 0; index < bands.length; ++index)
                bandModel.append(bands[index])
            bandModel.renumber()
            markersUpdated()
        }

        function signalRange() {
            var points = controller.signalPoints || []
            if (points.length < 2)
                return null
            var first = Number(points[0].x)
            var last = Number(points[points.length - 1].x)
            return isFinite(first) && isFinite(last) && first !== last
                    ? { minimum: Math.min(first, last),
                        maximum: Math.max(first, last) } : null
        }

        function addBandRange(requestedLeft, requestedRight) {
            var range = signalRange()
            if (!activeRecordKey || !range)
                return -1
            var left = Math.max(range.minimum,
                                Math.min(range.maximum, Number(requestedLeft)))
            var right = Math.max(range.minimum,
                                 Math.min(range.maximum, Number(requestedRight)))
            if (!isFinite(left) || !isFinite(right))
                return -1
            if (right < left) {
                var temporary = left
                left = right
                right = temporary
            }
            if (right - left < Math.max(0.000001,
                                        (range.maximum - range.minimum) * 0.001))
                return -1
            var color = controller.markerColorCycle[
                        bandModel.count % controller.markerColorCycle.length]
            selectedBandIndex = bandModel.add(
                        left, right, color,
                        controller.rmsForPoints(controller.signalPoints,
                                                left, right))
            saveCurrentMarkers()
            markerSelected("band", selectedBandIndex)
            markersUpdated()
            return selectedBandIndex
        }

        function updateBand(index, requestedLeft, requestedRight) {
            var range = signalRange()
            if (!range || index < 0 || index >= bandModel.count)
                return false
            var left = Math.max(range.minimum,
                                Math.min(range.maximum, Number(requestedLeft)))
            var right = Math.max(range.minimum,
                                 Math.min(range.maximum, Number(requestedRight)))
            if (!isFinite(left) || !isFinite(right))
                return false
            if (right < left) {
                var temporary = left
                left = right
                right = temporary
            }
            var minimumWidth = Math.max(0.000001,
                                        (range.maximum - range.minimum) * 0.001)
            if (right - left < minimumWidth)
                right = Math.min(range.maximum, left + minimumWidth)
            if (!bandModel.updateRange(index, left, right,
                                       controller.rmsForPoints(
                                           controller.signalPoints,
                                           left, right)))
                return false
            selectedBandIndex = index
            saveCurrentMarkers()
            markersUpdated()
            return true
        }

        function selectMarker(type, index) {
            selectedBandIndex = type === "band" ? index : -1
            markerSelected(type, index)
        }

        function removeBand(index) {
            if (!bandModel.removeAt(index))
                return false
            selectedBandIndex = -1
            saveCurrentMarkers()
            markersUpdated()
            return true
        }

        function clearMarkers(markerType) {
            if (markerType !== "band" || bandModel.count === 0)
                return false
            bandModel.clear()
            selectedBandIndex = -1
            saveCurrentMarkers()
            markersUpdated()
            return true
        }
    }

    property var selectedRecord: null
    property var resultAdapter: null
    property var spectrumPoints: []
    property var spectrumOverviewPoints: []
    property var comparisonSpectra: []
    property string primarySpectrumColor: "#005FCC"
    property string defaultComparisonSpectrumColor: "#005FCC"
    property var comparisonColorPalette: [
        "#6F42C1", "#22C55E", "#F59E0B", "#06B6D4",
        "#EC4899", "#84CC16", "#F97316", "#4F46E5",
        "#14B8A6", "#D946EF"
    ]
    property bool primarySpectrumVisible: true
    property int maximumComparisonSpectra: 8
    property var pendingComparisonResult: null
    property string pendingComparisonPointName: ""
    property var pendingComparisonRecord: null
    property bool comparisonDragActive: false
    property var spectrumDropTargets: []
    property var spectrumBasePoints: []
    property var spectrumExceedancePoints: []
    property bool spectrumBaseVisible: false
    property bool spectrumExceedancesVisible: false
    property string spectrumBaseColor: "#DC2626"
    property string spectrumExceedanceColor: "#DC2626"
    property real spectrumExceedanceThreshold: NaN
    property real pointRmsValue: NaN
    property bool pointHasExceedance: false
    property real pointStatePriority: NaN
    property var signalPoints: []
    property var scalarValues: []
    property var signalMetadata: null
    property int signalPointBudget: 4096
    property int spectrumPointBudget: 4096
    property var spectrumMetadata: null
    property var bandModel: null
    property var harmonicModel: null
    property var bandRmsProvider: null
    property var pointRmsProvider: null
    property string selectedResultTag: ""
    property string markerCreationMode: "harmonic"
    property var analysisByRecord: ({})
    property bool markerBatchActive: false
    property var markerBatchStates: ({})
    property var markerBatchOriginalStates: ({})
    property bool markerBatchDirty: false
    property bool markerBatchCurrentRecordUpdated: false
    property var lastMarkerApplicationSnapshot: ({})
    property bool canUndoLastMarkerApplication: false
    property var spectrumPrefixSquares: [0]
    property var spectrumPrefixCounts: [0]
    property bool spectrumSorted: true
    property real cachedSpectrumMinimumX: 0
    property real cachedSpectrumMaximumX: 1
    property real cachedSpectrumNoiseFloor: 0
    property real cachedSpectrumMaximumAmplitude: 0
    property string currentRecordKey: ""
    property string activeMarkerSpectrumKey: ""
    property bool explicitRecordUpdate: false
    property int selectedBandIndex: -1
    property int selectedHarmonicIndex: -1
    property bool signalLoading: false
    property bool spectrumLoading: false
    property string signalError: ""
    property string spectrumError: ""
    property string statusMessage: "Запись не выбрана"
    property var markerColorCycle: [
        "#6F42C1", "#005FCC", "#22C55E", "#F59E0B",
        "#DC2626", "#06B6D4", "#EC4899", "#84CC16",
        "#F97316", "#4F46E5", "#14B8A6", "#D946EF"
    ]

    readonly property bool hasSpectrum: spectrumPoints.length > 1
    readonly property bool hasSignal: signalPoints.length > 1
    readonly property bool hasRecord: selectedRecord !== null
    readonly property real spectrumMinimumFrequency:
        selectedRecord
        ? Number(selectedRecord.spectrumMinimumFrequency) : NaN
    readonly property real spectrumMaximumFrequency:
        selectedRecord
        ? Number(selectedRecord.spectrumMaximumFrequency) : NaN
    readonly property string amplitudeUnit:
        resolveMeasurementUnit(scalarValues, selectedRecord)
    readonly property var visibleSpectrumRangeCache:
        calculateVisibleSpectrumRange()

    signal analysisUpdated(var record)
    signal markersUpdated()
    signal markerSelected(string markerType, int index)
    signal comparisonSpectrumAdded()
    signal comparisonSpectrumRequested(var rawResult,
                                       string pointName,
                                       real maximumFrequency)
    signal signalRangeRequested(real startSample,
                                real sampleCount,
                                int pointLimit)
    signal spectrumRangeRequested(real minimumFrequency,
                                  real maximumFrequency,
                                  int pointLimit)

    function recordDisplayLabel(record) { return comparisonSpectrumController.recordDisplayLabel(record); }

    function clearComparisonSpectra(updateStatus) { comparisonSpectrumController.clearComparisonSpectra(updateStatus); }

    function comparisonIndexByKey(key) { return comparisonSpectrumController.comparisonIndexByKey(key); }

    function comparisonColor(index) { return comparisonSpectrumController.comparisonColor(index); }

    function appendComparisonRecord(record, points) { return comparisonSpectrumController.appendComparisonRecord(record, points); }

    function addComparisonResult(rawResult, fallbackPointName) { return comparisonSpectrumController.addComparisonResult(rawResult, fallbackPointName); }

    function applyComparisonSpectrumPreview(points, metadata) { comparisonSpectrumController.applyComparisonSpectrumPreview(points, metadata); }

    function failComparisonSpectrumPreview(message) { comparisonSpectrumController.failComparisonSpectrumPreview(message); }

    function prepareComparisonDrag(rawResult, fallbackPointName) { return comparisonSpectrumController.prepareComparisonDrag(rawResult, fallbackPointName); }

    function beginComparisonDrag() { comparisonSpectrumController.beginComparisonDrag(); }

    function cancelComparisonDrag() { comparisonSpectrumController.cancelComparisonDrag(); }

    function registerSpectrumDropTarget(target) { return comparisonSpectrumController.registerSpectrumDropTarget(target); }

    function unregisterSpectrumDropTarget(target) { comparisonSpectrumController.unregisterSpectrumDropTarget(target); }

    function finishComparisonDragAt(globalX, globalY) { return comparisonSpectrumController.finishComparisonDragAt(globalX, globalY); }

    function addPendingComparisonResult() { return comparisonSpectrumController.addPendingComparisonResult(); }

    function setComparisonSpectrumVisible(index, visible) { comparisonSpectrumController.setComparisonSpectrumVisible(index, visible); }

    function setComparisonSpectrumColor(index, value) { comparisonSpectrumController.setComparisonSpectrumColor(index, value); }

    function detachComparisonSpectrum(index) { return comparisonSpectrumController.detachComparisonSpectrum(index); }

    function restoreDetachedComparisonSpectrum(key) { return comparisonSpectrumController.restoreDetachedComparisonSpectrum(key); }

    function removeComparisonSpectrum(index) { comparisonSpectrumController.removeComparisonSpectrum(index); }

    function activeMarkerComparison() {
        var key = String(activeMarkerSpectrumKey || currentRecordKey)
        if (!key || key === currentRecordKey)
            return null
        var index = comparisonIndexByKey(key)
        return index >= 0 ? comparisonSpectra[index] : null
    }

    function activeMarkerRecordKey() {
        var key = String(activeMarkerSpectrumKey || currentRecordKey)
        return key.length > 0 ? key : currentRecordKey
    }

    function activeMarkerRecord() {
        return activeMarkerComparison() || selectedRecord
    }

    function activeMarkerSpectrumSeries() {
        var comparison = activeMarkerComparison()
        if (comparison) {
            return [{
                key: comparison.key,
                label: comparison.label,
                points: comparison.points || [],
                primary: false
            }]
        }
        if (!selectedRecord || spectrumPoints.length === 0)
            return []
        return [{
            key: currentRecordKey,
            label: recordDisplayLabel(selectedRecord),
            points: spectrumPoints,
            primary: true
        }]
    }

    function activeMarkerSpectrumRange() {
        var series = activeMarkerSpectrumSeries()
        return series.length > 0
                ? spectrumRangeForPoints(series[0].points)
                : { minimum: NaN, maximum: NaN }
    }

    function activateMarkerSpectrum(key) {
        var requestedKey = String(key || currentRecordKey)
        if (!requestedKey)
            return false
        if (requestedKey !== currentRecordKey
                && comparisonIndexByKey(requestedKey) < 0) {
            return false
        }
        if (requestedKey === activeMarkerRecordKey())
            return true

        saveCurrentMarkers()
        activeMarkerSpectrumKey = requestedKey
        restoreCurrentMarkers()
        var record = activeMarkerRecord()
        statusMessage = "Активный спектр для маркеров: "
                + recordDisplayLabel(record)
        return true
    }

    function filterSpectrumPointsForRecord(points, record) {
        var source = safeArray(points)
        var minimum = Number(record
                             ? record.spectrumMinimumFrequency : NaN)
        var maximum = Number(record
                             ? record.spectrumMaximumFrequency : NaN)
        if (!isFinite(minimum) || !isFinite(maximum)
                || maximum <= minimum) {
            return source
        }

        var filtered = []
        for (var index = 0; index < source.length; ++index) {
            var frequency = Number(source[index].x)
            if (isFinite(frequency)
                    && frequency >= minimum
                    && frequency <= maximum) {
                filtered.push(source[index])
            }
        }
        return filtered
    }

    function unitFromText(value) {
        var text = String(value || "")
        var match = text.match(
                    /(?:скз|rms)\s*[A-Za-zА-Яа-я]?\s*\(([^)]+)\)/i)
        if (!match)
            match = text.match(/[A-Za-zА-Яа-я]\s*\(([^)]+)\)/)
        return match ? String(match[1]).trim() : ""
    }

    function resolveMeasurementUnit(values, record) {
        for (var index = 0;
             values && index < values.length; ++index) {
            var item = values[index]
            var name = String(item.name || item.key || "")
            var lowerName = name.toLowerCase()
            if (lowerName.indexOf("скз") < 0
                    && lowerName.indexOf("rms") < 0) {
                continue
            }

            var explicitUnit = String(item.unit || "").trim()
            if (explicitUnit.length > 0)
                return unitFromText(explicitUnit) || explicitUnit

            var namedUnit = unitFromText(name)
            if (namedUnit.length > 0)
                return namedUnit
        }

        var measurementType = record
                ? String(record.measurementType || "") : ""
        return unitFromText(measurementType)
    }

    function setRecord(record) {
        saveCurrentMarkers()
        clearComparisonSpectra(false)
        explicitRecordUpdate = true
        selectedRecord = record || null
        explicitRecordUpdate = false
        currentRecordKey = recordKey(selectedRecord)
        activeMarkerSpectrumKey = currentRecordKey
        if (!selectedRecord) {
            spectrumPoints = []
            spectrumOverviewPoints = []
            spectrumBasePoints = []
            spectrumExceedancePoints = []
            spectrumBaseVisible = false
            spectrumExceedancesVisible = false
            spectrumBaseColor = "#DC2626"
            spectrumExceedanceColor = "#DC2626"
            spectrumExceedanceThreshold = NaN
            pointRmsValue = NaN
            pointHasExceedance = false
            pointStatePriority = NaN
            signalPoints = []
            scalarValues = []
            signalMetadata = null
            spectrumMetadata = null
            signalLoading = false
            spectrumLoading = false
            signalError = ""
            spectrumError = ""
            statusMessage = "Запись не выбрана"
            restoreCurrentMarkers()
            analysisUpdated(null)
            return
        }

        spectrumPoints = filterSpectrumPoints(
                    selectedRecord.spectrumPoints)
        spectrumOverviewPoints = spectrumPoints
        spectrumBasePoints = filterSpectrumPoints(
                    selectedRecord.spectrumBasePoints)
        spectrumExceedancePoints = filterSpectrumPoints(
                    selectedRecord.spectrumExceedancePoints)
        spectrumBaseVisible = Boolean(
                    selectedRecord.spectrumBaseVisible)
        spectrumExceedancesVisible = Boolean(
                    selectedRecord.spectrumExceedancesVisible)
        spectrumBaseColor = String(
                    selectedRecord.spectrumBaseColor || "#DC2626")
        spectrumExceedanceColor = String(
                    selectedRecord.stateColor
                    || selectedRecord.spectrumExceedanceColor
                    || "#DC2626")
        spectrumExceedanceThreshold = Number(
                    selectedRecord.spectrumExceedanceThreshold)
        pointRmsValue = Number(selectedRecord.rmsValue)
        pointHasExceedance = Boolean(
                    selectedRecord.hasExceedance)
        pointStatePriority = Number(selectedRecord.statePriority)
        signalPoints = safeArray(selectedRecord.signalPoints)
        scalarValues = safeArray(selectedRecord.scalarValues)
        signalMetadata = null
        spectrumMetadata = null
        signalLoading = false
        spectrumLoading = false
        signalError = ""
        spectrumError = ""

        updatePreviewStatus()
        restoreCurrentMarkers()
        analysisUpdated(selectedRecord)
    }

    function beginPreviewLoading() {
        if (!selectedRecord)
            return
        signalLoading = true
        spectrumLoading = true
        signalError = ""
        spectrumError = ""
        statusMessage = "Загрузка временного сигнала и спектра…"
    }

    function beginSignalPreviewLoading() {
        if (!selectedRecord)
            return
        signalLoading = true
        spectrumLoading = false
        signalError = ""
        spectrumError = ""
        statusMessage = "Загрузка временного сигнала…"
    }

    function useEmbeddedSpectrum(points) {
        var filteredPoints = filterSpectrumPoints(points)
        spectrumMetadata = {
            source: "result-plots",
            exact: true,
            returnedPoints: filteredPoints.length,
            minimumFrequency: filteredPoints.length > 0
                              ? Number(filteredPoints[0].x) : NaN,
            maximumFrequency: filteredPoints.length > 0
                              ? Number(filteredPoints[filteredPoints.length - 1].x) : NaN
        }
        spectrumPoints = filteredPoints
        spectrumOverviewPoints = filteredPoints
        spectrumLoading = false
        spectrumError = ""
        updatePreviewStatus()
        analysisUpdated(selectedRecord)
    }

    function applySignalPreview(points, metadata) {
        var nextPoints = safeArray(points)
        // Do not replace a valid overview/range with an unusable one-point
        // response produced at an extreme zoom boundary.
        if (nextPoints.length < 2 && signalPoints.length >= 2) {
            signalLoading = false
            signalError = ""
            updatePreviewStatus()
            return
        }
        signalMetadata = metadata || null
        signalPoints = nextPoints
        signalLoading = false
        signalError = ""
        updatePreviewStatus()
        analysisUpdated(selectedRecord)
    }

    function requestSignalRange(minimumTime, maximumTime, pointLimit) {
        var metadata = signalMetadata
        if (!selectedRecord || !metadata)
            return false

        var sampleRate = Number(metadata.sampleRate)
        var totalSamples = Number(metadata.totalSamples)
        if (!isFinite(sampleRate) || sampleRate <= 0
                || !isFinite(totalSamples) || totalSamples <= 0) {
            return false
        }

        var fromTime = Math.max(0, Number(minimumTime))
        var toTime = Math.max(fromTime, Number(maximumTime))
        if (!isFinite(fromTime) || !isFinite(toTime) || toTime <= fromTime)
            return false

        var startSample = Math.max(0, Math.min(totalSamples - 1,
                                               Math.floor(fromTime * sampleRate)))
        var endSample = Math.max(startSample + 1,
                                  Math.min(totalSamples,
                                           Math.ceil(toTime * sampleRate)))
        var sampleCount = endSample - startSample

        // A polyline requires at least two intervals.  Deep programmatic
        // zooms can otherwise collapse the request to a single WAV sample.
        var minimumSampleCount = Math.min(totalSamples, 4)
        if (sampleCount < minimumSampleCount) {
            var centerSample = (startSample + endSample) / 2
            startSample = Math.max(0, Math.min(
                        totalSamples - minimumSampleCount,
                        Math.floor(centerSample - minimumSampleCount / 2)))
            endSample = startSample + minimumSampleCount
            sampleCount = minimumSampleCount
        }

        var loadedStart = Number(metadata.startSample)
        var loadedCount = Number(metadata.sampleCount)
        if (isFinite(loadedStart) && isFinite(loadedCount)
                && Math.floor(loadedStart) === startSample
                && Math.ceil(loadedCount) === sampleCount) {
            return false
        }

        var budget = Math.max(512, Math.min(8192,
                    Math.round(Number(pointLimit) || signalPointBudget)))
        signalRangeRequested(startSample, sampleCount, budget)
        return true
    }

    function applySpectrumPreview(points, metadata) {
        var nextMetadata = metadata || null
        var filteredPoints = filterSpectrumPoints(points)
        // Keep the previous valid spectrum when a range narrower than the
        // FFT resolution happens to return fewer than two frequency bins.
        if (filteredPoints.length < 2 && spectrumPoints.length >= 2) {
            spectrumLoading = false
            spectrumError = ""
            updatePreviewStatus()
            return
        }
        spectrumMetadata = nextMetadata
        var loadedMinimum = Number(spectrumMetadata
                                   ? spectrumMetadata.minimumFrequency : NaN)
        var loadedMaximum = Number(spectrumMetadata
                                   ? spectrumMetadata.maximumFrequency : NaN)
        var fullMinimum = Number(spectrumMinimumFrequency)
        var fullMaximum = Number(spectrumMaximumFrequency)
        var tolerance = isFinite(fullMinimum) && isFinite(fullMaximum)
                ? Math.max(0.000000001,
                           (fullMaximum - fullMinimum) * 0.000000001)
                : 0.000000001
        if (spectrumOverviewPoints.length < 2
                || (isFinite(loadedMinimum) && isFinite(loadedMaximum)
                    && isFinite(fullMinimum) && isFinite(fullMaximum)
                    && loadedMinimum <= fullMinimum + tolerance
                    && loadedMaximum >= fullMaximum - tolerance)) {
            spectrumOverviewPoints = filteredPoints
        }
        spectrumPoints = filteredPoints
        spectrumLoading = false
        spectrumError = ""
        updatePreviewStatus()
        analysisUpdated(selectedRecord)
    }

    function requestSpectrumRange(minimumFrequency, maximumFrequency,
                                  pointLimit) {
        if (!selectedRecord)
            return false

        var metadata = spectrumMetadata || ({})
        // Native result analyzer zooms the already stored plot series.  Do
        // the same here: never replace the exact result with a WAV FFT.
        if (metadata.exact === true
                || String(metadata.source || "") === "result-plots") {
            return false
        }
        var fullMinimum = Number(spectrumMinimumFrequency)
        var fullMaximum = Number(spectrumMaximumFrequency)
        if (!isFinite(fullMinimum))
            fullMinimum = Number(metadata.fullMinimumFrequency)
        if (!isFinite(fullMaximum) || fullMaximum <= fullMinimum)
            fullMaximum = Number(metadata.fullMaximumFrequency)
        if (!isFinite(fullMinimum))
            fullMinimum = 0
        if (!isFinite(fullMaximum) || fullMaximum <= fullMinimum)
            return false

        var fromFrequency = Math.max(fullMinimum,
                                     Number(minimumFrequency))
        var toFrequency = Math.min(fullMaximum,
                                   Number(maximumFrequency))
        if (!isFinite(fromFrequency) || !isFinite(toFrequency)
                || toFrequency <= fromFrequency) {
            return false
        }

        // Load guard samples on both sides of the visible interval.  The
        // spectrum API returns frequency bins whose centres are inside the
        // requested range.  Without this guard the first/last returned bin
        // can be noticeably far from the viewport edge after a deep zoom,
        // so the polyline appears to be cut off in the middle of the chart.
        var frequencyResolution = Number(metadata.frequencyResolution)
        if (isFinite(frequencyResolution) && frequencyResolution > 0
                && toFrequency - fromFrequency
                   < frequencyResolution * 2) {
            var requiredSpan = Math.min(fullMaximum - fullMinimum,
                                        frequencyResolution * 2)
            var centerFrequency = (fromFrequency + toFrequency) / 2
            fromFrequency = centerFrequency - requiredSpan / 2
            toFrequency = centerFrequency + requiredSpan / 2
            if (fromFrequency < fullMinimum) {
                fromFrequency = fullMinimum
                toFrequency = fullMinimum + requiredSpan
            }
            if (toFrequency > fullMaximum) {
                toFrequency = fullMaximum
                fromFrequency = fullMaximum - requiredSpan
            }
        }
        var visibleSpan = toFrequency - fromFrequency
        var guardSpan = Math.max(visibleSpan * 0.5,
                                 isFinite(frequencyResolution)
                                 && frequencyResolution > 0
                                 ? frequencyResolution * 1.1 : 0)
        var requestedMinimum = Math.max(fullMinimum,
                                        fromFrequency - guardSpan)
        var requestedMaximum = Math.min(fullMaximum,
                                        toFrequency + guardSpan)

        var loadedMinimum = Number(metadata.minimumFrequency)
        var loadedMaximum = Number(metadata.maximumFrequency)
        var tolerance = Math.max(0.000000001,
                                 (fullMaximum - fullMinimum) * 0.000000001)
        if (isFinite(loadedMinimum) && isFinite(loadedMaximum)
                && loadedMinimum <= requestedMinimum + tolerance
                && loadedMaximum >= requestedMaximum - tolerance) {
            return false
        }

        var visibleBudget = Math.max(256, Math.min(8192,
                    Math.round(Number(pointLimit) || spectrumPointBudget)))
        var requestedSpan = requestedMaximum - requestedMinimum
        var budget = Math.max(visibleBudget, Math.min(8192,
                    Math.ceil(visibleBudget * requestedSpan / visibleSpan)))
        spectrumRangeRequested(requestedMinimum, requestedMaximum, budget)
        return true
    }

    function filterSpectrumPoints(points) {
        var source = safeArray(points)
        var minimum = Number(spectrumMinimumFrequency)
        var maximum = Number(spectrumMaximumFrequency)
        if (!isFinite(minimum) || !isFinite(maximum)
                || maximum <= minimum) {
            return source
        }

        var filtered = []
        for (var index = 0; index < source.length; ++index) {
            var frequency = Number(source[index].x)
            if (isFinite(frequency)
                    && frequency >= minimum
                    && frequency <= maximum) {
                filtered.push(source[index])
            }
        }
        return filtered
    }

    function failPreview(previewType, message) {
        if (previewType === "signal") {
            signalLoading = false
            signalError = String(message)
        } else if (previewType === "spectrum") {
            spectrumLoading = false
            spectrumError = String(message)
        }
        updatePreviewStatus()
    }

    function updatePreviewStatus() {
        if (!selectedRecord) {
            statusMessage = "Запись не выбрана"
            return
        }
        if (signalLoading || spectrumLoading) {
            statusMessage = "Загрузка "
                    + (signalLoading && spectrumLoading
                       ? "временного сигнала и спектра"
                       : signalLoading
                         ? "временного сигнала" : "спектра")
                    + "…"
            return
        }
        if (hasSpectrum && hasSignal) {
            statusMessage = "Спектр и временной сигнал загружены"
        } else if (hasSpectrum) {
            statusMessage = signalError.length > 0
                    ? "Спектр загружен; сигнал: " + signalError
                    : "Спектр загружен; временной сигнал отсутствует"
        } else if (hasSignal) {
            statusMessage = spectrumError.length > 0
                    ? "Сигнал загружен; спектр: " + spectrumError
                    : "Временной сигнал загружен; спектр отсутствует"
        } else if (signalError.length > 0
                   || spectrumError.length > 0) {
            statusMessage = (signalError.length > 0
                             ? "Сигнал: " + signalError : "")
                    + (signalError.length > 0
                       && spectrumError.length > 0 ? "; " : "")
                    + (spectrumError.length > 0
                       ? "Спектр: " + spectrumError : "")
        } else {
            statusMessage = "В записи нет доступных графических серий"
        }
    }

    function safeArray(value) {
        if (!value || value.length === undefined)
            return []
        if (Array.isArray(value))
            return value

        var result = []
        for (var i = 0; i < value.length; ++i)
            result.push(value[i])
        return result
    }

    function visibleSpectrumSeries() {
        var series = []
        if (primarySpectrumVisible && spectrumPoints.length > 0) {
            series.push({
                key: currentRecordKey,
                label: recordDisplayLabel(selectedRecord),
                points: spectrumPoints,
                primary: true
            })
        }
        for (var index = 0;
             index < comparisonSpectra.length; ++index) {
            var comparison = comparisonSpectra[index]
            if (!comparison || comparison.visible === false
                    || !comparison.points
                    || comparison.points.length === 0) {
                continue
            }
            series.push({
                key: comparison.key,
                label: comparison.label,
                points: comparison.points,
                primary: false
            })
        }
        return series
    }

    function nearestIndexInPoints(points, frequency) {
        if (!points || points.length === 0)
            return -1
        var target = Number(frequency)
        if (!isFinite(target))
            return -1

        var low = 0
        var high = points.length
        while (low < high) {
            var middle = (low + high) >> 1
            if (Number(points[middle].x) < target)
                low = middle + 1
            else
                high = middle
        }
        if (low <= 0)
            return 0
        if (low >= points.length)
            return points.length - 1
        return Math.abs(Number(points[low - 1].x) - target)
                <= Math.abs(Number(points[low].x) - target)
                ? low - 1 : low
    }

    function spectrumRangeForPoints(points) {
        var minimum = NaN
        var maximum = NaN
        for (var index = 0; points
             && index < points.length; ++index) {
            var frequency = Number(points[index].x)
            if (!isFinite(frequency))
                continue
            minimum = !isFinite(minimum)
                    ? frequency : Math.min(minimum, frequency)
            maximum = !isFinite(maximum)
                    ? frequency : Math.max(maximum, frequency)
        }
        return { minimum: minimum, maximum: maximum }
    }

    function calculateVisibleSpectrumRange() {
        var minimum = NaN
        var maximum = NaN
        var series = visibleSpectrumSeries()
        for (var index = 0; index < series.length; ++index) {
            var range = spectrumRangeForPoints(series[index].points)
            if (!isFinite(range.minimum) || !isFinite(range.maximum))
                continue
            minimum = !isFinite(minimum)
                    ? range.minimum : Math.min(minimum, range.minimum)
            maximum = !isFinite(maximum)
                    ? range.maximum : Math.max(maximum, range.maximum)
        }
        return { minimum: minimum, maximum: maximum }
    }

    function visibleSpectrumRange() {
        return visibleSpectrumRangeCache
    }

    function nearestPeakInPoints(points, target, window,
                                 requireSignificantPeak) {
        if (!points || points.length < 2)
            return null

        var amplitudes = []
        for (var amplitudeIndex = 0;
             amplitudeIndex < points.length; ++amplitudeIndex) {
            var sourceAmplitude = Math.abs(
                        Number(points[amplitudeIndex].y))
            if (isFinite(sourceAmplitude))
                amplitudes.push(sourceAmplitude)
        }
        amplitudes.sort(function(left, right) {
            return left - right
        })
        var noiseFloor = amplitudes.length > 0
                ? amplitudes[Math.floor(amplitudes.length / 2)] : 0
        var maximumAmplitude = amplitudes.length > 0
                ? amplitudes[amplitudes.length - 1] : 0
        var amplitudeThreshold = Math.max(
                    noiseFloor * 4, maximumAmplitude * 0.0001)
        var prominenceThreshold = Math.max(
                    noiseFloor * 0.5, maximumAmplitude * 0.00001)

        var best = null
        for (var index = 1; index < points.length - 1; ++index) {
            var frequency = Number(points[index].x)
            var amplitude = Math.abs(Number(points[index].y))
            if (!isFinite(frequency) || !isFinite(amplitude)
                    || Math.abs(frequency - target) > window) {
                continue
            }
            var previous = Math.abs(Number(points[index - 1].y))
            var next = Math.abs(Number(points[index + 1].y))
            if (amplitude < previous || amplitude < next)
                continue
            if (requireSignificantPeak
                    && (amplitude < amplitudeThreshold
                        || amplitude - Math.max(previous, next)
                           < prominenceThreshold)) {
                continue
            }
            var distance = Math.abs(frequency - target)
            if (!best || distance < best.distance
                    || (Math.abs(distance - best.distance) < 0.000001
                        && amplitude > best.amplitude)) {
                best = {
                    frequency: frequency,
                    amplitude: amplitude,
                    distance: distance,
                    index: index
                }
            }
        }
        return best
    }

    function rebuildSpectrumIndex() {
        var squares = [0]
        var counts = [0]
        var amplitudes = []
        var sorted = true
        var previousX = Number.NEGATIVE_INFINITY
        var minimumX = 0
        var maximumX = 1
        var maximumAmplitude = 0
        var amplitudeSampleStep = Math.max(
                    1, Math.floor(spectrumPoints.length / 2048))

        for (var i = 0; i < spectrumPoints.length; ++i) {
            var point = spectrumPoints[i]
            var x = Number(point.x)
            var y = Number(point.y)
            if (i === 0 && isFinite(x))
                minimumX = x
            if (isFinite(x)) {
                if (x < previousX)
                    sorted = false
                previousX = x
                maximumX = x
            }
            squares.push(squares[i]
                         + (isFinite(y) ? y * y : 0))
            counts.push(counts[i] + (isFinite(y) ? 1 : 0))
            if (isFinite(y)) {
                var absoluteAmplitude = Math.abs(y)
                maximumAmplitude = Math.max(
                            maximumAmplitude, absoluteAmplitude)
                if (i % amplitudeSampleStep === 0)
                    amplitudes.push(absoluteAmplitude)
            }
        }

        spectrumPrefixSquares = squares
        spectrumPrefixCounts = counts
        spectrumSorted = sorted
        cachedSpectrumMinimumX = minimumX
        cachedSpectrumMaximumX = spectrumPoints.length > 0
                ? maximumX : 1
        amplitudes.sort(function(left, right) {
            return left - right
        })
        cachedSpectrumNoiseFloor = amplitudes.length > 0
                ? amplitudes[Math.floor(amplitudes.length / 2)] : 0
        cachedSpectrumMaximumAmplitude = maximumAmplitude
    }

    function lowerSpectrumBound(value) {
        var low = 0
        var high = spectrumPoints.length
        while (low < high) {
            var middle = (low + high) >> 1
            if (Number(spectrumPoints[middle].x) < value)
                low = middle + 1
            else
                high = middle
        }
        return low
    }

    function upperSpectrumBound(value) {
        var low = 0
        var high = spectrumPoints.length
        while (low < high) {
            var middle = (low + high) >> 1
            if (Number(spectrumPoints[middle].x) <= value)
                low = middle + 1
            else
                high = middle
        }
        return low
    }

    function nearestSpectrumIndex(frequency) {
        if (spectrumPoints.length === 0)
            return -1

        if (!spectrumSorted) {
            var fallbackIndex = 0
            var fallbackDistance = Number.POSITIVE_INFINITY
            for (var i = 0; i < spectrumPoints.length; ++i) {
                var currentDistance = Math.abs(
                            Number(spectrumPoints[i].x) - frequency)
                if (currentDistance < fallbackDistance) {
                    fallbackDistance = currentDistance
                    fallbackIndex = i
                }
            }
            return fallbackIndex
        }

        var index = lowerSpectrumBound(frequency)
        if (index <= 0)
            return 0
        if (index >= spectrumPoints.length)
            return spectrumPoints.length - 1
        return Math.abs(Number(spectrumPoints[index - 1].x)
                        - frequency)
                <= Math.abs(Number(spectrumPoints[index].x)
                            - frequency)
                ? index - 1 : index
    }

    function nextMarkerColor() { return spectrumMarkerController.nextMarkerColor(); }
    function addBand() { return spectrumMarkerController.addBand(); }

    function addBandRange(requestedLeft, requestedRight) { return spectrumMarkerController.addBandRange(requestedLeft, requestedRight); }

    function updateBand(index, left, right) { spectrumMarkerController.updateBand(index, left, right); }

    function addHarmonic(requestedFrequency, snapToMaximum) { return spectrumMarkerController.addHarmonic(requestedFrequency, snapToMaximum); }

    function hasHarmonicAtMaximum() { return spectrumMarkerController.hasHarmonicAtMaximum(); }

    function updateHarmonicFrequency(index, frequency) { spectrumMarkerController.updateHarmonicFrequency(index, frequency); }

    function spectrumMaximumAmplitudeFrequency() { return spectrumMarkerController.spectrumMaximumAmplitudeFrequency(); }

    function dominantSpectrumPeak() { return spectrumMarkerController.dominantSpectrumPeak(); }
    function nearestSpectrumPeak(targetFrequency, tolerance, requireSignificantPeak) { return spectrumMarkerController.nearestSpectrumPeak(targetFrequency, tolerance, requireSignificantPeak); }

    function peakSearchTolerance(targetFrequency) { return spectrumMarkerController.peakSearchTolerance(targetFrequency); }

    function harmonicPeakFrequency(baseFrequency, order) { return spectrumMarkerController.harmonicPeakFrequency(baseFrequency, order); }

    function selectMarker(type, index) { spectrumMarkerController.selectMarker(type, index); }

    function removeBand(index) { return spectrumMarkerController.removeBand(index); }

    function removeHarmonic(index) { return spectrumMarkerController.removeHarmonic(index); }

    function clearMarkers(markerType) { spectrumMarkerController.clearMarkers(markerType); }

    function rmsForPoints(points, left, right) { return spectrumMarkerController.rmsForPoints(points, left, right); }

    function calculateBandRms(left, right) { return spectrumMarkerController.calculateBandRms(left, right); }

    function spectrumCursorMetrics(frequency) { return spectrumMarkerController.spectrumCursorMetrics(frequency); }

    function localCursorHalfWindowForPoints(points, index) { return spectrumMarkerController.localCursorHalfWindowForPoints(points, index); }

    function localCursorHalfWindow(index) { return spectrumMarkerController.localCursorHalfWindow(index); }

    function spectrumMinimumX() { return spectrumMarkerController.spectrumMinimumX(); }

    function spectrumMaximumX() { return spectrumMarkerController.spectrumMaximumX(); }

    function recordKey(record) { return spectrumMarkerController.recordKey(record); }

    function firstNonEmpty(object, keys) { return spectrumMarkerController.firstNonEmpty(object, keys); }

    function modelToArray(model) { return spectrumMarkerController.modelToArray(model); }

    function copyMarkerArray(source) { return spectrumMarkerController.copyMarkerArray(source); }

    function markerFrequencyExists(markers, frequency) { return spectrumMarkerController.markerFrequencyExists(markers, frequency); }

    function bandRangeExists(markers, left, right) { return spectrumMarkerController.bandRangeExists(markers, left, right); }

    function applySingleHarmonicMarkersToExceedances(record, exceedancePoints) { return spectrumMarkerController.applySingleHarmonicMarkersToExceedances(record, exceedancePoints); }

    function maximumSpectrumPoint(points) { return spectrumMarkerController.maximumSpectrumPoint(points); }

    function applySingleHarmonicMarkerToRecordMaximum(record) { return spectrumMarkerController.applySingleHarmonicMarkerToRecordMaximum(record); }

    function applySingleHarmonicMarkerToRecordRange(record, rangeFrom, rangeTo) { return spectrumMarkerController.applySingleHarmonicMarkerToRecordRange(record, rangeFrom, rangeTo); }

    function applySingleHarmonicMarkerToRecordExceedance(record) { return spectrumMarkerController.applySingleHarmonicMarkerToRecordExceedance(record); }

    function applySingleBandMarkerToRecordRange(record, rangeFrom, rangeTo) { return spectrumMarkerController.applySingleBandMarkerToRecordRange(record, rangeFrom, rangeTo); }

    function clearMarkersForRecord(record) { return spectrumMarkerController.clearMarkersForRecord(record); }

    function applyMarkerToRecords(records, markerType, firstFrequency, secondFrequency, harmonicCount) { return spectrumMarkerController.applyMarkerToRecords(records, markerType, firstFrequency, secondFrequency, harmonicCount); }

    function cloneAnalysisStates(sourceStates) { return spectrumMarkerController.cloneAnalysisStates(sourceStates); }

    function markerWorkingStates() { return spectrumMarkerController.markerWorkingStates(); }

    function publishMarkerStates(states, currentRecordUpdated) { spectrumMarkerController.publishMarkerStates(states, currentRecordUpdated); }

    function beginMarkerBatch() { return spectrumMarkerController.beginMarkerBatch(); }

    function commitMarkerBatch() { return spectrumMarkerController.commitMarkerBatch(); }

    function rollbackMarkerBatch() { spectrumMarkerController.rollbackMarkerBatch(); }

    function undoLastMarkerApplication() { return spectrumMarkerController.undoLastMarkerApplication(); }

    function saveCurrentMarkers() { spectrumMarkerController.saveCurrentMarkers(); }

    function restoreCurrentMarkers() { spectrumMarkerController.restoreCurrentMarkers(); }
    function markerStateForRecordKey(recordKey) { return spectrumMarkerController.markerStateForRecordKey(recordKey); }
    function replaceMarkerStateForRecordKey(recordKey, state) { return spectrumMarkerController.replaceMarkerStateForRecordKey(recordKey, state); }

    onSelectedRecordChanged: {
        if (explicitRecordUpdate)
            return
        var record = selectedRecord
        spectrumPoints = record
                ? filterSpectrumPoints(record.spectrumPoints) : []
        signalPoints = record
                ? safeArray(record.signalPoints) : []
        scalarValues = record
                ? safeArray(record.scalarValues) : []

        if (!record)
            statusMessage = "Запись не выбрана"
        else if (spectrumPoints.length > 1
                 && signalPoints.length > 1)
            statusMessage = "Спектр и временной сигнал загружены"
        else if (spectrumPoints.length > 1)
            statusMessage = "Спектр загружен; временной сигнал отсутствует"
        else if (signalPoints.length > 1)
            statusMessage = "Временной сигнал загружен; спектр отсутствует"
        else
            statusMessage = "В записи нет доступных графических серий"

        analysisUpdated(record)
    }

    onSpectrumPointsChanged: rebuildSpectrumIndex()
    onCurrentRecordKeyChanged: signalBandController.switchRecord(currentRecordKey)
}
