timecreated: !empty($course->timecreated) ? (int) $course->timecreated : null,
            availability: $requiresapproval
                ? offering_data::AVAILABILITY_ON_REQUEST
                : offering_data::AVAILABILITY_BOOKABLE,
            score: !empty($markings['featured']) ? 40 : 10,
            metaitems: $meta,
            capacitystatus: $capacitystatus,
            capacitylabel: $capacitylabel,
            capacityfill: $capacityfill,
            capacityisprogress: $isenrolled,
            showcapacitybar: $isenrolled,
            trainers: self::trainers_data($context),
            bookmarkable: $userid > 0,
            bookmarkcomponent: 'core_course',
            bookmarkitemtype: 'course',
            bookmarkitemid: (string) $course->id,
            flags: $flags,
            featured: !empty($markings['featured']),
            ispublic: !empty($markings['publicvisible']),
            ratingaverage: $rating && $rating->count > 0 ? (float) $rating->aggregate : null,
            ratingcount: $rating ? (int) $rating->count : 0,
        );
    }
 
    /**
     * Build image-overlay flags (recommended / mandatory / paid+price) from a
     * course's markings.
     *
     * @param array{recommended:bool,mandatory:bool,paid:bool,price:string} $markings
     * @param bool $needsapproval
     * @return array<int,array{label:string,tone:string,icon:string}>
     */
    private static function flags_from_markings(array $markings, bool $needsapproval = false): array {
        $flags = [];
        if (!empty($markings['mandatory'])) {
            $flags[] = [
                'label' => get_string('flag_mandatory', 'local_lernhive'),
                'tone' => 'mandatory',
                'icon' => 'fa-exclamation',
            ];

                continue;
            }
            // Date-range facet ("Termine von/bis"): a date window asks for
            // offerings *happening* inside it, so undated courses drop out
            // while the filter is active.
            if ($filter->from !== null || $filter->to !== null) {
                $startdate = (int) ($course->startdate ?? 0);
                if (
                    $startdate <= 0
                    || ($filter->from !== null && $startdate < $filter->from)
                    || ($filter->to !== null && $startdate > $filter->to)
                ) {
                    continue;
                }
            }
            if (!self::matches_access($course, $filter, $context, $userid)) {
                continue;
            }
 
            $offerings[] = self::course_to_offering($course, $context, $userid, $markings);
            if (count($offerings) >= self::RESULT_LIMIT) {
                break;
            }
        }
 
        return $offerings;
    }
 
    /**
     * Return course-specific catalogue facets.
     *
     * @param int $userid Viewer identifier.
     * @return facet[] Available facets.
     */
    public static function get_facets(int $userid): array {
        $facets = [
            new facet(
                id: 'catalog_focus',
                label: get_string('catalog_filter_group_focus', 'local_lernhive'),
                type: facet::TYPE_TOGGLE,

            return;
        }
        if (($PAGE->theme->name ?? '') !== 'lernhive') {
            return;
        }
        if (!level_manager::get_level_record($USER->id)) {
            return;
        }
 
        $scope = level_manager::get_level($USER->id) <= 1 ? 'explorer' : 'lernhive';
        $hook->add_attribute('data-lh-ui', $scope);
    }
 
    /**
     * Contribute ordinary Moodle courses to the central LernHive catalogue.
     *
     * @param collect_offerings $hook
     */
    public static function contribute_course_catalog_offerings(collect_offerings $hook): void {
        $hook->add_offerings(course_catalog_provider::get_offerings($hook->userid, $hook->filter));
    }
 
    /**
     * Contribute core catalogue facets.
     *
     * @param collect_facets $hook
     */
    public static function contribute_course_catalog_facets(collect_facets $hook): void {
        $hook->add_facets(course_catalog_provider::get_facets($hook->userid));
    }
 
    /**
     * Register core catalogue sort options.
     *
     * @param collect_sort_options $hook Sort-option collection hook.
     */
    public static function contribute_course_catalog_sort_options(collect_sort_options $hook): void {
        // Core owns the built-in modes. Feature plugins may register more modes.
    }
 

        if (empty($callbacks)) {
            // Nothing is interested in this hook.
            return $event;
        }
 
        foreach ($callbacks as $callback) {
            // Note: PSR-14 states:
            // If passed a Stoppable Event, a Dispatcher
            // MUST call isPropagationStopped() on the Event before each Listener has been called.
            // If that method returns true it MUST return the Event to the Emitter immediately and
            // MUST NOT call any further Listeners. This implies that if an Event is passed to the
            // Dispatcher that always returns true from isPropagationStopped(), zero listeners will be called.
            // Ergo, we check for a stopped event before calling each listener, not afterwards.
            if ($event instanceof StoppableEventInterface) {
                if ($event->isPropagationStopped()) {
                    return $event;
                }
            }
 
            call_user_func($callback, $event);
        }
 
        // Developers need to be careful to not create infinite loops in hook callbacks.
        return $event;
    }
 
    /**
     * Initialise list of all callbacks for each hook.
     */
    private function init_standard_callbacks(): void {
        global $CFG;
 
        $this->allcallbacks = [];
        $this->alldeprecations = [];
 
        // @codeCoverageIgnoreStart
        $shouldcache = $this->should_cache();
        if ($shouldcache) {
            $cache = $this->get_cache();
 

        if (empty($callbacks)) {
            // Nothing is interested in this hook.
            return $event;
        }
 
        foreach ($callbacks as $callback) {
            // Note: PSR-14 states:
            // If passed a Stoppable Event, a Dispatcher
            // MUST call isPropagationStopped() on the Event before each Listener has been called.
            // If that method returns true it MUST return the Event to the Emitter immediately and
            // MUST NOT call any further Listeners. This implies that if an Event is passed to the
            // Dispatcher that always returns true from isPropagationStopped(), zero listeners will be called.
            // Ergo, we check for a stopped event before calling each listener, not afterwards.
            if ($event instanceof StoppableEventInterface) {
                if ($event->isPropagationStopped()) {
                    return $event;
                }
            }
 
            call_user_func($callback, $event);
        }
 
        // Developers need to be careful to not create infinite loops in hook callbacks.
        return $event;
    }
 
    /**
     * Initialise list of all callbacks for each hook.
     */
    private function init_standard_callbacks(): void {
        global $CFG;
 
        $this->allcallbacks = [];
        $this->alldeprecations = [];
 
        // @codeCoverageIgnoreStart
        $shouldcache = $this->should_cache();
        if ($shouldcache) {
            $cache = $this->get_cache();
 

 * @package    local_lernhive
 * @copyright  2026 LernHive.de
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class catalog_registry {
    /**
     * Collect offerings for a user under the given filter.
     *
     * Sort order: relevance score descending, then start timestamp ascending
     * (offerings without a start date land last among same-score items), then
     * source-component for deterministic ordering.
     *
     * @param int $userid User id to render for; 0 renders the public
     *        (anonymous) catalogue and keeps only opted-in public offerings.
     * @param search_filter $filter Resolved filter values.
     * @return offering_data[] Sorted as documented above.
     */
    public static function collect_offerings(int $userid, search_filter $filter, string $sortid = 'relevance'): array {
        $hook = new collect_offerings($userid, $filter);
        di::get(hook_manager::class)->dispatch($hook);
 
        $offerings = $hook->get_offerings();
        $offerings = self::apply_visibility_filters($userid, $offerings, $filter);
 
        $option = self::sort_option($userid, $sortid);
        usort($offerings, static function (offering_data $a, offering_data $b) use ($option): int {
            $result = $option->compare($a, $b);
            return $result !== 0 ? $result : [$a->sourcecomponent, $a->id] <=> [$b->sourcecomponent, $b->id];
        });
 
        return $offerings;
    }
 
    /**
     * Collect built-in and provider-declared sort modes.
     *
     * @return sort_option[]
     */
    public static function collect_sort_options(int $userid): array {
        $hook = new collect_sort_options($userid);

     */
    private function url(array $params = []): \moodle_url {
        $url = $this->baseurl
            ? new \moodle_url($this->baseurl)
            : new \moodle_url('/local/lernhive/catalog.php');
        foreach ($params as $name => $value) {
            $url->param($name, $value);
        }
        return $url;
    }
 
    /**
     * Export the catalogue template context.
     *
     * @param \renderer_base $output Renderer instance.
     * @return array<string,mixed> Template context.
     */
    public function export_for_template(\renderer_base $output): array {
        $sortid = (string) ($this->rawparams['sort'] ?? 'relevance');
        $offerings = catalog_registry::collect_offerings($this->userid, $this->filter, $sortid);
        $sortoptions = catalog_registry::collect_sort_options($this->userid);
        $selectedsort = catalog_registry::sort_option($this->userid, $sortid);
 
        // Preserve any non-search params (e.g. format=, category=) across the
        // search-submit so a click on the search button does not silently drop
        // an active tag-driven filter.
        $extras = [];
        foreach ($this->rawparams as $name => $value) {
            // Skip params that render as their own visible form fields.
            if (in_array($name, ['q', 'datefrom', 'dateto', 'sort'], true) || !is_string($value) || $value === '') {
                continue;
            }
            $extras[] = ['name' => $name, 'value' => $value];
        }
        // A GET form drops the query string of its action, so any param the
        // hosting page needs for itself (e.g. index.php's `redirect=0`) has to
        // ride along as a hidden field or the search submit would lose it.
        if ($this->baseurl) {
            foreach ($this->baseurl->params() as $name => $value) {
                if (array_key_exists($name, $this->rawparams) || $value === '') {

 
// View switcher (cards | month) — shared with the full-view catalogue block,
// see `catalog_view`.
$togglebase = new moodle_url('/local/lernhive/catalog.php', $rawparams);
echo catalog_view::view_toggle($togglebase, $view);
 
if ($view === catalog_view::VIEW_MONTH) {
    $monthhtml = catalog_view::month_html(
        $OUTPUT,
        $PAGE,
        $togglebase,
        $filter,
        $rawparams,
        $calendartime,
        (int) ($rawparams['expand'] ?? 0)
    );
    $renderable = new catalog_page($userid, $filter, $rawparams, $monthhtml);
    echo $OUTPUT->render_from_template(
        'local_lernhive/catalog_page',
        $renderable->export_for_template($OUTPUT)
    );
} else {
    $renderable = new catalog_page($userid, $filter, $rawparams);
    echo $OUTPUT->render_from_template(
        'local_lernhive/catalog_page',
        $renderable->export_for_template($OUTPUT)
    );
}
 
echo html_writer::end_div();
echo $OUTPUT->footer();