import QtQml

QtObject {
    id: adapter

    readonly property bool available: typeof gtld !== "undefined"

    property var node: null
    property var routeRoots: []
    property var currentLastResult: null
    property var currentMasterValues: []
    property var currentSignalRequestId: null
    property var currentSpectrumRequestId: null
    property var currentSignalSourceResult: null
    property var currentSpectrumSourceResult: null
    property var signalPreviewSources: ({})
    property var spectrumPreviewSources: ({})
    property var signalPreviewDeadlines: ({})
    property var spectrumPreviewDeadlines: ({})
    property int previewTimeoutMs: 15000
    property string errorMessage: ""

    signal refreshed
    signal operationFailed(string operation, string message)
    signal signalPreviewLoaded(var requestId, var sourceResult, var points, var metadata)
    signal spectrumPreviewLoaded(var requestId, var sourceResult, var points, var metadata)
    signal previewFailed(string previewType, var requestId, string message)

    function refresh() {
        cancelAllPreviews("Источник данных обновлён", true);
        errorMessage = "";
        currentLastResult = null;
        currentMasterValues = [];
        currentSignalRequestId = null;
        currentSpectrumRequestId = null;
        currentSignalSourceResult = null;
        currentSpectrumSourceResult = null;
        node = currentNode();
        routeRoots = routeRootNodes();
        if (!available) {
            setError("refresh", "API GTLd недоступен");
            refreshed();
            return false;
        }
        if (!node) {
            setError("refresh", "Текущий узел GTLd не выбран");
            refreshed();
            return false;
        }
        refreshed();
        return true;
    }

    function currentNode() {
        if (!available || !gtld.node)
            return null;
        return gtld.node;
    }

    function routeRootNodes() {
        if (!available)
            return [];

        if (typeof gtld.routeRootNodes === "function") {
            try {
                var roots = toArray(gtld.routeRootNodes());
                if (roots.length > 0)
                    return roots;
            } catch (error) {
                setError("routeRootNodes", error);
            }
        }

        var current = currentNode();
        if (!current)
            return [];
        var visited = ({});
        for (var depth = 0; current && depth < 256; ++depth) {
            var key = nodeUuid(current);
            if (key.length > 0 && visited[key])
                break;
            if (key.length > 0)
                visited[key] = true;
            var parent = current.parent;
            if (typeof parent === "function") {
                try {
                    parent = parent.call(current);
                } catch (parentError) {
                    parent = null;
                }
            }
            if (!parent)
                break;
            current = parent;
        }
        return current ? [current] : [];
    }

    function activateNode(targetNode) {
        if (!available || !targetNode)
            return false;
        var methodNames = [
            "activateNode", "selectNode", "setCurrentNode"
        ];
        for (var index = 0; index < methodNames.length; ++index) {
            var method = gtld[methodNames[index]];
            if (typeof method !== "function")
                continue;
            try {
                var activationResult = method.call(gtld, targetNode);
                return activationResult === undefined
                        ? true
                        : Boolean(activationResult);
            } catch (error) {
                setError("activateNode", error);
                return false;
            }
        }
        return false;
    }

    function setCurrentResult(result) {
        currentLastResult = result || null;
        currentMasterValues = resultMasterValues(currentLastResult);
    }

    function lastResult(requestedNode) {
        if (!currentLastResult)
            return null;
        if (!requestedNode || sameNode(requestedNode, node))
            return currentLastResult;
        return null;
    }

    function masterValues(source) {
        if (looksLikeResult(source))
            return resultMasterValues(source);
        if (!source || sameNode(source, node))
            return currentMasterValues;
        return [];
    }

    function resultMasterValues(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 resultMap(result) {
        if (!result)
            return ({});
        var value = result.resultJSON;
        if (value === undefined || value === null)
            return ({});
        if (typeof value === "string") {
            try {
                value = JSON.parse(value);
            } catch (error) {
                setError("resultJSON", "Не удалось разобрать resultJSON: " + error);
                return ({});
            }
        }
        return value && typeof value === "object" ? value : ({});
    }

    function selectPointResults(targetNode, tag, count) {
        if (!available) {
            setError("selectPointResults", "API GTLd недоступен");
            return [];
        }
        var pointNode = targetNode || currentNode();
        if (!pointNode)
            return [];
        var options = {
            count: normalizedCount(count),
            tag: normalizedTag(tag)
        };
        try {
            if (sameNode(pointNode, currentNode()) && typeof gtld.selectLastResults === "function") {
                var currentResults = unwrapResults(gtld.selectLastResults(options));
                if (currentResults.length > 0)
                    return currentResults;
            }
            if (typeof pointNode.selectLastResults === "function") {
                var nodeResults = unwrapResults(pointNode.selectLastResults(options));
                if (nodeResults.length > 0)
                    return nodeResults;
            }
        } catch (nodeError)
        // Ниже остаётся резервный запрос по UUID.
        {}
        if (typeof gtld.selectLastPointResults !== "function") {
            setError("selectPointResults", "Методы загрузки результатов точки недоступны");
            return [];
        }
        var pointUuid = nodeUuid(pointNode);
        if (pointUuid.length === 0)
            return [];
        return selectPointResultsByUuid(pointUuid, parentNodeUuid(pointNode), tag, count);
    }

    function selectPointResultsByUuid(pointUuid, objectUuid, tag, count) {
        if (!available || typeof gtld.selectLastPointResults !== "function") {
            setError("selectPointResultsByUuid", "Метод selectLastPointResults недоступен");
            return [];
        }
        var point = String(pointUuid || "");
        var object = String(objectUuid || "");
        if (point.length === 0 || object.length === 0) {
            setError("selectPointResultsByUuid", "Не определены UUID точки или объекта");
            return [];
        }
        try {
            return unwrapResults(gtld.selectLastPointResults({
                pointUUID: point,
                objectUUID: object,
                count: normalizedCount(count),
                tag: normalizedTag(tag)
            }));
        } catch (error) {
            setError("selectPointResultsByUuid", error);
            return [];
        }
    }

    function selectObjectResults(targetNode, tag, count) {
        if (!available || typeof gtld.selectLastObjectResults !== "function") {
            setError("selectObjectResults", "Метод selectLastObjectResults недоступен");
            return [];
        }
        var objectNode = targetNode || currentNode();
        var objectUuid = nodeUuid(objectNode);
        if (objectUuid.length === 0)
            return [];
        try {
            return unwrapResults(gtld.selectLastObjectResults({
                objectUUID: objectUuid,
                count: normalizedCount(count),
                tag: normalizedTag(tag)
            }));
        } catch (error) {
            setError("selectObjectResults", error);
            return [];
        }
    }

    function selectResultTags(targetNode) {
        if (!available || typeof gtld.selectResultTags !== "function") {
            setError("selectResultTags", "Метод selectResultTags недоступен");
            return [];
        }
        try {
            errorMessage = "";
            return unwrapTags(gtld.selectResultTags(
                                  targetNode || currentNode()));
        } catch (error) {
            setError("selectResultTags", error);
            return [];
        }
    }

    function unwrapTags(response) {
        if (!response)
            return [];
        if (response.ok === false) {
            setError("selectResultTags",
                     response.errorMessage || response.errorCode
                     || "Ошибка получения тегов");
            return [];
        }

        var source = response;
        if (!isArray(source)
                && !(typeof source !== "string"
                     && source.length !== undefined)) {
            if (source.data !== undefined && source.data !== null)
                source = source.data;
            if (source && source.tags !== undefined)
                source = source.tags;
            else if (source && source.resultTags !== undefined)
                source = source.resultTags;
            else if (source && source.results !== undefined)
                source = source.results;
        }

        var values = toArray(source);
        var tags = [];
        for (var index = 0; index < values.length; ++index) {
            var value = values[index];
            if (value && typeof value === "object")
                value = value.tag !== undefined ? value.tag
                      : value.name !== undefined ? value.name
                      : value.value;
            if (value !== undefined && value !== null)
                tags.push(String(value));
        }
        return tags;
    }

    function selectResultsByTag(tag, count, targetNode) {
        if (!available) {
            setError("selectResultsByTag", "API GTLd недоступен");
            return [];
        }
        var selectedNode = targetNode || currentNode();
        errorMessage = "";
        var options = {
            count: normalizedCount(count),
            tag: normalizedTag(tag)
        };
        try {
            if (sameNode(selectedNode, currentNode()) && typeof gtld.selectLastResults === "function") {
                return unwrapResults(gtld.selectLastResults(options));
            }
            if (nodeHasChildren(selectedNode))
                return selectObjectResults(selectedNode, options.tag, options.count);
            return selectPointResults(selectedNode, options.tag, options.count);
        } catch (error) {
            setError("selectResultsByTag", error);
            return [];
        }
    }

    function unwrapResults(response) {
        if (!response)
            return [];
        if (isArray(response) || (typeof response !== "string" && response.length !== undefined)) {
            return toArray(response);
        }
        if (response.ok === false) {
            setError("selectLastResults", response.errorMessage || response.errorCode || "Ошибка получения результатов");
            return [];
        }
        if (response.data && response.data.results)
            return toArray(response.data.results);
        if (response.results)
            return toArray(response.results);
        if (response.data && (isArray(response.data) || (typeof response.data !== "string" && response.data.length !== undefined))) {
            return toArray(response.data);
        }
        return [];
    }

    function requestSignalPreview(result, pointLimit, startSample,
                                  sampleCount, mode) {
        if (!available || typeof gtld.requestSignalPreview !== "function") {
            setError("requestSignalPreview", "Метод requestSignalPreview недоступен");
            previewFailed("signal", null, errorMessage);
            return null;
        }
        try {
            errorMessage = "";
            currentSignalSourceResult = result;
            var options = {
                channel: 0,
                maxPoints: normalizedPreviewLimit(pointLimit, 4096,
                                                  512, 8192),
                mode: String(mode || "auto")
            };
            var normalizedStart = Number(startSample);
            var normalizedCount = Number(sampleCount);
            if (isFinite(normalizedStart) && normalizedStart >= 0)
                options.startSample = Math.floor(normalizedStart);
            if (isFinite(normalizedCount) && normalizedCount > 0)
                options.sampleCount = Math.ceil(normalizedCount);
            currentSignalRequestId = gtld.requestSignalPreview(result,
                                                               options);
            if (currentSignalRequestId !== null
                    && currentSignalRequestId !== undefined) {
                registerPreviewRequest("signal", currentSignalRequestId,
                                       result);
            } else {
                currentSignalRequestId = null;
                currentSignalSourceResult = null;
            }
            return currentSignalRequestId;
        } catch (error) {
            currentSignalRequestId = null;
            currentSignalSourceResult = null;
            setError("requestSignalPreview", error);
            previewFailed("signal", null, errorMessage);
            return null;
        }
    }

    function requestSpectrumPreview(result, pointLimit, maximumFrequency,
                                    minimumFrequency) {
        if (!available || typeof gtld.requestSpectrumPreview !== "function") {
            setError("requestSpectrumPreview", "Метод requestSpectrumPreview недоступен");
            previewFailed("spectrum", null, errorMessage);
            return null;
        }
        var options = {
            channel: 0,
            maxPoints: normalizedPreviewLimit(pointLimit, 4096, 256, 8192)
        };
        var maximum = Number(maximumFrequency);
        if (isFinite(maximum) && maximum > 0)
            options.maximumFrequency = maximum;
        var minimum = Number(minimumFrequency);
        if (isFinite(minimum) && minimum >= 0)
            options.minimumFrequency = minimum;
        try {
            errorMessage = "";
            currentSpectrumSourceResult = result;
            currentSpectrumRequestId = gtld.requestSpectrumPreview(result, options);
            if (currentSpectrumRequestId !== null
                    && currentSpectrumRequestId !== undefined) {
                registerPreviewRequest("spectrum",
                                       currentSpectrumRequestId, result);
            } else {
                currentSpectrumRequestId = null;
                currentSpectrumSourceResult = null;
            }
            return currentSpectrumRequestId;
        } catch (error) {
            currentSpectrumRequestId = null;
            currentSpectrumSourceResult = null;
            setError("requestSpectrumPreview", error);
            previewFailed("spectrum", null, errorMessage);
            return null;
        }
    }

    function registerPreviewRequest(previewType, requestId, sourceResult) {
        var requestKey = String(requestId);
        var deadline = Date.now() + Math.max(1, previewTimeoutMs);
        if (String(previewType) === "signal") {
            signalPreviewSources[requestKey] = sourceResult;
            signalPreviewDeadlines[requestKey] = deadline;
        } else {
            spectrumPreviewSources[requestKey] = sourceResult;
            spectrumPreviewDeadlines[requestKey] = deadline;
        }
    }

    function hasPreviewRequest(previewType, requestId) {
        if (requestId === undefined || requestId === null)
            return false;
        var requestKey = String(requestId);
        return String(previewType) === "signal"
                ? signalPreviewDeadlines[requestKey] !== undefined
                : spectrumPreviewDeadlines[requestKey] !== undefined;
    }

    function takePreviewSource(previewType, requestId) {
        if (!hasPreviewRequest(previewType, requestId))
            return undefined;
        var requestKey = String(requestId);
        var sourceResult;
        if (String(previewType) === "signal") {
            sourceResult = signalPreviewSources[requestKey];
            delete signalPreviewSources[requestKey];
            delete signalPreviewDeadlines[requestKey];
            if (sameRequest(requestId, currentSignalRequestId)) {
                currentSignalRequestId = null;
                currentSignalSourceResult = null;
            }
        } else {
            sourceResult = spectrumPreviewSources[requestKey];
            delete spectrumPreviewSources[requestKey];
            delete spectrumPreviewDeadlines[requestKey];
            if (sameRequest(requestId, currentSpectrumRequestId)) {
                currentSpectrumRequestId = null;
                currentSpectrumSourceResult = null;
            }
        }
        return sourceResult;
    }

    function cancelPreview(previewType, requestId, message, notifyFailure) {
        if (requestId === undefined || requestId === null)
            return false;

        var type = String(previewType) === "signal"
                ? "signal" : "spectrum";
        if (!hasPreviewRequest(type, requestId))
            return false;

        takePreviewSource(type, requestId);
        if (notifyFailure === true) {
            previewFailed(type, requestId,
                          String(message || "Запрос предпросмотра отменён"));
        }
        return true;
    }

    function discardPreviewRequest(previewType, requestId) {
        return cancelPreview(previewType, requestId, "", false);
    }

    function cancelAllPreviews(message, notifyFailure) {
        var signalKeys = Object.keys(signalPreviewSources);
        var spectrumKeys = Object.keys(spectrumPreviewSources);
        var cancelled = [];
        for (var signalIndex = 0;
             signalIndex < signalKeys.length; ++signalIndex) {
            if (cancelPreview("signal", signalKeys[signalIndex],
                              "", false)) {
                cancelled.push({
                    type: "signal",
                    requestId: signalKeys[signalIndex]
                });
            }
        }
        for (var spectrumIndex = 0;
             spectrumIndex < spectrumKeys.length; ++spectrumIndex) {
            if (cancelPreview("spectrum", spectrumKeys[spectrumIndex],
                              "", false)) {
                cancelled.push({
                    type: "spectrum",
                    requestId: spectrumKeys[spectrumIndex]
                });
            }
        }

        signalPreviewSources = ({});
        spectrumPreviewSources = ({});
        signalPreviewDeadlines = ({});
        spectrumPreviewDeadlines = ({});
        currentSignalRequestId = null;
        currentSpectrumRequestId = null;
        currentSignalSourceResult = null;
        currentSpectrumSourceResult = null;

        if (notifyFailure === true) {
            var failureMessage = String(
                        message || "Запрос предпросмотра отменён");
            for (var cancelledIndex = 0;
                 cancelledIndex < cancelled.length; ++cancelledIndex) {
                var entry = cancelled[cancelledIndex];
                previewFailed(entry.type, entry.requestId,
                              failureMessage);
            }
        }
    }

    function expirePreviewRequests() {
        var now = Date.now();
        var signalKeys = Object.keys(signalPreviewDeadlines);
        var spectrumKeys = Object.keys(spectrumPreviewDeadlines);
        for (var signalIndex = 0;
             signalIndex < signalKeys.length; ++signalIndex) {
            var signalKey = signalKeys[signalIndex];
            if (Number(signalPreviewDeadlines[signalKey]) <= now) {
                cancelPreview("signal", signalKey,
                              "Истекло время ожидания временного сигнала",
                              true);
            }
        }
        for (var spectrumIndex = 0;
             spectrumIndex < spectrumKeys.length; ++spectrumIndex) {
            var spectrumKey = spectrumKeys[spectrumIndex];
            if (Number(spectrumPreviewDeadlines[spectrumKey]) <= now) {
                cancelPreview("spectrum", spectrumKey,
                              "Истекло время ожидания спектра",
                              true);
            }
        }
    }

    function handleSignalPreview(requestId, response) {
        if (!hasPreviewRequest("signal", requestId))
            return;
        var sourceResult = takePreviewSource("signal", requestId);
        if (!response || response.ok === false) {
            var message = responseError(response, "Не удалось загрузить временной сигнал");
            setError("signalPreview", message);
            previewFailed("signal", requestId, message);
            return;
        }
        var preview = response.data || response;
        errorMessage = "";
        var points = signalPreviewPoints(preview);
        signalPreviewLoaded(requestId, sourceResult, points, preview);
    }

    // GTL charts use the sample time (sample index * dt).  Do not stretch a
    // shortened preview over the record duration: that changes the waveform
    // and puts extrema at positions where they do not exist in the source.
    function signalPreviewPoints(preview) {
        var sourcePoints = toArray(preview.points);
        var samples = toArray(preview.samples);
        var times = toArray(preview.times || preview.timestamps);
        var indices = toArray(preview.sampleIndices || preview.indices);
        var sampleRate = Number(preview.sampleRate);
        var dt = Number(preview.sampleInterval || preview.dt);
        var sampleStep = Number(preview.sampleStep || preview.step);
        var firstSample = Number(preview.firstSample || preview.startSample || 0);
        var points = [];
        var i;

        if (sourcePoints.length > 0) {
            for (i = 0; i < sourcePoints.length; ++i) {
                var sourcePoint = sourcePoints[i];
                var pointX = Number(sourcePoint.x !== undefined ? sourcePoint.x : sourcePoint.time);
                var pointY = Number(sourcePoint.y !== undefined ? sourcePoint.y : sourcePoint.value);
                if (isFinite(pointX) && isFinite(pointY))
                    points.push({ x: pointX, y: pointY });
            }
            if (points.length > 0)
                return points;
        }

        if ((!isFinite(dt) || dt <= 0) && isFinite(sampleRate) && sampleRate > 0)
            dt = 1 / sampleRate;
        if (!isFinite(sampleStep) || sampleStep <= 0)
            sampleStep = 1;
        if (!isFinite(firstSample) || firstSample < 0)
            firstSample = 0;

        for (i = 0; i < samples.length; ++i) {
            var sample = samples[i];
            var value = Number(sample && sample.value !== undefined ? sample.value : sample);
            var time = Number(sample && sample.time !== undefined ? sample.time
                              : (i < times.length ? times[i] : NaN));
            var sampleIndex = Number(sample && sample.index !== undefined ? sample.index
                                    : (i < indices.length ? indices[i] : NaN));
            if (!isFinite(time) && isFinite(dt) && dt > 0) {
                if (!isFinite(sampleIndex))
                    sampleIndex = firstSample + i * sampleStep;
                time = sampleIndex * dt;
            }
            if (isFinite(time) && isFinite(value))
                points.push({ x: time, y: value });
        }

        // Compatibility with an older host that exposes neither dt nor rate.
        // Only that legacy response needs duration-based coordinates.
        if (points.length === 0) {
            var duration = Number(preview.duration);
            for (i = 0; i < samples.length; ++i) {
                var legacyValue = Number(samples[i]);
                if (isFinite(duration) && duration >= 0 && isFinite(legacyValue)) {
                    points.push({
                        x: duration * i / Math.max(1, samples.length - 1),
                        y: legacyValue
                    });
                }
            }
        }
        return points;
    }

    function handleSpectrumPreview(requestId, response) {
        if (!hasPreviewRequest("spectrum", requestId))
            return;
        var sourceResult = takePreviewSource("spectrum", requestId);
        if (!response || response.ok === false) {
            var message = responseError(response, "Не удалось построить спектр");
            setError("spectrumPreview", message);
            previewFailed("spectrum", requestId, message);
            return;
        }
        var preview = response.data || response;
        errorMessage = "";
        var points = spectrumPreviewPoints(preview);
        spectrumPreviewLoaded(requestId, sourceResult, points, preview);
    }

    // Prefer the exact bins produced by GTL.  Frequency values must come from
    // the transform (or its bin step), never from the amount of preview data.
    function spectrumPreviewPoints(preview) {
        var sourcePoints = toArray(preview.points);
        if (sourcePoints.length === 0)
            sourcePoints = toArray(preview.bins);
        var frequencies = toArray(preview.frequencies);
        var amplitudes = toArray(preview.amplitudes);
        var points = [];
        var i;

        for (i = 0; i < sourcePoints.length; ++i) {
            var sourcePoint = sourcePoints[i];
            if (!sourcePoint || typeof sourcePoint !== "object")
                continue;
            var sourceFrequency = Number(
                        sourcePoint.frequency !== undefined
                        ? sourcePoint.frequency : sourcePoint.x);
            var sourceAmplitude = Number(
                        sourcePoint.amplitude !== undefined
                        ? sourcePoint.amplitude
                        : (sourcePoint.value !== undefined
                           ? sourcePoint.value : sourcePoint.y));
            if (isFinite(sourceFrequency) && isFinite(sourceAmplitude))
                points.push({ x: sourceFrequency, y: sourceAmplitude });
        }
        if (points.length > 0)
            return points;

        var count = Math.min(frequencies.length, amplitudes.length);
        for (i = 0; i < count; ++i) {
            var frequency = Number(frequencies[i]);
            var amplitude = Number(amplitudes[i]);
            if (isFinite(frequency) && isFinite(amplitude))
                points.push({
                    x: frequency,
                    y: amplitude
                });
        }
        if (points.length > 0)
            return points;

        var values = amplitudes;
        if (values.length === 0)
            values = toArray(preview.values);
        if (values.length === 0)
            values = toArray(preview.samples);
        var frequencyStep = Number(
                    preview.frequencyStep || preview.binWidth || preview.df);
        var firstFrequency = Number(
                    preview.firstFrequency || preview.minimumFrequency || 0);
        if (!isFinite(firstFrequency))
            firstFrequency = 0;
        if (isFinite(frequencyStep) && frequencyStep > 0) {
            for (i = 0; i < values.length; ++i) {
                var value = Number(values[i]);
                if (isFinite(value)) {
                    points.push({
                        x: firstFrequency + i * frequencyStep,
                        y: value
                    });
                }
            }
        }
        return points;
    }

    function responseError(response, fallback) {
        if (!response)
            return fallback;
        return String(response.errorMessage || response.errorCode || fallback);
    }

    function sameRequest(left, right) {
        if (left === undefined || left === null || right === undefined || right === null) {
            return false;
        }
        return String(left) === String(right);
    }

    function normalizedCount(count) {
        var value = Number(count);
        if (!isFinite(value) || value <= 0)
            return 5000;
        return Math.floor(value);
    }

    function normalizedTag(tag) {
        return tag === undefined || tag === null ? "" : String(tag);
    }

    function normalizedPreviewLimit(value, fallback, minimum, maximum) {
        var number = Number(value);
        if (!isFinite(number))
            number = fallback;
        return Math.max(minimum, Math.min(maximum, Math.floor(number)));
    }

    function nodeUuid(sourceNode) {
        if (!sourceNode || sourceNode.uuid === undefined || sourceNode.uuid === null) {
            return "";
        }
        if (typeof sourceNode.uuid.toString === "function")
            return sourceNode.uuid.toString();
        return String(sourceNode.uuid);
    }

    function parentNodeUuid(sourceNode) {
        if (!sourceNode)
            return "";
        var parent = sourceNode.parent;
        if (typeof parent === "function") {
            try {
                parent = parent.call(sourceNode);
            } catch (error) {
                parent = null;
            }
        }
        return nodeUuid(parent);
    }

    function nodeName(sourceNode) {
        if (!sourceNode)
            return "";
        var candidates = ["label", "name", "title"];
        for (var i = 0; i < candidates.length; ++i) {
            var value = sourceNode[candidates[i]];
            if (value !== undefined && value !== null && String(value).length > 0) {
                return String(value);
            }
        }
        return nodeUuid(sourceNode);
    }

    function nodeProperty(sourceNode, name) {
        if (!sourceNode)
            return undefined;
        try {
            var value = sourceNode[name];
            if (typeof value === "function")
                return value.call(sourceNode);
            return value;
        } catch (error) {
            return undefined;
        }
    }

    function nodeIsPoint(sourceNode) {
        if (!sourceNode)
            return false;

        var pointFlags = ["isPoint", "isMeasurementPoint"];
        for (var flagIndex = 0; flagIndex < pointFlags.length; ++flagIndex) {
            var flag = nodeProperty(sourceNode, pointFlags[flagIndex]);
            if (flag !== undefined && flag !== null)
                return Boolean(flag);
        }

        var typeNames = ["type", "nodeType", "kind", "category"];
        for (var typeIndex = 0; typeIndex < typeNames.length; ++typeIndex) {
            var typeValue = nodeProperty(sourceNode, typeNames[typeIndex]);
            if (typeValue === undefined || typeValue === null)
                continue;
            var normalizedType = String(typeValue).toLowerCase();
            if (normalizedType.indexOf("point") >= 0
                    || normalizedType.indexOf("точк") >= 0) {
                return true;
            }
            if (normalizedType.indexOf("object") >= 0
                    || normalizedType.indexOf("объект") >= 0) {
                return false;
            }
        }

        var objectDescriptor = String(sourceNode).toLowerCase();
        if (objectDescriptor.indexOf("point") >= 0
                || objectDescriptor.indexOf("точк") >= 0) {
            return true;
        }

        var result = nodeProperty(sourceNode, "lastResult");
        if (isArray(result)
                || (result !== undefined && result !== null
                    && typeof result !== "string"
                    && result.length !== undefined)) {
            return true;
        }

        // У точки без результатов lastResult может быть null, но имя
        // измерительного скрипта остаётся доступным.
        var scriptNames = [
            "scriptName", "scriptFileName", "measurementScriptName"
        ];
        for (var scriptIndex = 0;
             scriptIndex < scriptNames.length; ++scriptIndex) {
            var scriptName = nodeProperty(sourceNode,
                                          scriptNames[scriptIndex]);
            if (scriptName !== undefined && scriptName !== null
                    && String(scriptName).trim().length > 0) {
                return true;
            }
        }

        var objectProperties = [
            "objectType", "masterScriptName", "masterScriptFileName"
        ];
        for (var objectIndex = 0;
             objectIndex < objectProperties.length; ++objectIndex) {
            if (nodeProperty(sourceNode, objectProperties[objectIndex])
                    !== undefined) {
                return false;
            }
        }

        var children = nodeProperty(sourceNode, "children");
        return children !== undefined && children !== null
                && children.length !== undefined && children.length === 0;
    }

    function nodeHasChildren(sourceNode) {
        if (!sourceNode)
            return false;
        var children = sourceNode.children;
        if (typeof children === "function") {
            try {
                children = children.call(sourceNode);
            } catch (error) {
                children = null;
            }
        }
        return children && children.length !== undefined && children.length > 0;
    }

    function sameNode(left, right) {
        if (!left || !right)
            return false;
        if (left === right)
            return true;
        var leftUuid = nodeUuid(left);
        var rightUuid = nodeUuid(right);
        return leftUuid.length > 0 && leftUuid === rightUuid;
    }

    function looksLikeResult(value) {
        return value && (value.resultJSON !== undefined || value.recordUUID !== undefined || value.resultID !== undefined);
    }

    function isArray(value) {
        return Array.isArray(value);
    }

    function toArray(value) {
        var result = [];
        if (value === undefined || value === null)
            return result;
        if (isArray(value))
            return value.slice();
        if (value.length === undefined)
            return result;
        for (var i = 0; i < value.length; ++i)
            result.push(value[i]);
        return result;
    }

    function setError(operation, error) {
        var message = error === undefined || error === null ? "Неизвестная ошибка" : String(error);
        errorMessage = message;
        operationFailed(operation, message);
    }

    property var gtldConnections: Connections {
        target: adapter.available ? gtld : null

        function onItem_changed() {
            adapter.refresh();
        }

        function onSignalPreviewReady(requestId, response) {
            adapter.handleSignalPreview(requestId, response);
        }

        function onSpectrumPreviewReady(requestId, response) {
            adapter.handleSpectrumPreview(requestId, response);
        }
    }

    property var previewExpiryTimer: Timer {
        interval: 500
        repeat: true
        running: true
        onTriggered: adapter.expirePreviewRequests()
    }

    Component.onCompleted: refresh()
}
