// SPDX-License-Identifier: GPL-3.0-or-later

#include "rrdcontext-internal.h"
#include "database/pattern-array.h"

#define QUERY_TARGET_MAX_REALLOC_INCREASE 500
#define query_target_realloc_size(size, start) \
            (size) ? ((size) < QUERY_TARGET_MAX_REALLOC_INCREASE ? (size) * 2 : (size) + QUERY_TARGET_MAX_REALLOC_INCREASE) : (start)

static void query_metric_release(QUERY_TARGET *qt, QUERY_METRIC *qm);
static void query_dimension_release(QUERY_DIMENSION *qd);
static void query_instance_release(QUERY_INSTANCE *qi);
static void query_context_release(QUERY_CONTEXT *qc);
static void query_node_release(QUERY_NODE *qn);

static __thread QUERY_TARGET *thread_qt = NULL;
static struct {
    struct {
        SPINLOCK spinlock;
        size_t count;
        QUERY_TARGET *base;
    } available;

    struct {
        SPINLOCK spinlock;
        size_t count;
        QUERY_TARGET *base;
    } used;
} query_target_base = {
        .available = {
                .spinlock = SPINLOCK_INITIALIZER,
                .base = NULL,
                .count = 0,
        },
        .used = {
                .spinlock = SPINLOCK_INITIALIZER,
                .base = NULL,
                .count = 0,
        },
};

static void query_target_destroy(QUERY_TARGET *qt) {
    __atomic_sub_fetch(&netdata_buffers_statistics.query_targets_size, qt->query.size * sizeof(*qt->query.array), __ATOMIC_RELAXED);
    freez(qt->query.array);

    __atomic_sub_fetch(&netdata_buffers_statistics.query_targets_size, qt->dimensions.size * sizeof(*qt->dimensions.array), __ATOMIC_RELAXED);
    freez(qt->dimensions.array);

    __atomic_sub_fetch(&netdata_buffers_statistics.query_targets_size, qt->instances.size * sizeof(*qt->instances.array), __ATOMIC_RELAXED);
    freez(qt->instances.array);

    __atomic_sub_fetch(&netdata_buffers_statistics.query_targets_size, qt->contexts.size * sizeof(*qt->contexts.array), __ATOMIC_RELAXED);
    freez(qt->contexts.array);

    __atomic_sub_fetch(&netdata_buffers_statistics.query_targets_size, qt->nodes.size * sizeof(*qt->nodes.array), __ATOMIC_RELAXED);
    freez(qt->nodes.array);

    freez(qt);
}

void query_target_release(QUERY_TARGET *qt) {
    if(unlikely(!qt)) return;

    internal_fatal(!qt->internal.used, "QUERY TARGET: qt to be released is not used");

    simple_pattern_free(qt->nodes.scope_pattern);
    qt->nodes.scope_pattern = NULL;

    simple_pattern_free(qt->nodes.pattern);
    qt->nodes.pattern = NULL;

    simple_pattern_free(qt->contexts.scope_pattern);
    qt->contexts.scope_pattern = NULL;

    simple_pattern_free(qt->contexts.pattern);
    qt->contexts.pattern = NULL;

    simple_pattern_free(qt->instances.pattern);
    qt->instances.pattern = NULL;

    simple_pattern_free(qt->instances.scope_pattern);
    qt->instances.scope_pattern = NULL;

    simple_pattern_free(qt->instances.chart_label_key_pattern);
    qt->instances.chart_label_key_pattern = NULL;

    simple_pattern_free(qt->instances.scope_chart_label_key_pattern);
    qt->instances.scope_chart_label_key_pattern = NULL;

    simple_pattern_free(qt->instances.labels_pattern);
    qt->instances.labels_pattern = NULL;

    simple_pattern_free(qt->instances.scope_labels_pattern);
    qt->instances.scope_labels_pattern = NULL;

    pattern_array_free(qt->instances.labels_pa);
    qt->instances.labels_pa = NULL;

    pattern_array_free(qt->instances.scope_labels_pa);
    qt->instances.scope_labels_pa = NULL;

    simple_pattern_free(qt->query.pattern);
    qt->query.pattern = NULL;
    
    simple_pattern_free(qt->dimensions.scope_pattern);
    qt->dimensions.scope_pattern = NULL;

    // release the query
    for(size_t i = 0, used = qt->query.used; i < used ;i++) {
        QUERY_METRIC *qm = query_metric(qt, i);
        query_metric_release(qt, qm);
    }
    qt->query.used = 0;

    // release the dimensions
    for(size_t i = 0, used = qt->dimensions.used; i < used ; i++) {
        QUERY_DIMENSION *qd = query_dimension(qt, i);
        query_dimension_release(qd);
    }
    qt->dimensions.used = 0;

    // release the instances
    for(size_t i = 0, used = qt->instances.used; i < used ;i++) {
        QUERY_INSTANCE *qi = query_instance(qt, i);
        query_instance_release(qi);
    }
    qt->instances.used = 0;

    // release the contexts
    for(size_t i = 0, used = qt->contexts.used; i < used ;i++) {
        QUERY_CONTEXT *qc = query_context(qt, i);
        rrdcontext_release(qc->rca);
        qc->rca = NULL;
    }
    qt->contexts.used = 0;

    // release the nodes
    for(size_t i = 0, used = qt->nodes.used; i < used ; i++) {
        QUERY_NODE *qn = query_node(qt, i);
        query_node_release(qn);
    }
    qt->nodes.used = 0;

    qt->db.minimum_latest_update_every_s = 0;
    qt->db.first_time_s = 0;
    qt->db.last_time_s = 0;

    for(size_t g = 0; g < MAX_QUERY_GROUP_BY_PASSES ;g++)
        qt->group_by[g].used = 0;

    qt->id[0] = '\0';

    spinlock_lock(&query_target_base.used.spinlock);
    DOUBLE_LINKED_LIST_REMOVE_ITEM_UNSAFE(query_target_base.used.base, qt, internal.prev, internal.next);
    query_target_base.used.count--;
    spinlock_unlock(&query_target_base.used.spinlock);

    qt->internal.used = false;
    thread_qt = NULL;

    if (qt->internal.queries > 1000) {
        query_target_destroy(qt);
    }
    else {
        spinlock_lock(&query_target_base.available.spinlock);
        DOUBLE_LINKED_LIST_APPEND_ITEM_UNSAFE(query_target_base.available.base, qt, internal.prev, internal.next);
        query_target_base.available.count++;
        spinlock_unlock(&query_target_base.available.spinlock);
    }
}

static QUERY_TARGET *query_target_get(void) {
    spinlock_lock(&query_target_base.available.spinlock);
    QUERY_TARGET *qt = query_target_base.available.base;
    if (qt) {
        DOUBLE_LINKED_LIST_REMOVE_ITEM_UNSAFE(query_target_base.available.base, qt, internal.prev, internal.next);
        query_target_base.available.count--;
    }
    spinlock_unlock(&query_target_base.available.spinlock);

    if(unlikely(!qt))
        qt = callocz(1, sizeof(*qt));

    spinlock_lock(&query_target_base.used.spinlock);
    DOUBLE_LINKED_LIST_APPEND_ITEM_UNSAFE(query_target_base.used.base, qt, internal.prev, internal.next);
    query_target_base.used.count++;
    spinlock_unlock(&query_target_base.used.spinlock);

    qt->internal.used = true;
    qt->internal.queries++;
    thread_qt = qt;

    return qt;
}

// this is used to release a query target from a cancelled thread
void query_target_free(void) {
    query_target_release(thread_qt);
}

// ----------------------------------------------------------------------------
// query API

typedef struct query_target_locals {
    time_t start_s;

    QUERY_TARGET *qt;

    RRDSET *st;

    const char *scope_nodes;
    const char *scope_contexts;
    const char *scope_instances;
    const char *scope_labels;
    const char *scope_dimensions;

    const char *nodes;
    const char *contexts;
    const char *instances;
    const char *dimensions;
    const char *chart_label_key;
    const char *labels;
    const char *alerts;

    long long after;
    long long before;
    bool match_ids;
    bool match_names;

    size_t metrics_skipped_due_to_not_matching_timeframe;

    char host_node_id_str[UUID_STR_LEN];
    QUERY_NODE *qn; // temp to pass on callbacks, ignore otherwise - no need to free
} QUERY_TARGET_LOCALS;

struct storage *query_metric_storage_engine(QUERY_TARGET *qt, QUERY_METRIC *qm, size_t tier) {
    QUERY_NODE *qn = query_node(qt, qm->link.query_node_id);
    return qn->rrdhost->db[tier].eng;
}

static inline void query_metric_release(QUERY_TARGET *qt, QUERY_METRIC *qm) {
    qm->plan.used = 0;

    // reset the tiers
    for(size_t tier = 0; tier < nd_profile.storage_tiers;tier++) {
        if(qm->tiers[tier].smh) {
            STORAGE_ENGINE *eng = query_metric_storage_engine(qt, qm, tier);
            eng->api.metric_release(qm->tiers[tier].smh);
            qm->tiers[tier].smh = NULL;
        }
    }
}

static bool query_metric_add(QUERY_TARGET_LOCALS *qtl, QUERY_NODE *qn, QUERY_CONTEXT *qc,
                             QUERY_INSTANCE *qi, size_t qd_slot, RRDMETRIC *rm, RRDR_DIMENSION_FLAGS options) {
    QUERY_TARGET *qt = qtl->qt;
    RRDINSTANCE *ri = rm->ri;

    time_t common_first_time_s = 0;
    time_t common_last_time_s = 0;
    time_t common_update_every_s = 0;
    size_t tiers_added = 0;

    struct {
        STORAGE_ENGINE *eng;
        STORAGE_METRIC_HANDLE *smh;
        time_t db_first_time_s;
        time_t db_last_time_s;
        time_t db_update_every_s;
    } tier_retention[nd_profile.storage_tiers];

    RRDDIM *rd = rrdmetric_rrddim_get_and_lock(rm);

    for (size_t tier = 0; tier < nd_profile.storage_tiers; tier++) {
        STORAGE_ENGINE *eng = qn->rrdhost->db[tier].eng;
        tier_retention[tier].eng = eng;
        tier_retention[tier].db_update_every_s = (time_t) (qn->rrdhost->db[tier].tier_grouping * ri->update_every_s);

        if(rd && rd->tiers[tier].smh)
            tier_retention[tier].smh = eng->api.metric_dup(rd->tiers[tier].smh);
        else
            tier_retention[tier].smh = eng->api.metric_get_by_id(qn->rrdhost->db[tier].si, rm->uuid);

        if(tier_retention[tier].smh) {
            tier_retention[tier].db_first_time_s = storage_engine_oldest_time_s(tier_retention[tier].eng->seb, tier_retention[tier].smh);
            tier_retention[tier].db_last_time_s = storage_engine_latest_time_s(tier_retention[tier].eng->seb, tier_retention[tier].smh);

            if(!common_first_time_s)
                common_first_time_s = tier_retention[tier].db_first_time_s;
            else if(tier_retention[tier].db_first_time_s)
                common_first_time_s = MIN(common_first_time_s, tier_retention[tier].db_first_time_s);

            if(!common_last_time_s)
                common_last_time_s = tier_retention[tier].db_last_time_s;
            else
                common_last_time_s = MAX(common_last_time_s, tier_retention[tier].db_last_time_s);

            if(!common_update_every_s)
                common_update_every_s = tier_retention[tier].db_update_every_s;
            else if(tier_retention[tier].db_update_every_s)
                common_update_every_s = MIN(common_update_every_s, tier_retention[tier].db_update_every_s);

            tiers_added++;
        }
        else {
            tier_retention[tier].db_first_time_s = 0;
            tier_retention[tier].db_last_time_s = 0;
            tier_retention[tier].db_update_every_s = 0;
        }
    }

    rrdmetric_rrddim_unlock(rd);

    for (size_t tier = 0; tier < nd_profile.storage_tiers; tier++) {
        if(!qt->db.tiers[tier].update_every || (tier_retention[tier].db_update_every_s && tier_retention[tier].db_update_every_s < qt->db.tiers[tier].update_every))
            qt->db.tiers[tier].update_every = tier_retention[tier].db_update_every_s;

        if(!qt->db.tiers[tier].retention.first_time_s || (tier_retention[tier].db_first_time_s && tier_retention[tier].db_first_time_s < qt->db.tiers[tier].retention.first_time_s))
            qt->db.tiers[tier].retention.first_time_s = tier_retention[tier].db_first_time_s;

        if(!qt->db.tiers[tier].retention.last_time_s || (tier_retention[tier].db_last_time_s && tier_retention[tier].db_last_time_s > qt->db.tiers[tier].retention.last_time_s))
            qt->db.tiers[tier].retention.last_time_s = tier_retention[tier].db_last_time_s;
    }

    bool timeframe_matches =
            (tiers_added &&
             query_matches_retention(qt->window.after, qt->window.before, common_first_time_s, common_last_time_s, common_update_every_s))
            ? true : false;

    if(timeframe_matches) {
        if(ri->rrdset)
            ri->rrdset->last_accessed_time_s = qtl->start_s;

        if (qt->query.used == qt->query.size) {
            size_t old_mem = qt->query.size * sizeof(*qt->query.array);
            qt->query.size = query_target_realloc_size(qt->query.size, 4);
            size_t new_mem = qt->query.size * sizeof(*qt->query.array);
            qt->query.array = reallocz(qt->query.array, new_mem);

            __atomic_add_fetch(&netdata_buffers_statistics.query_targets_size, new_mem - old_mem, __ATOMIC_RELAXED);
        }
        QUERY_METRIC *qm = &qt->query.array[qt->query.used++];
        memset(qm, 0, sizeof(*qm));

        qm->status = options;

        qm->link.query_node_id = qn->slot;
        qm->link.query_context_id = qc->slot;
        qm->link.query_instance_id = qi->slot;
        qm->link.query_dimension_id = qd_slot;

        if (!qt->db.first_time_s || common_first_time_s < qt->db.first_time_s)
            qt->db.first_time_s = common_first_time_s;

        if (!qt->db.last_time_s || common_last_time_s > qt->db.last_time_s)
            qt->db.last_time_s = common_last_time_s;

        for (size_t tier = 0; tier < nd_profile.storage_tiers; tier++) {
            internal_fatal(tier_retention[tier].eng != query_metric_storage_engine(qt, qm, tier), "QUERY TARGET: storage engine mismatch");
            qm->tiers[tier].smh = tier_retention[tier].smh;
            qm->tiers[tier].db_first_time_s = tier_retention[tier].db_first_time_s;
            qm->tiers[tier].db_last_time_s = tier_retention[tier].db_last_time_s;
            qm->tiers[tier].db_update_every_s = tier_retention[tier].db_update_every_s;
        }

        return true;
    }

    // cleanup anything we allocated to the retention we will not use
    for(size_t tier = 0; tier < nd_profile.storage_tiers;tier++) {
        if (tier_retention[tier].smh) {
            tier_retention[tier].eng->api.metric_release(tier_retention[tier].smh);
            tier_retention[tier].smh = NULL;
        }
    }

    return false;
}

static inline bool rrdmetric_retention_matches_query(QUERY_TARGET *qt, RRDMETRIC *rm, time_t now_s) {
    time_t first_time_s = rm->first_time_s;
    time_t last_time_s = rrd_flag_is_collected(rm) ? now_s : rm->last_time_s;
    time_t update_every_s = rm->ri->update_every_s;
    return query_matches_retention(qt->window.after, qt->window.before, first_time_s, last_time_s, update_every_s);
}

static inline void query_dimension_release(QUERY_DIMENSION *qd) {
    rrdmetric_release(qd->rma);
    qd->rma = NULL;
}

static QUERY_DIMENSION *query_dimension_allocate(QUERY_TARGET *qt, RRDMETRIC_ACQUIRED *rma, QUERY_STATUS status, size_t priority) {
    if(qt->dimensions.used == qt->dimensions.size) {
        size_t old_mem = qt->dimensions.size * sizeof(*qt->dimensions.array);
        qt->dimensions.size = query_target_realloc_size(qt->dimensions.size, 4);
        size_t new_mem = qt->dimensions.size * sizeof(*qt->dimensions.array);
        qt->dimensions.array = reallocz(qt->dimensions.array, new_mem);

        __atomic_add_fetch(&netdata_buffers_statistics.query_targets_size, new_mem - old_mem, __ATOMIC_RELAXED);
    }
    QUERY_DIMENSION *qd = &qt->dimensions.array[qt->dimensions.used];
    memset(qd, 0, sizeof(*qd));

    qd->slot = qt->dimensions.used++;
    qd->rma = rrdmetric_acquired_dup(rma);
    qd->status = status;
    qd->priority = priority;

    return qd;
}

static bool query_dimension_add(QUERY_TARGET_LOCALS *qtl, QUERY_NODE *qn, QUERY_CONTEXT *qc, QUERY_INSTANCE *qi,
                                RRDMETRIC_ACQUIRED *rma, bool queryable_instance, size_t *metrics_added, size_t priority) {
    QUERY_TARGET *qt = qtl->qt;

    RRDMETRIC *rm = rrdmetric_acquired_value(rma);
    if(rrd_flag_is_deleted(rm))
        return false;
    
    // Check scope_dimensions first - if it doesn't match, skip entirely
    if(qt->dimensions.scope_pattern) {
        SIMPLE_PATTERN_RESULT ret = SP_NOT_MATCHED;
        
        if(qtl->match_ids)
            ret = simple_pattern_matches_string_extract(qt->dimensions.scope_pattern, rm->id, NULL, 0);
            
        if(ret == SP_NOT_MATCHED && qtl->match_names && (rm->name != rm->id || !qtl->match_ids))
            ret = simple_pattern_matches_string_extract(qt->dimensions.scope_pattern, rm->name, NULL, 0);
            
        if(ret != SP_MATCHED_POSITIVE)
            return false;  // Skip this dimension entirely - not in scope
    }

    QUERY_STATUS status = QUERY_STATUS_NONE;

    bool undo = false;
    if(!queryable_instance) {
        if(rrdmetric_retention_matches_query(qt, rm, qtl->start_s)) {
            qi->metrics.excluded++;
            qc->metrics.excluded++;
            qn->metrics.excluded++;
            status |= QUERY_STATUS_EXCLUDED;
        }
        else
            undo = true;
    }
    else {
        RRDR_DIMENSION_FLAGS options = RRDR_DIMENSION_DEFAULT;
        bool needed = false;

        if (qt->query.pattern) {
            // the user asked for specific dimensions

            SIMPLE_PATTERN_RESULT ret = SP_NOT_MATCHED;

            if(qtl->match_ids)
                ret = simple_pattern_matches_string_extract(qt->query.pattern, rm->id, NULL, 0);

            if(ret == SP_NOT_MATCHED && qtl->match_names && (rm->name != rm->id || !qtl->match_ids))
                ret = simple_pattern_matches_string_extract(qt->query.pattern, rm->name, NULL, 0);

            if(ret == SP_MATCHED_POSITIVE) {
                needed = true;
                options |= RRDR_DIMENSION_SELECTED | RRDR_DIMENSION_NONZERO;
            }
            else {
                // the user selection does not match this dimension
                // but, we may still need to query it

                if (query_target_needs_all_dimensions(qt)) {
                    // this is percentage calculation
                    // so, we need this dimension to calculate the percentage
                    needed = true;
                    options |= RRDR_DIMENSION_HIDDEN;
                }
                else {
                    // the user did not select this dimension
                    // and the calculation is not percentage
                    // so, no need to query it
                    ;
                }
            }
        }
        else {
            // we don't have a dimensions pattern
            // so this is a selected dimension
            // if it is not hidden
            RRDDIM *rd = rrdmetric_rrddim_get_and_lock(rm);
            bool hidden = rrd_flag_check(rm, RRD_FLAG_HIDDEN) || (rd && rrddim_option_check(rd, RRDDIM_OPTION_HIDDEN));
            rrdmetric_rrddim_unlock(rd);

            if(hidden) {
                // this is a hidden dimension
                // we don't need to query it
                status |= QUERY_STATUS_DIMENSION_HIDDEN;
                options |= RRDR_DIMENSION_HIDDEN;

                if (query_target_needs_all_dimensions(qt)) {
                    // this is percentage calculation
                    // so, we need this dimension to calculate the percentage
                    needed = true;
                }
            }
            else {
                // this is a not hidden dimension
                // and the user did not provide any selection for dimensions
                // so, we need to query it
                needed = true;
                options |= RRDR_DIMENSION_SELECTED;
            }
        }

        if (needed) {
            if(query_metric_add(qtl, qn, qc, qi, qt->dimensions.used, rm, options)) {
                (*metrics_added)++;

                qi->metrics.selected++;
                qc->metrics.selected++;
                qn->metrics.selected++;
            }
            else {
                undo = true;
                qtl->metrics_skipped_due_to_not_matching_timeframe++;
            }
        }
        else if(rrdmetric_retention_matches_query(qt, rm, qtl->start_s)) {
            qi->metrics.excluded++;
            qc->metrics.excluded++;
            qn->metrics.excluded++;
            status |= QUERY_STATUS_EXCLUDED;
        }
        else
            undo = true;
    }

    if(undo)
        return false;

    query_dimension_allocate(qt, rma, status, priority);
    return true;
}

static inline STRING *rrdinstance_create_id_fqdn_v1(RRDINSTANCE_ACQUIRED *ria) {
    if(unlikely(!ria))
        return NULL;

    RRDINSTANCE *ri = rrdinstance_acquired_value(ria);
    return string_dup(ri->id);
}

static inline STRING *rrdinstance_create_name_fqdn_v1(RRDINSTANCE_ACQUIRED *ria) {
    if(unlikely(!ria))
        return NULL;

    RRDINSTANCE *ri = rrdinstance_acquired_value(ria);
    return string_dup(ri->name);
}

static inline STRING *rrdinstance_create_id_fqdn_v2(RRDINSTANCE_ACQUIRED *ria) {
    if(unlikely(!ria))
        return NULL;

    char buffer[RRD_ID_LENGTH_MAX + 1];

    RRDHOST *host = rrdinstance_acquired_rrdhost(ria);
    snprintfz(buffer, RRD_ID_LENGTH_MAX, "%s@%s", rrdinstance_acquired_id(ria), host->machine_guid);
    return string_strdupz(buffer);
}

static inline STRING *rrdinstance_create_name_fqdn_v2(RRDINSTANCE_ACQUIRED *ria) {
    if(unlikely(!ria))
        return NULL;

    char buffer[RRD_ID_LENGTH_MAX + 1];

    RRDHOST *host = rrdinstance_acquired_rrdhost(ria);
    snprintfz(buffer, RRD_ID_LENGTH_MAX, "%s@%s", rrdinstance_acquired_name(ria), rrdhost_hostname(host));
    return string_strdupz(buffer);
}

inline STRING *query_instance_id_fqdn(QUERY_INSTANCE *qi, size_t version) {
    if(!qi->id_fqdn) {
        if (version <= 1)
            qi->id_fqdn = rrdinstance_create_id_fqdn_v1(qi->ria);
        else
            qi->id_fqdn = rrdinstance_create_id_fqdn_v2(qi->ria);
    }

    return qi->id_fqdn;
}

inline STRING *query_instance_name_fqdn(QUERY_INSTANCE *qi, size_t version) {
    if(!qi->name_fqdn) {
        if (version <= 1)
            qi->name_fqdn = rrdinstance_create_name_fqdn_v1(qi->ria);
        else
            qi->name_fqdn = rrdinstance_create_name_fqdn_v2(qi->ria);
    }

    return qi->name_fqdn;
}

RRDSET *rrdinstance_acquired_rrdset(RRDINSTANCE_ACQUIRED *ria) {
    RRDINSTANCE *ri = rrdinstance_acquired_value(ria);
    return ri->rrdset;
}

const char *rrdcontext_acquired_units(RRDCONTEXT_ACQUIRED *rca) {
    RRDCONTEXT *rc = rrdcontext_acquired_value(rca);
    return string2str(rc->units);
}

RRDSET_TYPE rrdcontext_acquired_chart_type(RRDCONTEXT_ACQUIRED *rca) {
    RRDCONTEXT *rc = rrdcontext_acquired_value(rca);
    return rc->chart_type;
}

const char *rrdcontext_acquired_title(RRDCONTEXT_ACQUIRED *rca) {
    RRDCONTEXT *rc = rrdcontext_acquired_value(rca);
    return string2str(rc->title);
}

static void query_target_eval_instance_rrdcalc(QUERY_TARGET_LOCALS *qtl __maybe_unused,
                                               QUERY_NODE *qn, QUERY_CONTEXT *qc, QUERY_INSTANCE *qi) {
    RRDSET *st = rrdinstance_acquired_rrdset(qi->ria);
    if (st) {
        rw_spinlock_read_lock(&st->alerts.spinlock);
        for (RRDCALC *rc = st->alerts.base; rc; rc = rc->next) {
            switch(rc->status) {
                case RRDCALC_STATUS_CLEAR:
                    qi->alerts.clear++;
                    qc->alerts.clear++;
                    qn->alerts.clear++;
                    break;

                case RRDCALC_STATUS_WARNING:
                    qi->alerts.warning++;
                    qc->alerts.warning++;
                    qn->alerts.warning++;
                    break;

                case RRDCALC_STATUS_CRITICAL:
                    qi->alerts.critical++;
                    qc->alerts.critical++;
                    qn->alerts.critical++;
                    break;

                default:
                case RRDCALC_STATUS_UNINITIALIZED:
                case RRDCALC_STATUS_UNDEFINED:
                case RRDCALC_STATUS_REMOVED:
                    qi->alerts.other++;
                    qc->alerts.other++;
                    qn->alerts.other++;
                    break;
            }
        }
        rw_spinlock_read_unlock(&st->alerts.spinlock);
    }
}

static bool query_target_match_alert_pattern(RRDINSTANCE_ACQUIRED *ria, SIMPLE_PATTERN *pattern) {
    if(!pattern)
        return true;

    RRDSET *st = rrdinstance_acquired_rrdset(ria);
    if (!st)
        return false;

    BUFFER *wb = NULL;
    bool matched = false;
    rw_spinlock_read_lock(&st->alerts.spinlock);
    if (st->alerts.base) {
        for (RRDCALC *rc = st->alerts.base; rc; rc = rc->next) {
            SIMPLE_PATTERN_RESULT ret = simple_pattern_matches_string_extract(pattern, rc->config.name, NULL, 0);

            if(ret == SP_MATCHED_POSITIVE) {
                matched = true;
                break;
            }
            else if(ret == SP_MATCHED_NEGATIVE)
                break;

            if (!wb)
                wb = buffer_create(0, NULL);
            else
                buffer_flush(wb);

            buffer_fast_strcat(wb, string2str(rc->config.name), string_strlen(rc->config.name));
            buffer_fast_strcat(wb, ":", 1);
            buffer_strcat(wb, rrdcalc_status2string(rc->status));

            ret = simple_pattern_matches_buffer_extract(pattern, wb, NULL, 0);

            if(ret == SP_MATCHED_POSITIVE) {
                matched = true;
                break;
            }
            else if(ret == SP_MATCHED_NEGATIVE)
                break;
        }
    }
    rw_spinlock_read_unlock(&st->alerts.spinlock);

    buffer_free(wb);
    return matched;
}

static inline void query_instance_strings_free(QUERY_INSTANCE *qi) {
    string_freez(qi->id_fqdn);
    qi->id_fqdn = NULL;

    string_freez(qi->name_fqdn);
    qi->name_fqdn = NULL;
}

static inline void query_instance_release(QUERY_INSTANCE *qi) {
    if(qi->ria) {
        rrdinstance_release(qi->ria);
        qi->ria = NULL;
    }

    query_instance_strings_free(qi);
}

static inline QUERY_INSTANCE *query_instance_allocate(QUERY_TARGET *qt, RRDINSTANCE_ACQUIRED *ria, size_t qn_slot) {
    if(qt->instances.used == qt->instances.size) {
        size_t old_mem = qt->instances.size * sizeof(*qt->instances.array);
        qt->instances.size = query_target_realloc_size(qt->instances.size, 2);
        size_t new_mem = qt->instances.size * sizeof(*qt->instances.array);
        qt->instances.array = reallocz(qt->instances.array, new_mem);

        __atomic_add_fetch(&netdata_buffers_statistics.query_targets_size, new_mem - old_mem, __ATOMIC_RELAXED);
    }
    QUERY_INSTANCE *qi = &qt->instances.array[qt->instances.used];
    memset(qi, 0, sizeof(*qi));

    qi->slot = qt->instances.used;
    qt->instances.used++;
    qi->ria = rrdinstance_acquired_dup(ria);
    qi->query_host_id = qn_slot;

    return qi;
}

static inline SIMPLE_PATTERN_RESULT query_instance_matches(QUERY_INSTANCE *qi,
                                             RRDINSTANCE *ri,
                                             SIMPLE_PATTERN *instances_sp,
                                             bool match_ids,
                                             bool match_names,
                                             size_t version,
                                             char *host_node_id_str) {
    SIMPLE_PATTERN_RESULT ret = SP_MATCHED_POSITIVE;

    if(instances_sp) {
        ret = SP_NOT_MATCHED;

        if(match_ids)
            ret = simple_pattern_matches_string_extract(instances_sp, ri->id, NULL, 0);
        if (ret == SP_NOT_MATCHED && match_names && (ri->name != ri->id || !match_ids))
            ret = simple_pattern_matches_string_extract(instances_sp, ri->name, NULL, 0);
        if (ret == SP_NOT_MATCHED && match_ids)
            ret = simple_pattern_matches_string_extract(instances_sp, query_instance_id_fqdn(qi, version), NULL, 0);
        if (ret == SP_NOT_MATCHED && match_names)
            ret = simple_pattern_matches_string_extract(instances_sp, query_instance_name_fqdn(qi, version), NULL, 0);

        if (ret == SP_NOT_MATCHED && match_ids && host_node_id_str[0]) {
            char buffer[RRD_ID_LENGTH_MAX + 1];
            snprintfz(buffer, RRD_ID_LENGTH_MAX, "%s@%s", rrdinstance_acquired_id(qi->ria), host_node_id_str);
            ret = simple_pattern_matches_extract(instances_sp, buffer, NULL, 0);
        }
    }

    return ret;
}

static inline bool query_instance_matches_labels(
    RRDINSTANCE *ri,
    SIMPLE_PATTERN *chart_label_key_sp,
    struct pattern_array *labels_pa)
{
    RRDLABELS *labels = rrdinstance_labels(ri);
    if (chart_label_key_sp && rrdlabels_match_simple_pattern_parsed(labels, chart_label_key_sp, '\0', NULL) != SP_MATCHED_POSITIVE)
        return false;

    if (labels_pa) {
        return pattern_array_label_match(labels_pa, labels, ':', NULL);
    }

    return true;
}

static bool query_instance_add(QUERY_TARGET_LOCALS *qtl, QUERY_NODE *qn, QUERY_CONTEXT *qc,
                               RRDINSTANCE_ACQUIRED *ria, bool queryable_instance, bool filter_instances) {
    RRDINSTANCE *ri = rrdinstance_acquired_value(ria);
    if(rrd_flag_is_deleted(ri))
        return false;

    QUERY_TARGET *qt = qtl->qt;
    QUERY_INSTANCE *qi = query_instance_allocate(qt, ria, qn->slot);

    if(queryable_instance && filter_instances)
        queryable_instance = (SP_MATCHED_POSITIVE == query_instance_matches(
                qi, ri, qt->instances.pattern, qtl->match_ids, qtl->match_names, qt->request.version, qtl->host_node_id_str));

    if(queryable_instance)
        queryable_instance = query_instance_matches_labels(
            ri,
            qt->instances.chart_label_key_pattern,
            qt->instances.labels_pa);

    if(queryable_instance) {
        if(qt->instances.alerts_pattern && !query_target_match_alert_pattern(ria, qt->instances.alerts_pattern))
            queryable_instance = false;
    }

    if(queryable_instance && qt->request.version >= 2)
        query_target_eval_instance_rrdcalc(qtl, qn, qc, qi);

    size_t dimensions_added = 0, metrics_added = 0, priority = 0;

    if(unlikely(qt->request.rma)) {
        if(query_dimension_add(qtl, qn, qc, qi, qt->request.rma, queryable_instance, &metrics_added, priority++))
            dimensions_added++;
    }
    else {
        RRDMETRIC *rm;
        dfe_start_read(ri->rrdmetrics, rm) {
            if(query_dimension_add(qtl, qn, qc, qi, (RRDMETRIC_ACQUIRED *) rm_dfe.item,
                                   queryable_instance, &metrics_added, priority++))
                dimensions_added++;
        }
        dfe_done(rm);
    }

    if(!dimensions_added) {
        qt->instances.used--;
        query_instance_release(qi);
        return false;
    }
    else {
        if(metrics_added) {
            if(qt->db.minimum_latest_update_every_s == 0 || ri->update_every_s < qt->db.minimum_latest_update_every_s)
                qt->db.minimum_latest_update_every_s = ri->update_every_s;

            qc->instances.selected++;
            qn->instances.selected++;
        }
        else {
            qc->instances.excluded++;
            qn->instances.excluded++;
        }
    }

    return true;
}

static inline void query_context_release(QUERY_CONTEXT *qc) {
    rrdcontext_release(qc->rca);
    qc->rca = NULL;
}

static inline QUERY_CONTEXT *query_context_allocate(QUERY_TARGET *qt, RRDCONTEXT_ACQUIRED *rca) {
    if(qt->contexts.used == qt->contexts.size) {
        size_t old_mem = qt->contexts.size * sizeof(*qt->contexts.array);
        qt->contexts.size = query_target_realloc_size(qt->contexts.size, 2);
        size_t new_mem = qt->contexts.size * sizeof(*qt->contexts.array);
        qt->contexts.array = reallocz(qt->contexts.array, new_mem);

        __atomic_add_fetch(&netdata_buffers_statistics.query_targets_size, new_mem - old_mem, __ATOMIC_RELAXED);
    }
    QUERY_CONTEXT *qc = &qt->contexts.array[qt->contexts.used];
    memset(qc, 0, sizeof(*qc));
    qc->slot = qt->contexts.used++;
    qc->rca =  rrdcontext_acquired_dup(rca);

    return qc;
}

static ssize_t query_scope_foreach_instance(QUERY_TARGET_LOCALS *qtl, QUERY_NODE *qn, QUERY_CONTEXT *qc,
                                           RRDCONTEXT_ACQUIRED *rca, bool queryable_context) {
    QUERY_TARGET *qt = qtl->qt;
    RRDCONTEXT *rc = rrdcontext_acquired_value(rca);
    ssize_t added = 0;

    if(unlikely(qt->request.ria)) {
        // Single instance requested
        RRDINSTANCE *ri = rrdinstance_acquired_value(qt->request.ria);
        
        // Check scope_instances
        if(qt->instances.scope_pattern) {
            QUERY_INSTANCE qi = { .ria = qt->request.ria };
            SIMPLE_PATTERN_RESULT ret = query_instance_matches(&qi, ri,
                qt->instances.scope_pattern, qtl->match_ids, qtl->match_names, 
                qt->request.version, qtl->host_node_id_str);
            query_instance_strings_free(&qi);
            if(ret != SP_MATCHED_POSITIVE)
                return 0;
        }
        
        // Check scope_labels
        if(qt->instances.scope_labels_pa || qt->instances.scope_chart_label_key_pattern) {
            if(!query_instance_matches_labels(ri,
                qt->instances.scope_chart_label_key_pattern,
                qt->instances.scope_labels_pa))
                return 0;
        }
        
        if(query_instance_add(qtl, qn, qc, qt->request.ria, queryable_context, false))
            added++;
    }
    else if(unlikely(qtl->st && qtl->st->rrdcontexts.rrdcontext == rca)) {
        // Single chart requested
        RRDINSTANCE_ACQUIRED *ria = (RRDINSTANCE_ACQUIRED *)dictionary_get_and_acquire_item(
            rc->rrdinstances, string2str(qtl->st->id));
        if(unlikely(!ria))
            return 0;

        RRDINSTANCE *ri = rrdinstance_acquired_value(ria);
        
        // Check scope_instances
        if(qt->instances.scope_pattern) {
            QUERY_INSTANCE qi = { .ria = ria };
            SIMPLE_PATTERN_RESULT ret = query_instance_matches(&qi, ri,
                qt->instances.scope_pattern, qtl->match_ids, qtl->match_names, 
                qt->request.version, qtl->host_node_id_str);
            query_instance_strings_free(&qi);
            if(ret != SP_MATCHED_POSITIVE) {
                rrdinstance_release(ria);
                return 0;
            }
        }
        
        // Check scope_labels
        if(qt->instances.scope_labels_pa || qt->instances.scope_chart_label_key_pattern) {
            if(!query_instance_matches_labels(ri,
                qt->instances.scope_chart_label_key_pattern,
                qt->instances.scope_labels_pa)) {
                rrdinstance_release(ria);
                return 0;
            }
        }
        
        if(query_instance_add(qtl, qn, qc, ria, queryable_context, false))
            added++;

        rrdinstance_release(ria);
    }
    else {
        // Pattern query - iterate through all instances
        RRDINSTANCE *ri;
        dfe_start_read(rc->rrdinstances, ri) {
            if(rrd_flag_is_deleted(ri))
                continue;

            RRDINSTANCE_ACQUIRED *ria = (RRDINSTANCE_ACQUIRED *) ri_dfe.item;
            
            // Check scope_instances
            if(qt->instances.scope_pattern) {
                QUERY_INSTANCE qi = { .ria = ria };
                SIMPLE_PATTERN_RESULT ret = query_instance_matches(&qi, ri,
                    qt->instances.scope_pattern, qtl->match_ids, qtl->match_names, 
                    qt->request.version, qtl->host_node_id_str);
                query_instance_strings_free(&qi);
                if(ret != SP_MATCHED_POSITIVE)
                    continue;
            }
            
            // Check scope_labels
            if(qt->instances.scope_labels_pa || qt->instances.scope_chart_label_key_pattern) {
                if(!query_instance_matches_labels(ri,
                    qt->instances.scope_chart_label_key_pattern,
                    qt->instances.scope_labels_pa))
                    continue;
            }
            
            if(query_instance_add(qtl, qn, qc, ria, queryable_context, true))
                added++;
        }
        dfe_done(ri);
    }
    
    return added;
}

static ssize_t query_context_add(void *data, RRDCONTEXT_ACQUIRED *rca, bool queryable_context) {
    QUERY_TARGET_LOCALS *qtl = data;

    RRDCONTEXT *rc = rrdcontext_acquired_value(rca);
    if(rrd_flag_is_deleted(rc))
        return 0;

    QUERY_NODE *qn = qtl->qn;
    QUERY_TARGET *qt = qtl->qt;
    QUERY_CONTEXT *qc = query_context_allocate(qt, rca);

    ssize_t added = query_scope_foreach_instance(qtl, qn, qc, rca, queryable_context);

    if(!added) {
        query_context_release(qc);
        qt->contexts.used--;
        return 0;
    }

    return added;
}

static inline void query_node_release(QUERY_NODE *qn) {
    qn->rrdhost = NULL;
}

static inline QUERY_NODE *query_node_allocate(QUERY_TARGET *qt, RRDHOST *host) {
    if(qt->nodes.used == qt->nodes.size) {
        size_t old_mem = qt->nodes.size * sizeof(*qt->nodes.array);
        qt->nodes.size = query_target_realloc_size(qt->nodes.size, 2);
        size_t new_mem = qt->nodes.size * sizeof(*qt->nodes.array);
        qt->nodes.array = reallocz(qt->nodes.array, new_mem);

        __atomic_add_fetch(&netdata_buffers_statistics.query_targets_size, new_mem - old_mem, __ATOMIC_RELAXED);
    }
    QUERY_NODE *qn = &qt->nodes.array[qt->nodes.used];
    memset(qn, 0, sizeof(*qn));

    qn->slot = qt->nodes.used++;
    qn->rrdhost = host;

    return qn;
}

static ssize_t query_node_add(void *data, RRDHOST *host, bool queryable_host) {
    QUERY_TARGET_LOCALS *qtl = data;
    QUERY_TARGET *qt = qtl->qt;
    QUERY_NODE *qn = query_node_allocate(qt, host);

    if(!UUIDiszero(host->node_id)) {
        if(!qtl->host_node_id_str[0])
            uuid_unparse_lower(host->node_id.uuid, qn->node_id);
        else
            memcpy(qn->node_id, qtl->host_node_id_str, sizeof(qn->node_id));
    }
    else
        qn->node_id[0] = '\0';

    // is the chart given valid?
    if(unlikely(qtl->st && (!qtl->st->rrdcontexts.rrdinstance || !qtl->st->rrdcontexts.rrdcontext))) {
        netdata_log_error("QUERY TARGET: RRDSET '%s' given, but it is not linked to rrdcontext structures. Linking it now.", rrdset_name(qtl->st));
        rrdinstance_from_rrdset(qtl->st);

        if(unlikely(qtl->st && (!qtl->st->rrdcontexts.rrdinstance || !qtl->st->rrdcontexts.rrdcontext))) {
            netdata_log_error("QUERY TARGET: RRDSET '%s' given, but failed to be linked to rrdcontext structures. Switching to context query.",
                              rrdset_name(qtl->st));

            if (!is_valid_sp(qtl->instances))
                qtl->instances = rrdset_name(qtl->st);

            qtl->st = NULL;
        }
    }

    qtl->qn = qn;

    ssize_t added = 0;
    if(unlikely(qt->request.rca)) {
        if(query_context_add(qtl, qt->request.rca, true))
            added++;
    }
    else if(unlikely(qtl->st)) {
        // single chart data queries
        if(query_context_add(qtl, qtl->st->rrdcontexts.rrdcontext, true))
            added++;
    }
    else {
        // context pattern queries
        added = query_scope_foreach_context(
                host, qtl->scope_contexts,
                qt->contexts.scope_pattern, qt->contexts.pattern,
                query_context_add, queryable_host, qtl);

        if(added < 0)
            added = 0;
    }

    qtl->qn = NULL;

    if(!added) {
        query_node_release(qn);
        qt->nodes.used--;
        return false;
    }

    return true;
}

void query_target_generate_name(QUERY_TARGET *qt) {
    char options_buffer[100 + 1];
    web_client_api_request_data_vX_options_to_string(options_buffer, 100, qt->request.options);

    char resampling_buffer[20 + 1] = "";
    if(qt->request.resampling_time > 1)
        snprintfz(resampling_buffer, 20, "/resampling:%lld", (long long)qt->request.resampling_time);

    char tier_buffer[20 + 1] = "";
    if(qt->request.options & RRDR_OPTION_SELECTED_TIER)
        snprintfz(tier_buffer, 20, "/tier:%zu", qt->request.tier);

    if(qt->request.st)
        snprintfz(qt->id, MAX_QUERY_TARGET_ID_LENGTH, "chart://hosts:%s/instance:%s/dimensions:%s/after:%lld/before:%lld/points:%zu/group:%s%s/options:%s%s%s"
                , rrdhost_hostname(qt->request.st->rrdhost)
                , rrdset_name(qt->request.st)
                , (qt->request.dimensions) ? qt->request.dimensions : "*"
                , (long long)qt->request.after
                , (long long)qt->request.before
                , qt->request.points
                , time_grouping_tostring(qt->request.time_group_method)
                , qt->request.time_group_options ? qt->request.time_group_options : ""
                , options_buffer
                , resampling_buffer
                , tier_buffer
        );
    else if(qt->request.host && qt->request.rca && qt->request.ria && qt->request.rma)
        snprintfz(qt->id, MAX_QUERY_TARGET_ID_LENGTH, "metric://hosts:%s/context:%s/instance:%s/dimension:%s/after:%lld/before:%lld/points:%zu/group:%s%s/options:%s%s%s"
                , rrdhost_hostname(qt->request.host)
                , rrdcontext_acquired_id(qt->request.rca)
                , rrdinstance_acquired_id(qt->request.ria)
                , rrdmetric_acquired_id(qt->request.rma)
                , (long long)qt->request.after
                , (long long)qt->request.before
                , qt->request.points
                , time_grouping_tostring(qt->request.time_group_method)
                , qt->request.time_group_options ? qt->request.time_group_options : ""
                , options_buffer
                , resampling_buffer
                , tier_buffer
        );
    else if(qt->request.version >= 2)
        snprintfz(qt->id, MAX_QUERY_TARGET_ID_LENGTH, "data_v2://scope_nodes:%s/scope_contexts:%s/scope_instances:%s/scope_labels:%s/scope_dimensions:%s/nodes:%s/contexts:%s/instances:%s/labels:%s/dimensions:%s/after:%lld/before:%lld/points:%zu/time_group:%s%s/options:%s%s%s"
                , qt->request.scope_nodes ? qt->request.scope_nodes : "*"
                , qt->request.scope_contexts ? qt->request.scope_contexts : "*"
                , qt->request.scope_instances ? qt->request.scope_instances : "*"
                , qt->request.scope_labels ? qt->request.scope_labels : "*"
                , qt->request.scope_dimensions ? qt->request.scope_dimensions : "*"
                , qt->request.nodes ? qt->request.nodes : "*"
                , (qt->request.contexts) ? qt->request.contexts : "*"
                , (qt->request.instances) ? qt->request.instances : "*"
                , (qt->request.labels) ? qt->request.labels : "*"
                , (qt->request.dimensions) ? qt->request.dimensions : "*"
                , (long long)qt->request.after
                , (long long)qt->request.before
                , qt->request.points
                , time_grouping_tostring(qt->request.time_group_method)
                , qt->request.time_group_options ? qt->request.time_group_options : ""
                , options_buffer
                , resampling_buffer
                , tier_buffer
        );
    else
        snprintfz(qt->id, MAX_QUERY_TARGET_ID_LENGTH, "context://hosts:%s/contexts:%s/instances:%s/dimensions:%s/after:%lld/before:%lld/points:%zu/group:%s%s/options:%s%s%s"
                , (qt->request.host) ? rrdhost_hostname(qt->request.host) : ((qt->request.nodes) ? qt->request.nodes : "*")
                , (qt->request.contexts) ? qt->request.contexts : "*"
                , (qt->request.instances) ? qt->request.instances : "*"
                , (qt->request.dimensions) ? qt->request.dimensions : "*"
                , (long long)qt->request.after
                , (long long)qt->request.before
                , qt->request.points
                , time_grouping_tostring(qt->request.time_group_method)
                , qt->request.time_group_options ? qt->request.time_group_options : ""
                , options_buffer
                , resampling_buffer
                , tier_buffer
        );

    // Sanitize the query ID - safe because qt->id is ASCII-only (from snprintfz)
    char buf[MAX_QUERY_TARGET_ID_LENGTH + 1];
    text_sanitize((unsigned char *)buf, (const unsigned char *)qt->id, sizeof(buf),
                  rrd_string_allowed_chars, true, "", NULL);
    strcpy(qt->id, buf);
}

QUERY_TARGET *query_target_create(QUERY_TARGET_REQUEST *qtr) {
    //if(!service_running(ABILITY_DATA_QUERIES))
    //    return NULL;

    QUERY_TARGET *qt = query_target_get();

    if(!qtr->received_ut)
        qtr->received_ut = now_monotonic_usec();

    qt->timings.received_ut = qtr->received_ut;

    if(qtr->nodes && !qtr->scope_nodes)
        qtr->scope_nodes = qtr->nodes;

    if(qtr->contexts && !qtr->scope_contexts)
        qtr->scope_contexts = qtr->contexts;

    // IMPORTANT: old dashboards do not know about scope_instances and scope_labels
    // so this code makes non-scope instances and labels to be used as scope.
    // Leave it commented!

    // if(qtr->instances && !qtr->scope_instances)
    //     qtr->scope_instances = qtr->instances;
    //
    // if(qtr->labels && !qtr->scope_labels)
    //     qtr->scope_labels = qtr->labels;

    memset(&qt->db, 0, sizeof(qt->db));
    qt->query_points = STORAGE_POINT_UNSET;

    // copy the request into query_thread_target
    qt->request = *qtr;

    query_target_generate_name(qt);
    qt->window.after = qt->request.after;
    qt->window.before = qt->request.before;

    qt->window.options = qt->request.options;
    if(query_target_has_percentage_of_group(qt))
        qt->window.options &= ~RRDR_OPTION_PERCENTAGE;

    qt->internal.relative = rrdr_relative_window_to_absolute_query(&qt->window.after, &qt->window.before
                                                                   , &qt->window.now, unittest_running
                                                                  );

    // prepare our local variables - we need these across all these functions
    QUERY_TARGET_LOCALS qtl = {
            .qt = qt,
            .start_s = now_realtime_sec(),
            .st = qt->request.st,
            .scope_nodes = qt->request.scope_nodes,
            .scope_contexts = qt->request.scope_contexts,
            .scope_instances = qt->request.scope_instances,
            .scope_labels = qt->request.scope_labels,
            .scope_dimensions = qt->request.scope_dimensions,
            .nodes = qt->request.nodes,
            .contexts = qt->request.contexts,
            .instances = qt->request.instances,
            .dimensions = qt->request.dimensions,
            .chart_label_key = qt->request.chart_label_key,
            .labels = qt->request.labels,
            .alerts = qt->request.alerts,
    };

    RRDHOST *host = qt->request.host;

    // prepare all the patterns
    qt->nodes.scope_pattern = string_to_simple_pattern(qtl.scope_nodes);
    qt->nodes.pattern = string_to_simple_pattern(qtl.nodes);

    qt->contexts.pattern = string_to_simple_pattern(qtl.contexts);
    qt->contexts.scope_pattern = string_to_simple_pattern(qtl.scope_contexts);

    qt->instances.pattern = string_to_simple_pattern(qtl.instances);
    qt->instances.scope_pattern = string_to_simple_pattern(qtl.scope_instances);
    qt->query.pattern = string_to_simple_pattern(qtl.dimensions);
    qt->dimensions.scope_pattern = string_to_simple_pattern(qtl.scope_dimensions);
    qt->instances.chart_label_key_pattern = string_to_simple_pattern(qtl.chart_label_key);
    qt->instances.scope_chart_label_key_pattern = string_to_simple_pattern(qtl.chart_label_key);  // For now, using same as non-scope
    qt->instances.labels_pattern = string_to_simple_pattern(qtl.labels);
    qt->instances.scope_labels_pattern = string_to_simple_pattern(qtl.scope_labels);
    qt->instances.alerts_pattern = string_to_simple_pattern(qtl.alerts);
    
    // Pre-compile pattern arrays for labels
    if(qt->instances.labels_pattern)
        qt->instances.labels_pa = pattern_array_add_simple_pattern(NULL, qt->instances.labels_pattern, ':');
    if(qt->instances.scope_labels_pattern)
        qt->instances.scope_labels_pa = pattern_array_add_simple_pattern(NULL, qt->instances.scope_labels_pattern, ':');

    qtl.match_ids = qt->request.options & RRDR_OPTION_MATCH_IDS;
    qtl.match_names = qt->request.options & RRDR_OPTION_MATCH_NAMES;
    if(likely(!qtl.match_ids && !qtl.match_names))
        qtl.match_ids = qtl.match_names = true;

    // verify that the chart belongs to the host we are interested
    if(qtl.st) {
        if (!host) {
            // It is NULL, set it ourselves.
            host = qtl.st->rrdhost;
        }
        else if (unlikely(host != qtl.st->rrdhost)) {
            // Oops! A different host!
            netdata_log_error("QUERY TARGET: RRDSET '%s' given does not belong to host '%s'. Switching query host to '%s'",
                  rrdset_name(qtl.st), rrdhost_hostname(host), rrdhost_hostname(qtl.st->rrdhost));
            host = qtl.st->rrdhost;
        }
    }

    if(host) {
        if(!UUIDiszero(host->node_id))
            uuid_unparse_lower(host->node_id.uuid, qtl.host_node_id_str);
        else
            qtl.host_node_id_str[0] = '\0';

        // single host query
        qt->versions.contexts_hard_hash = dictionary_version(host->rrdctx.contexts);
        qt->versions.contexts_soft_hash = rrdcontext_queue_version(&host->rrdctx.hub_queue);
        qt->versions.alerts_hard_hash = dictionary_version(host->rrdcalc_root_index);
        qt->versions.alerts_soft_hash = __atomic_load_n(&host->health_transitions, __ATOMIC_RELAXED);
        query_node_add(&qtl, host, true);
        qtl.nodes = rrdhost_hostname(host);
    }
    else
        query_scope_foreach_host(qt->nodes.scope_pattern, qt->nodes.pattern,
                                 query_node_add, &qtl,
                                 &qt->versions,
                                 qtl.host_node_id_str);

    // we need the available db retention for this call
    // so it has to be done last
    query_target_calculate_window(qt);

    qt->timings.preprocessed_ut = now_monotonic_usec();

    return qt;
}

ssize_t weights_foreach_rrdmetric_in_context(RRDCONTEXT_ACQUIRED *rca,
                                            SIMPLE_PATTERN *scope_instances_sp,
                                            struct pattern_array *scope_labels_pa,
                                            SIMPLE_PATTERN *scope_dimensions_sp,
                                            SIMPLE_PATTERN *instances_sp,
                                            SIMPLE_PATTERN *chart_label_key_sp,
                                            struct pattern_array *labels_pa,
                                            SIMPLE_PATTERN *alerts_sp,
                                            SIMPLE_PATTERN *dimensions_sp,
                                            bool match_ids, bool match_names,
                                            size_t version,
                                            weights_add_metric_t cb,
                                            void *data
                                           ) {
    RRDCONTEXT *rc = rrdcontext_acquired_value(rca);
    if(!rc || rrd_flag_is_deleted(rc))
        return 0;

    char host_node_id_str[UUID_STR_LEN] = "";

    bool proceed = true;

    ssize_t count = 0;
    RRDINSTANCE *ri;
    dfe_start_read(rc->rrdinstances, ri) {
                if(rrd_flag_is_deleted(ri))
                    continue;

                RRDINSTANCE_ACQUIRED *ria = (RRDINSTANCE_ACQUIRED *) ri_dfe.item;
                
                // Check scope_instances first - if it doesn't match, skip entirely
                if(scope_instances_sp) {
                    QUERY_INSTANCE qi = { .ria = ria, };
                    SIMPLE_PATTERN_RESULT ret = query_instance_matches(&qi, ri, scope_instances_sp, match_ids, match_names, version, host_node_id_str);
                    query_instance_strings_free(&qi);

                    if (ret != SP_MATCHED_POSITIVE)
                        continue;
                }
                
                // Check scope_labels - if it doesn't match, skip entirely
                if(scope_labels_pa) {
                    if(!query_instance_matches_labels(ri, NULL, scope_labels_pa))
                        continue;
                }

                if(instances_sp) {
                    QUERY_INSTANCE qi = { .ria = ria, };
                    SIMPLE_PATTERN_RESULT ret = query_instance_matches(&qi, ri, instances_sp, match_ids, match_names, version, host_node_id_str);
                    query_instance_strings_free(&qi);

                    if (ret != SP_MATCHED_POSITIVE)
                        continue;
                }

                if(!query_instance_matches_labels(ri, chart_label_key_sp, labels_pa))
                    continue;

                if(alerts_sp && !query_target_match_alert_pattern(ria, alerts_sp))
                    continue;

                dfe_unlock(ri);

                RRDMETRIC *rm;
                dfe_start_read(ri->rrdmetrics, rm) {
                            if(rrd_flag_is_deleted(rm))
                                continue;

                            // Check scope_dimensions first - if it doesn't match, skip entirely
                            if(scope_dimensions_sp) {
                                SIMPLE_PATTERN_RESULT ret = SP_NOT_MATCHED;

                                if (match_ids)
                                    ret = simple_pattern_matches_string_extract(scope_dimensions_sp, rm->id, NULL, 0);

                                if (ret == SP_NOT_MATCHED && match_names && (rm->name != rm->id || !match_ids))
                                    ret = simple_pattern_matches_string_extract(scope_dimensions_sp, rm->name, NULL, 0);

                                if(ret != SP_MATCHED_POSITIVE)
                                    continue;
                            }

                            if(dimensions_sp) {
                                SIMPLE_PATTERN_RESULT ret = SP_NOT_MATCHED;

                                if (match_ids)
                                    ret = simple_pattern_matches_string_extract(dimensions_sp, rm->id, NULL, 0);

                                if (ret == SP_NOT_MATCHED && match_names && (rm->name != rm->id || !match_ids))
                                    ret = simple_pattern_matches_string_extract(dimensions_sp, rm->name, NULL, 0);

                                if(ret != SP_MATCHED_POSITIVE)
                                    continue;
                            }

                            dfe_unlock(rm);

                            RRDMETRIC_ACQUIRED *rma = (RRDMETRIC_ACQUIRED *)rm_dfe.item;
                            ssize_t ret = cb(data, rc->rrdhost, rca, ria, rma);

                            if(ret < 0) {
                                proceed = false;
                                break;
                            }

                            count += ret;
                        }
                dfe_done(rm);

                if(unlikely(!proceed))
                    break;
            }
    dfe_done(ri);
    
    return count;
}
