import QtQml

QtObject {
    id: adapter

    property var seriesParserObject: ResultSeriesParser {
        id: resultSeriesParser
        adapter: adapter
    }

    property var masterValuesAdapter: null
    property string errorMessage: ""
    property real defaultExceedanceThreshold: 10
    property var resultMapCacheObjects: []
    property var resultMapCacheValues: []
    property int resultMapCacheLimit: 64

    signal parsingWarning(string message)

    function normalizeSummary(result, fallbackPointName) {
        if (!result)
            return null

        var name = pointName(result, fallbackPointName)
        var trafficState = masterValuesAdapter
                ? masterValuesAdapter.resultState(result) : null
        return {
            key: resultKey(result, name),
            recordUuid: immutableRecordUuid(result),
            tag: resultTag(result),
            pointName: name,
            measurementType: measurementType(result),
            recordTime: recordTime(result),
            recordFileName: recordFileName(result),
            hasExceedance: trafficState && trafficState.known
                           ? Boolean(trafficState.hasExceedance)
                           : hasRmsExceedance(result, trafficState),
            stateColor: trafficState ? trafficState.color : "",
            statePriority: trafficState
                           ? trafficState.priority : NaN,
            stateKnown: trafficState
                        ? Boolean(trafficState.known) : false,
            rawResult: result
        }
    }

    function normalize(result, fallbackPointName, includeSeries,
                       includeSignalSeries) {
        errorMessage = ""

        if (!result)
            return null

        var name = pointName(result, fallbackPointName)
        var type = measurementType(result)
        var loadEmbeddedSeries = includeSeries !== false
        var spectrum = loadEmbeddedSeries
                ? extractSpectrum(result) : []
        var signal = loadEmbeddedSeries && includeSignalSeries !== false
                ? extractSignal(result) : []
        var scalars = extractScalarValues(result)
        var spectrumTools = extractSpectrumTools(result)
        var threshold = Number(spectrumTools.threshold)
        var trafficState = masterValuesAdapter
                ? masterValuesAdapter.resultState(result) : null
        if (!isFinite(threshold))
            threshold = exceedanceThreshold(result, trafficState)
        var rmsValue = rmsValueFromScalars(scalars)
        if (trafficState && trafficState.known
                && trafficState.source) {
            rmsValue = Number(trafficState.source.value)
            threshold = trafficState.priority >= 2
                    ? Number(trafficState.source.cd)
                    : Number(trafficState.source.bc)
        }
        var hasExceedance = trafficState && trafficState.known
                ? Boolean(trafficState.hasExceedance)
                : isFinite(rmsValue) && isFinite(threshold)
                  && rmsValue > threshold
        var ranges = diagnosticFrequencyRanges(
                    result, scalars, type)

        return {
            key: resultKey(result, name),
            recordUuid: immutableRecordUuid(result),
            tag: resultTag(result),
            pointName: name,
            measurementType: type,
            recordTime: recordTime(result),
            recordFileName: recordFileName(result),
            scalarValues: scalars,
            spectrumPoints: spectrum,
            spectrumBasePoints: spectrumTools.basePoints,
            spectrumExceedancePoints: spectrumTools.exceedancePoints,
            spectrumBaseVisible: spectrumTools.baseVisible,
            spectrumExceedancesVisible:
                spectrumTools.exceedancesVisible,
            spectrumBaseColor: spectrumTools.baseColor,
            spectrumExceedanceColor:
                trafficState && trafficState.known
                ? trafficState.color
                : spectrumTools.exceedanceColor,
            spectrumExceedanceThreshold:
                threshold,
            rmsValue: rmsValue,
            hasExceedance: hasExceedance,
            stateColor: trafficState ? trafficState.color : "",
            statePriority: trafficState
                           ? trafficState.priority : NaN,
            stateKnown: trafficState
                        ? Boolean(trafficState.known) : false,
            signalPoints: signal,
            rmsMinimumFrequency: ranges.rmsMinimum,
            rmsMaximumFrequency: ranges.rmsMaximum,
            spectrumMinimumFrequency: ranges.spectrumMinimum,
            spectrumMaximumFrequency: ranges.spectrumMaximum,
            hasSpectrum: spectrum.length > 1,
            hasSignal: signal.length > 1,
            rawResult: result
        }
    }

    function safeText(value, fallback) {
        if (value === undefined || value === null
                || String(value).length === 0) {
            return fallback === undefined ? "—" : fallback
        }
        return String(value)
    }

    function safeNumber(value, fallback) {
        var number = Number(value)
        if (isNaN(number))
            return fallback === undefined ? NaN : fallback
        return number
    }

    function isArray(value) {
        return Array.isArray(value)
    }

    function toArray(value) {
        var array = []
        if (!value || value.length === undefined)
            return array
        for (var i = 0; i < value.length; ++i)
            array.push(value[i])
        return array
    }

    function resultMap(result) {
        if (!result)
            return ({})

        for (var cacheIndex = resultMapCacheObjects.length - 1;
             cacheIndex >= 0; --cacheIndex) {
            if (resultMapCacheObjects[cacheIndex] === result)
                return resultMapCacheValues[cacheIndex]
        }

        var resolved = result
        if (result.resultJSON !== undefined
                && result.resultJSON !== null) {
            var resultJson = result.resultJSON
            if (typeof resultJson === "string") {
                try {
                    resultJson = JSON.parse(resultJson)
                } catch (error) {
                    setWarning("Не удалось разобрать resultJSON: "
                               + error)
                    return ({})
                }
            }
            if (resultJson && typeof resultJson === "object")
                resolved = resultJson
        } else if (result.results
                   && typeof result.results === "object") {
            resolved = result.results
        } else if (result.values && typeof result.values === "object"
                && !isArray(result.values)) {
            resolved = result.values
        } else if (result.data && typeof result.data === "object"
                && !isArray(result.data)) {
            resolved = result.data
        }

        var objects = resultMapCacheObjects
        var values = resultMapCacheValues
        objects.push(result)
        values.push(resolved)
        while (objects.length > resultMapCacheLimit) {
            objects.shift()
            values.shift()
        }
        return resolved
    }

    function firstDefined(object, keys) {
        if (!object)
            return undefined
        for (var i = 0; i < keys.length; ++i) {
            var key = keys[i]
            if (object[key] !== undefined && object[key] !== null)
                return object[key]
        }
        return undefined
    }

    function recordTime(result) {
        return safeText(firstDefined(result, [
            "recordDate", "calcDate", "time", "dateTime", "createdAt",
            "timestamp", "date", "recordTime"
        ]), "—")
    }

    function recordFileName(result) {
        if (!result)
            return "—"
        if (result.recordOptions) {
            var optionName = firstDefined(result.recordOptions, [
                "recordFileName", "fileName", "filename",
                "recordPath", "filePath"
            ])
            if (optionName !== undefined)
                return safeText(optionName)
        }
        return safeText(firstDefined(result, [
            "recordFileName", "fileName", "filename", "recordName"
        ]), "—")
    }

    function resultTag(result) {
        var map = resultMap(result)
        return safeText(firstDefined(result, ["tag", "resultTag"])
                        || firstDefined(map, ["tag", "INFO / Тег"]), "—")
    }

    function pointName(result, fallbackPointName) {
        var map = resultMap(result)
        var value = firstDefined(map, [
            "INFO / Точка",
            "INFO / Полное имя точки",
            "Точка",
            "Метка точки",
            "Ключ точки",
            "point",
            "label"
        ])
        if (value === undefined) {
            value = firstDefined(result.pointOptions, [
                "name", "label", "title", "displayName"
            ])
        }
        if (value === undefined) {
            value = firstDefined(result, [
                "pointName", "nodeName", "point", "label"
            ])
        }
        if (value === undefined
                && fallbackPointName !== undefined
                && fallbackPointName !== null
                && String(fallbackPointName).length > 0) {
            value = fallbackPointName
        }
        return safeText(value, "Неизвестная точка")
    }

    function measurementType(result) {
        var map = resultMap(result)
        var value = firstDefined(map, [
            "INFO / Тип измерения",
            "Тип измерения",
            "measurementType",
            "type"
        ])
        if (value === undefined)
            value = firstDefined(result, ["measurementType", "type"])
        return safeText(value, "—")
    }

    function extractScalarValues(result) {
        var map = resultMap(result)
        var values = []
        collectScalarValues(map, "", values, 5)
        return values
    }

    function rmsValueFromScalars(values) {
        var maximum = NaN
        for (var index = 0;
             values && index < values.length; ++index) {
            var scalar = values[index]
            var value = Number(scalar.value)
            if (isFinite(value)
                    && (!isFinite(maximum) || value > maximum)) {
                maximum = value
            }
        }
        return maximum
    }

    function rmsValue(result) {
        return rmsValueFromScalars(extractScalarValues(result))
    }

    function exceedanceThreshold(result, resolvedState) {
        if (masterValuesAdapter) {
            var state = resolvedState === undefined
                    ? masterValuesAdapter.resultState(result)
                    : resolvedState
            if (state.known && state.source) {
                return state.priority >= 2
                        ? Number(state.source.cd)
                        : Number(state.source.bc)
            }
        }
        var savedThreshold = findSpectrumThreshold(result, 5)
        if (isFinite(savedThreshold))
            return savedThreshold

        var optionThreshold = configuredThreshold(result)
        return isFinite(optionThreshold)
                ? optionThreshold : defaultExceedanceThreshold
    }

    function hasRmsExceedance(result, resolvedState) {
        if (masterValuesAdapter) {
            var state = resolvedState === undefined
                    ? masterValuesAdapter.resultState(result)
                    : resolvedState
            if (state && state.known)
                return Boolean(state.hasExceedance)
        }
        var value = rmsValue(result)
        var threshold = exceedanceThreshold(result, state)
        return isFinite(value) && isFinite(threshold)
                && value > threshold
    }

    function configuredThreshold(result) {
        if (!result || typeof result !== "object")
            return NaN

        var candidates = [
            result.customOptions,
            result.objectOptions,
            result.pointOptions
        ]
        for (var index = 0;
             index < candidates.length; ++index) {
            var options = parseObject(candidates[index])
            if (!options || typeof options !== "object")
                continue

            var nested = parseObject(
                        options.customOptionsString)
            if (nested && typeof nested === "object"
                    && isFinite(Number(nested.threshold))) {
                return Number(nested.threshold)
            }
            if (isFinite(Number(options.threshold)))
                return Number(options.threshold)
        }
        return NaN
    }

    function diagnosticFrequencyRanges(result, scalarValues,
                                       measurementName) {
        var rmsRange = null
        for (var index = 0;
             scalarValues && index < scalarValues.length;
             ++index) {
            var scalar = scalarValues[index]
            var name = String(scalar.name || scalar.key || "")
            var lowerName = name.toLowerCase()
            if (lowerName.indexOf("скз") < 0
                    && lowerName.indexOf("rms") < 0) {
                continue
            }
            rmsRange = frequencyRangeFromText(name)
            if (rmsRange)
                break
        }

        var spectrumRange = spectrumRangeFromResult(result, 6)
        if (!spectrumRange)
            spectrumRange = frequencyRangeFromText(measurementName)

        return {
            rmsMinimum: rmsRange ? rmsRange.minimum : NaN,
            rmsMaximum: rmsRange ? rmsRange.maximum : NaN,
            spectrumMinimum:
                spectrumRange ? spectrumRange.minimum : NaN,
            spectrumMaximum:
                spectrumRange ? spectrumRange.maximum : NaN
        }
    }

    function frequencyRangeFromText(value) {
        var match = String(value || "").match(
                    /(\d+(?:[.,]\d+)?)\s*[-–—]\s*(\d+(?:[.,]\d+)?)\s*(?:гц|hz)/i)
        if (!match)
            return null

        var minimum = Number(match[1].replace(",", "."))
        var maximum = Number(match[2].replace(",", "."))
        if (!isFinite(minimum) || !isFinite(maximum)
                || maximum <= minimum) {
            return null
        }
        return { minimum: minimum, maximum: maximum }
    }

    function spectrumRangeFromResult(value, depth) {
        if (value === undefined || value === null || depth < 0)
            return null

        if (typeof value === "string") {
            var text = String(value).trim()
            if (text.length > 1
                    && (text[0] === "{" || text[0] === "[")) {
                try {
                    return spectrumRangeFromResult(
                                JSON.parse(text), depth - 1)
                } catch (error) {
                    return null
                }
            }
            return null
        }

        if (typeof value !== "object")
            return null

        if (isArray(value)) {
            if (value.length === 0
                    || typeof value[0] !== "object")
                return null
            var rangeScanCount = Math.min(value.length, 64)
            for (var arrayIndex = 0;
                 arrayIndex < rangeScanCount; ++arrayIndex) {
                var arrayRange = spectrumRangeFromResult(
                            value[arrayIndex], depth - 1)
                if (arrayRange)
                    return arrayRange
            }
            return null
        }

        var descriptor = ""
        var descriptorKeys = [
            "name", "title", "label", "key", "tag", "tags"
        ]
        for (var descriptorIndex = 0;
             descriptorIndex < descriptorKeys.length;
             ++descriptorIndex) {
            var descriptorValue =
                    value[descriptorKeys[descriptorIndex]]
            if (descriptorValue !== undefined
                    && descriptorValue !== null) {
                descriptor += " " + String(descriptorValue)
            }
        }

        var lowerDescriptor = descriptor.toLowerCase()
        if (lowerDescriptor.indexOf("спектр") >= 0
                || lowerDescriptor.indexOf("spectrum") >= 0
                || lowerDescriptor.indexOf("fft") >= 0) {
            var descriptorRange =
                    frequencyRangeFromText(descriptor)
            if (descriptorRange)
                return descriptorRange
        }

        var priorityKeys = [
            "debugJSON", "resultJSON", "plots", "plotData",
            "spectra", "spectrum", "series"
        ]
        for (var priorityIndex = 0;
             priorityIndex < priorityKeys.length;
             ++priorityIndex) {
            var priorityValue = value[priorityKeys[priorityIndex]]
            if (priorityValue === undefined || priorityValue === null)
                continue
            var priorityRange = spectrumRangeFromResult(
                        priorityValue, depth - 1)
            if (priorityRange)
                return priorityRange
        }

        for (var key in value) {
            if (priorityKeys.indexOf(key) >= 0)
                continue
            var childRange = spectrumRangeFromResult(
                        value[key], depth - 1)
            if (childRange)
                return childRange
        }
        return null
    }

    function extractMasterValues(result) {
        if (!result)
            return []
        if (result.masterValues !== undefined
                && result.masterValues !== null) {
            return result.masterValues
        }
        var map = resultMap(result)
        if (map.masterValues !== undefined
                && map.masterValues !== null) {
            return map.masterValues
        }
        return map
    }

    function collectScalarValues(value, path, output, depth) {
        if (value === undefined || value === null || depth < 0)
            return

        if (typeof value !== "object") {
            output.push({
                key: path,
                name: path,
                value: value
            })
            return
        }

        if (isArray(value))
            return

        if (value.value !== undefined
                && typeof value.value !== "object") {
            output.push({
                key: path,
                name: safeText(firstDefined(value, [
                    "name", "label", "title", "key"
                ]), path),
                value: value.value,
                unit: safeText(firstDefined(value, [
                    "unit", "units", "dimension"
                ]), "")
            })
            return
        }

        for (var key in value) {
            var childPath = path.length > 0
                    ? path + " / " + key : String(key)
            collectScalarValues(
                        value[key], childPath, output, depth - 1)
        }
    }

    function normalizeSeries(candidate, defaultStep) { return resultSeriesParser.normalizeSeries(candidate, defaultStep); }

    // debugResult["plots"] is the exact collection consumed by the native
    // result analyzer.  It is an array of plot series, not an array of
    // points, so normalizeSeries(plots) cannot decode it directly.
    function normalizePlotCollection(candidate, defaultStep) { return resultSeriesParser.normalizePlotCollection(candidate, defaultStep); }

    function parseObject(value) { return resultSeriesParser.parseObject(value); }

    function spectrumThresholdCandidate(candidate) { return resultSeriesParser.spectrumThresholdCandidate(candidate); }

    function findSpectrumThreshold(value, depth) { return resultSeriesParser.findSpectrumThreshold(value, depth); }

    function colorText(value, fallback) { return resultSeriesParser.colorText(value, fallback); }

    function normalizeSpectrumTools(candidate) { return resultSeriesParser.normalizeSpectrumTools(candidate); }

    function findSpectrumTools(value, depth) { return resultSeriesParser.findSpectrumTools(value, depth); }

    function extractSpectrumTools(result) { return resultSeriesParser.extractSpectrumTools(result); }

    function searchNamedSeries(object, words, depth) { return resultSeriesParser.searchNamedSeries(object, words, depth); }

    function extractSpectrum(result) { return resultSeriesParser.extractSpectrum(result); }

    function extractSignal(result) { return resultSeriesParser.extractSignal(result); }

    function resultKey(result, resolvedPointName) {
        if (!result)
            return ""
        var recordIdentity = firstDefined(
                    result, [
                        "recordUUID", "recordUuid", "uuid", "_id"
                    ])
        var resultIdentity = firstDefined(
                    result, ["resultID", "resultId", "id"])
        return [
            resolvedPointName || pointName(result, ""),
            recordIdentity === undefined ? "" : recordIdentity,
            resultIdentity === undefined ? "" : resultIdentity,
            recordTime(result),
            recordFileName(result)
        ].join("\u001f")
    }

    function immutableRecordUuid(result) {
        if (!result)
            return ""
        var value = firstDefined(result, [
            "recordUUID", "recordUuid", "uuid", "_id"
        ])
        return value === undefined || value === null
                ? "" : String(value)
    }

    function formatNumber(value, digits) {
        var number = Number(value)
        if (isNaN(number))
            return "—"
        return number.toFixed(digits === undefined ? 3 : digits)
    }

    function setWarning(message) {
        errorMessage = String(message)
        parsingWarning(errorMessage)
    }
}
