<?php

// Prevent direct access
if (!defined('ABSPATH')) {
    exit;
}

/**
 * Activity Definition Groups
 *
 * A Definition Group owns a set of activity types (mutually exclusive across
 * groups - a type belongs to at most one group) plus its own private Club
 * Groups, Climbing Profiles, one Difficulty scale, Tags, and an optional
 * hard Distance/Ascent range override. An activity type tagged into no group
 * is "unassigned" and sees the union of every UNTAGGED group's content
 * instead (never a tagged group's - that stays exclusive to its own types).
 *
 * This file provides the raw option accessor plus the resolver functions
 * used to determine what applies to a given activity type. The legacy
 * per-dimension accessors (rfcc_get_club_groups() etc. in their own admin
 * files) are reimplemented as flattening functions over this option - see
 * rfcc_flatten_definition_group_dimension() below.
 */

// Get all Definition Groups, in admin-defined order.
function rfcc_get_definition_groups() {
    $groups = get_option('rfcc_activity_definition_groups', array());
    $groups = wp_unslash($groups);
    return is_array($groups) ? $groups : array();
}

/**
 * The Definition Group that owns a given activity type, or null if the type
 * is unassigned (belongs to no group). An untagged group (activity_types
 * === []) never "owns" any type - it only ever contributes to the
 * unassigned-type union, mirroring today's "empty activity_types = applies
 * everywhere" convention one level up.
 *
 * @param string $activity_type_name
 * @return array|null
 */
function rfcc_get_definition_group_for_activity_type($activity_type_name) {
    if (empty($activity_type_name)) {
        return null;
    }
    foreach (rfcc_get_definition_groups() as $group) {
        if (!empty($group['activity_types']) && in_array($activity_type_name, $group['activity_types'], true)) {
            return $group;
        }
    }
    return null;
}

/**
 * Activity type names claimed by NO tagged Definition Group - i.e. the set
 * an untagged group's content actually applies to (see the "unassigned"
 * union rule documented at the top of this file). Used by the two flatten
 * functions below so an untagged group's items get an accurate
 * `activity_types` list instead of a bare `[]` - `[]` used to be this
 * project's "applies to literally everything" convention, which was
 * correct back when an untagged group was the only group that existed, but
 * became wrong the moment a type gets its own tagged group: that type is no
 * longer unassigned, so the untagged group's content must stop matching it.
 *
 * @param array|null $groups Optional - pass an already-fetched
 *        rfcc_get_definition_groups() array to avoid a second option read.
 * @return string[]
 */
function rfcc_get_unassigned_activity_type_names($groups = null) {
    if ($groups === null) {
        $groups = rfcc_get_definition_groups();
    }
    $claimed = array();
    foreach ($groups as $group) {
        if (!empty($group['activity_types']) && is_array($group['activity_types'])) {
            $claimed = array_merge($claimed, $group['activity_types']);
        }
    }
    $all_names = function_exists('rfcc_get_activity_types') ? wp_list_pluck(rfcc_get_activity_types(), 'name') : array();
    return array_values(array_diff($all_names, $claimed));
}

/**
 * Flatten one list-shaped owned dimension ('club_groups', 'climbing_profiles'
 * or 'tags') across every Definition Group into a single flat array, in
 * group order then each group's own item order. Each item gains an
 * `activity_types` field: the owning group's own `activity_types` if it's
 * tagged, or the current unassigned-type list (rfcc_get_unassigned_activity_type_names())
 * if it's untagged - never a bare `[]` (see that function's docblock for
 * why). This is what lets the legacy accessors (rfcc_get_club_groups_unsorted()
 * etc.) and the frontend filter buttons' `data-activity-types` attribute
 * keep working off one accurate, always-populated field instead of each
 * needing to special-case emptiness themselves.
 *
 * @param string $dimension_key 'club_groups', 'climbing_profiles', or 'tags'.
 * @return array
 */
function rfcc_flatten_definition_group_dimension($dimension_key) {
    $flat = array();
    $groups = rfcc_get_definition_groups();
    $unassigned_types = null; // Lazily computed only if an untagged group actually has items.
    foreach ($groups as $group) {
        $items = (isset($group[$dimension_key]) && is_array($group[$dimension_key])) ? $group[$dimension_key] : array();
        if (!empty($group['activity_types']) && is_array($group['activity_types'])) {
            $activity_types = $group['activity_types'];
        } else {
            if ($unassigned_types === null) {
                $unassigned_types = rfcc_get_unassigned_activity_type_names($groups);
            }
            $activity_types = $unassigned_types;
        }
        foreach ($items as $item) {
            if (!is_array($item)) {
                continue;
            }
            $item['activity_types'] = $activity_types;
            $flat[] = $item;
        }
    }
    return $flat;
}

/**
 * Flatten every group's single Difficulty scale into a one-scale-per-group
 * array, matching the shape rfcc_get_difficulty_scales() has always
 * returned (Difficulty is singular per group, unlike the other three
 * dimensions). Same untagged-group `activity_types` substitution as
 * rfcc_flatten_definition_group_dimension() above.
 *
 * @return array
 */
function rfcc_flatten_definition_group_difficulty_scales() {
    $flat = array();
    $groups = rfcc_get_definition_groups();
    $unassigned_types = null;
    foreach ($groups as $group) {
        if (empty($group['difficulty_scale']) || !is_array($group['difficulty_scale'])) {
            continue;
        }
        $scale = $group['difficulty_scale'];
        if (!empty($group['activity_types']) && is_array($group['activity_types'])) {
            $scale['activity_types'] = $group['activity_types'];
        } else {
            if ($unassigned_types === null) {
                $unassigned_types = rfcc_get_unassigned_activity_type_names($groups);
            }
            $scale['activity_types'] = $unassigned_types;
        }
        $flat[] = $scale;
    }
    return $flat;
}

/**
 * Effective Club Groups for an activity type: the owning group's own
 * club_groups if the type is assigned to a group (sparse = returns empty,
 * never borrows from elsewhere), otherwise the union of every UNTAGGED
 * group's club_groups for an unassigned type - a group that has itself
 * claimed specific activity types is exclusive to them and must never leak
 * into an unrelated, unassigned type's filters just because that type
 * hasn't been assigned anywhere yet. Only a group with an empty
 * activity_types (nothing claimed at all) is a true "applies everywhere"
 * fallback, mirroring the pre-Definition-Groups convention this replaces.
 *
 * @param string $activity_type_name
 * @return array
 */
function rfcc_get_effective_club_groups_for_activity_type($activity_type_name) {
    $owning_group = rfcc_get_definition_group_for_activity_type($activity_type_name);
    if ($owning_group !== null) {
        return (isset($owning_group['club_groups']) && is_array($owning_group['club_groups'])) ? $owning_group['club_groups'] : array();
    }
    $union = array();
    foreach (rfcc_get_definition_groups() as $group) {
        if (!empty($group['activity_types'])) {
            continue;
        }
        if (!empty($group['club_groups']) && is_array($group['club_groups'])) {
            $union = array_merge($union, $group['club_groups']);
        }
    }
    return $union;
}

/**
 * Effective Climbing Profiles for an activity type - same owning-group /
 * untagged-group-union rule as rfcc_get_effective_club_groups_for_activity_type().
 *
 * @param string $activity_type_name
 * @return array
 */
function rfcc_get_effective_climbing_profiles_for_activity_type($activity_type_name) {
    $owning_group = rfcc_get_definition_group_for_activity_type($activity_type_name);
    if ($owning_group !== null) {
        return (isset($owning_group['climbing_profiles']) && is_array($owning_group['climbing_profiles'])) ? $owning_group['climbing_profiles'] : array();
    }
    $union = array();
    foreach (rfcc_get_definition_groups() as $group) {
        if (!empty($group['activity_types'])) {
            continue;
        }
        if (!empty($group['climbing_profiles']) && is_array($group['climbing_profiles'])) {
            $union = array_merge($union, $group['climbing_profiles']);
        }
    }
    return $union;
}

/**
 * Effective Tags for an activity type - same owning-group / untagged-group-
 * union rule as rfcc_get_effective_club_groups_for_activity_type().
 *
 * @param string $activity_type_name
 * @return array
 */
function rfcc_get_effective_tags_for_activity_type($activity_type_name) {
    $owning_group = rfcc_get_definition_group_for_activity_type($activity_type_name);
    if ($owning_group !== null) {
        return (isset($owning_group['tags']) && is_array($owning_group['tags'])) ? $owning_group['tags'] : array();
    }
    $union = array();
    foreach (rfcc_get_definition_groups() as $group) {
        if (!empty($group['activity_types'])) {
            continue;
        }
        if (!empty($group['tags']) && is_array($group['tags'])) {
            $union = array_merge($union, $group['tags']);
        }
    }
    return $union;
}

/**
 * Effective Difficulty scale for an activity type. Difficulty is singular
 * per group, so the two branches differ in shape:
 * - assigned type: the owning group's own difficulty_scale, or null if that
 *   group hasn't configured one yet (sparse - never borrows from elsewhere).
 * - unassigned type: the union of every UNTAGGED group's difficulty_scale
 *   (see rfcc_get_effective_club_groups_for_activity_type() for why tagged
 *   groups are excluded here), as a list since more than one untagged
 *   group's scale may apply.
 *
 * @param string $activity_type_name
 * @return array|null Single scale (assigned) or array of scales (unassigned).
 */
function rfcc_get_effective_difficulty_scale_for_activity_type($activity_type_name) {
    $owning_group = rfcc_get_definition_group_for_activity_type($activity_type_name);
    if ($owning_group !== null) {
        return (!empty($owning_group['difficulty_scale']) && is_array($owning_group['difficulty_scale'])) ? $owning_group['difficulty_scale'] : null;
    }
    $union = array();
    foreach (rfcc_get_definition_groups() as $group) {
        if (!empty($group['activity_types'])) {
            continue;
        }
        if (!empty($group['difficulty_scale']) && is_array($group['difficulty_scale'])) {
            $union[] = $group['difficulty_scale'];
        }
    }
    return $union;
}

/**
 * Effective Distance/Ascent range for an activity type - each bound is,
 * in order: (1) the owning Definition Group's explicit configured value if
 * one exists, (2) otherwise this type's own auto-computed real min/max (see
 * rfcc_get_route_ranges_for_activity_type() below) if it has any published
 * routes to compute from, (3) otherwise null (= caller falls back to the
 * site-wide auto-computed range - a genuinely routeless type has nothing of
 * its own to narrow to).
 *
 * The auto-computed tier (2) is safe to fold into this one shared resolver
 * for BOTH of its consumers - the hard-exclusion filter
 * (rfcc_route_within_definition_group_hard_range(), frontend/route-group-filter.php)
 * and the slider-bounds union merge
 * (rfcc_get_effective_route_ranges_for_activity_types(), same file) - because
 * a route can never fall outside its own activity type's own computed
 * min/max by definition, so it can never turn into a NEW hard exclusion;
 * it only ever narrows the slider UX. An explicit admin hard range (tier 1)
 * genuinely CAN exclude routes and is untouched by this change.
 *
 * @param string $activity_type_name
 * @return array {distance_min, distance_max, ascent_min, ascent_max}
 */
function rfcc_get_effective_range_for_activity_type($activity_type_name) {
    $owning_group = rfcc_get_definition_group_for_activity_type($activity_type_name);

    if ($owning_group === null) {
        $explicit = array(
            'distance_min' => null,
            'distance_max' => null,
            'ascent_min'   => null,
            'ascent_max'   => null,
        );
    } else {
        $distance_range = (isset($owning_group['distance_range']) && is_array($owning_group['distance_range'])) ? $owning_group['distance_range'] : array();
        $ascent_range = (isset($owning_group['ascent_range']) && is_array($owning_group['ascent_range'])) ? $owning_group['ascent_range'] : array();
        $explicit = array(
            'distance_min' => isset($distance_range['min']) ? $distance_range['min'] : null,
            'distance_max' => isset($distance_range['max']) ? $distance_range['max'] : null,
            'ascent_min'   => isset($ascent_range['min']) ? $ascent_range['min'] : null,
            'ascent_max'   => isset($ascent_range['max']) ? $ascent_range['max'] : null,
        );
    }

    // Tier 2: auto-computed fallback, only for sides tier 1 left null.
    if (function_exists('rfcc_get_route_ranges_for_activity_type') && in_array(null, $explicit, true)) {
        $auto = rfcc_get_route_ranges_for_activity_type($activity_type_name);
        foreach ($explicit as $side => $value) {
            if ($value === null && isset($auto[$side]) && $auto[$side] !== null) {
                $explicit[$side] = $auto[$side];
            }
        }
    }

    return $explicit;
}

/**
 * Auto-computed Distance/Ascent range for one activity type's own published
 * routes - SQL MIN()/MAX(), same shape and REGEXP/DECIMAL approach as the
 * global rfcc_get_route_ranges() (frontend/route-group-filter.php), scoped
 * to one activity_type_name. Backs the tier-2 fallback in
 * rfcc_get_effective_range_for_activity_type() above and the client-side
 * `activityTypeAutoRanges` localization (frontend/route-group-filter.php,
 * frontend/rfcc-v2.php).
 *
 * Returns all-null bounds for a type with nothing to compute from (no
 * published routes, or none with a valid distance_km/ascent_m value) - the
 * caller should treat that the same as "no auto range available".
 *
 * @param string $activity_type_name
 * @return array {distance_min, distance_max, ascent_min, ascent_max} each a number or null.
 */
function rfcc_get_route_ranges_for_activity_type($activity_type_name) {
    $all = rfcc_get_route_ranges_by_activity_type();
    if (isset($all[$activity_type_name])) {
        return $all[$activity_type_name];
    }
    return array(
        'distance_min' => null,
        'distance_max' => null,
        'ascent_min'   => null,
        'ascent_max'   => null,
    );
}

/**
 * Map of every activity type name => its own auto-computed Distance/Ascent
 * range - one query for every type at once (not N per-type queries), the
 * data source behind rfcc_get_route_ranges_for_activity_type(). Cached via
 * transient 'rfcc_route_ranges_by_activity_type', invalidated on the same
 * save_post hook as the sibling site-wide range transient
 * 'rfcc_route_ranges_simple' - see rfcc_clear_simple_route_cache()
 * (frontend/route-group-filter.php).
 *
 * @return array<string,array> activity_type_name => {distance_min, distance_max, ascent_min, ascent_max}
 */
function rfcc_get_route_ranges_by_activity_type() {
    global $wpdb;

    $cache_key = 'rfcc_route_ranges_by_activity_type';
    $cached = get_transient($cache_key);
    if ($cached !== false && is_array($cached)) {
        return $cached;
    }

    // Same REGEXP + CAST...AS DECIMAL approach as rfcc_get_route_ranges()
    // (frontend/route-group-filter.php) - see that function's comment for
    // why (decimal-valued distance_km/ascent_m, e.g. "3.1", must not be
    // silently excluded or truncated).
    // The regex is passed as a parameter so its backslash reaches MySQL's
    // REGEXP intact (a literal '\\.' inside the SQL string itself would be
    // unescaped to '.' by MySQL, matching any character).
    $results = $wpdb->get_results( // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching -- aggregate query, result is cached via transient
        $wpdb->prepare(
            "SELECT
                atn.meta_value AS activity_type,
                pm.meta_key AS metric,
                MIN(CAST(pm.meta_value AS DECIMAL(10,2))) AS min_val,
                MAX(CAST(pm.meta_value AS DECIMAL(10,2))) AS max_val
            FROM {$wpdb->postmeta} pm
            INNER JOIN {$wpdb->posts} p ON pm.post_id = p.ID
            INNER JOIN {$wpdb->postmeta} atn ON atn.post_id = p.ID AND atn.meta_key = %s
            WHERE pm.meta_key IN (%s, %s)
            AND pm.meta_value REGEXP %s
            AND p.post_type = %s
            AND p.post_status = %s
            AND atn.meta_value != ''
            GROUP BY atn.meta_value, pm.meta_key",
            'activity_type_name',
            'distance_km',
            'ascent_m',
            '^[0-9]+(\\.[0-9]+)?$',
            'rfcc_route',
            'publish'
        )
    );

    $map = array();
    foreach ($results as $row) {
        $type = $row->activity_type;
        if (!isset($map[$type])) {
            $map[$type] = array(
                'distance_min' => null,
                'distance_max' => null,
                'ascent_min'   => null,
                'ascent_max'   => null,
            );
        }
        // floor()/ceil() rather than a plain (int) cast, matching
        // rfcc_get_route_ranges() - a decimal minimum must round DOWN and a
        // decimal maximum must round UP, or the narrowed floor/ceiling could
        // clip the exact route that motivated using DECIMAL in the first place.
        if ($row->metric === 'distance_km') {
            $map[$type]['distance_min'] = (int) floor((float) $row->min_val);
            $map[$type]['distance_max'] = (int) ceil((float) $row->max_val);
        } elseif ($row->metric === 'ascent_m') {
            $map[$type]['ascent_min'] = (int) floor((float) $row->min_val);
            $map[$type]['ascent_max'] = (int) ceil((float) $row->max_val);
        }
    }

    set_transient($cache_key, $map, DAY_IN_SECONDS);
    return $map;
}

/**
 * Same as rfcc_get_effective_club_groups_for_activity_type(), but just the
 * key strings - for callers doing in_array()/array_intersect() membership
 * checks (frontend/route-group-filter.php's club-groups filter, in both the
 * cached-groups and live-query paths) that need the sparse "assigned type
 * never borrows an untagged group's items" rule. Do NOT use the older
 * rfcc_get_club_group_indices_for_activity_type() (admin/routes-club-groups.php)
 * for this - it still uses the pre-Definition-Groups "empty activity_types
 * = applies everywhere" convention, which incorrectly lets an untagged
 * group's club groups leak into a type that has since been explicitly
 * assigned to its own Definition Group (confirmed live: selecting a
 * Default-group club-group key while an assigned-elsewhere activity type
 * was selected wrongly restricted that type's routes instead of being a
 * no-op).
 *
 * @param string $activity_type_name
 * @return string[]
 */
function rfcc_get_effective_club_group_keys_for_activity_type($activity_type_name) {
    return array_values(array_filter(array_column(rfcc_get_effective_club_groups_for_activity_type($activity_type_name), 'key')));
}

/**
 * Same as rfcc_get_effective_climbing_profiles_for_activity_type(), but just
 * the key strings - see rfcc_get_effective_club_group_keys_for_activity_type()
 * above for why this exists instead of using
 * rfcc_get_climbing_profile_keys_for_activity_type() (admin/routes-climbing-profiles.php)
 * for filter-membership checks.
 *
 * @param string $activity_type_name
 * @return string[]
 */
function rfcc_get_effective_climbing_profile_keys_for_activity_type($activity_type_name) {
    return array_values(array_filter(array_column(rfcc_get_effective_climbing_profiles_for_activity_type($activity_type_name), 'key')));
}

/**
 * Short random lowercase-alphanumeric identifier, in the same character-class
 * style already enforced for Climbing Profile keys (/^[a-z0-9_]+$/ elsewhere
 * in this plugin). Used by the migration to stamp a stable `key`/`id` onto
 * rows that never had one before (e.g. existing Club Groups, which were
 * identified purely by array index prior to Definition Groups).
 *
 * @param string $prefix e.g. 'grp' or 'cg'.
 * @return string
 */
function rfcc_generate_definition_group_id($prefix) {
    return $prefix . '_' . substr(md5(uniqid((string) wp_rand(), true)), 0, 6);
}

/**
 * Scaffold a new, empty Definition Group tagged to exactly one activity type -
 * so a newly-added activity type gets a ready-to-fill-in section without the
 * admin having to remember to create one themselves. Called from
 * rfcc_save_activity_types() (admin/routes-activity-types.php) for each
 * genuinely NEW type name found on save, and from the fresh-install path in
 * includes/migrations/migration-1.0.php for each default type. Deliberately
 * NOT hooked into any recurring migration/update check - re-running this on
 * every plugin update would resurrect a group the admin has since deleted.
 *
 * No-op if a group already claims this type (defensive; shouldn't happen for
 * a genuinely new type, but avoids ever creating a duplicate/conflicting claim).
 *
 * @param string $activity_type_name
 * @return void
 */
function rfcc_create_empty_definition_group_for_activity_type($activity_type_name) {
    if (empty($activity_type_name) || rfcc_get_definition_group_for_activity_type($activity_type_name) !== null) {
        return;
    }
    $groups = rfcc_get_definition_groups();
    $groups[] = array(
        'id' => rfcc_generate_definition_group_id('grp'),
        'name' => $activity_type_name,
        'activity_types' => array($activity_type_name),
        'club_groups' => array(),
        'climbing_profiles' => array(),
        'difficulty_scale' => null,
        'tags' => array(),
        'distance_range' => array('min' => null, 'max' => null),
        'ascent_range' => array('min' => null, 'max' => null),
    );
    update_option('rfcc_activity_definition_groups', $groups);
}