// Make sure the file pool directory exists.
        if (!is_dir($this->filedir)) {
            if (!mkdir($this->filedir, $this->dirpermissions, true)) {
                // Permission trouble.
                throw new file_exception('storedfilecannotcreatefiledirs');
            }
 
            // Place warning file in file pool root.
            if (!file_exists($this->filedir.'/warning.txt')) {
                file_put_contents($this->filedir.'/warning.txt',
                        'This directory contains the content of uploaded files and is controlled by Moodle code. ' .
                        'Do not manually move, change or rename any of the files and subdirectories here.');
                chmod($this->filedir . '/warning.txt', $this->filepermissions);
            }
        }
 
        // Make sure the trashdir directory exists too.
        if (!is_dir($this->trashdir)) {
            if (!mkdir($this->trashdir, $this->dirpermissions, true)) {
                // Permission trouble.
                throw new file_exception('storedfilecannotcreatefiledirs');
            }
        }
    }
 
    /**
     * Get the full path for the specified hash, including the path to the filedir.
     *
     * @param string $contenthash The content hash
     * @param bool $fetchifnotfound Whether to attempt to fetch from the remote path if not found.
     * @return string The full path to the content file
     */
    protected function get_local_path_from_hash($contenthash, $fetchifnotfound = false) {
        return $this->get_fulldir_from_hash($contenthash) . '/' .$contenthash;
    }
 
    /**
     * Get a remote filepath for the specified stored file.
     *

        $this->setup_file_system();
    }
 
    /**
     * Complete setup procedure for the file_system component.
     *
     * @return file_system
     */
    public function setup_file_system() {
        global $CFG;
        if ($this->filesystem === null) {
            require_once($CFG->libdir . '/filestorage/file_system.php');
            if (!empty($CFG->alternative_file_system_class)) {
                $class = $CFG->alternative_file_system_class;
            } else {
                // The default file_system is the filedir.
                require_once($CFG->libdir . '/filestorage/file_system_filedir.php');
                $class = file_system_filedir::class;
            }
            $this->filesystem = new $class();
        }
 
        return $this->filesystem;
    }
 
    /**
     * Return the file system instance.
     *
     * @return file_system
     */
    public function get_file_system() {
        return $this->filesystem;
    }
 
    /**
     * Calculates sha1 hash of unique full path name information.
     *
     * This hash is a unique file identifier - it is used to improve
     * performance and overcome db index size limits.
     *

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @since     Moodle 2.0
 */
class file_storage {
 
    /** @var string tempdir */
    private $tempdir;
 
    /** @var file_system filesystem */
    private $filesystem;
 
    /**
     * Constructor - do not use directly use {@link get_file_storage()} call instead.
     */
    public function __construct() {
        // The tempdir must always remain on disk, but shared between all ndoes in a cluster. Its content is not subject
        // to the file_system abstraction.
        $this->tempdir = make_temp_directory('filestorage');
 
        $this->setup_file_system();
    }
 
    /**
     * Complete setup procedure for the file_system component.
     *
     * @return file_system
     */
    public function setup_file_system() {
        global $CFG;
        if ($this->filesystem === null) {
            require_once($CFG->libdir . '/filestorage/file_system.php');
            if (!empty($CFG->alternative_file_system_class)) {
                $class = $CFG->alternative_file_system_class;
            } else {
                // The default file_system is the filedir.
                require_once($CFG->libdir . '/filestorage/file_system_filedir.php');
                $class = file_system_filedir::class;
            }
            $this->filesystem = new $class();
        }

 *
 * @return ?file_storage
 */
function get_file_storage($reset = false) {
    global $CFG;
 
    static $fs = null;
 
    if ($reset) {
        $fs = null;
        return;
    }
 
    if ($fs) {
        return $fs;
    }
 
    require_once("$CFG->libdir/filelib.php");
 
    $fs = new file_storage();
 
    return $fs;
}
 
/**
 * Returns local file storage instance
 *
 * @return file_browser
 */
function get_file_browser() {
    global $CFG;
 
    static $fb = null;
 
    if ($fb) {
        return $fb;
    }
 
    require_once("$CFG->libdir/filelib.php");
 

        return null;
    }
 
    /**
     * Return the URL of a pathway's own cover image, or null when it has none.
     *
     * The image is stored via the Moodle File API in the system context under
     * the 'pathwayimage' filearea (itemid = pathway id). Catalogue cards prefer
     * this over the derived first-course image.
     *
     * @param int $pathwayid
     * @return string|null
     */
    public static function pathway_image_url(int $pathwayid): ?string {
        if ($pathwayid <= 0) {
            return null;
        }
 
        $context = context_system::instance();
        $fs = get_file_storage();
        $files = $fs->get_area_files(
            $context->id,
            'local_lernhive_pathways',
            'pathwayimage',
            $pathwayid,
            'itemid, filepath, filename',
            false
        );
        foreach ($files as $file) {
            if ($file->is_directory()) {
                continue;
            }
            return \moodle_url::make_pluginfile_url(
                $file->get_contextid(),
                $file->get_component(),
                $file->get_filearea(),
                $file->get_itemid(),
                $file->get_filepath(),
                $file->get_filename()
            )->out(false);

 
        if (empty($pathways)) {
            return [];
        }
 
        $stepcounts = self::step_counts(array_keys($pathways));
        $steptypes = self::step_types(array_keys($pathways));
        $assignments = self::assignments_for_user(array_keys($pathways), $userid);
        $firstcourses = self::first_course_ids(array_keys($pathways));
 
        $offerings = [];
        foreach ($pathways as $pathway) {
            $pid = (int) $pathway->id;
            $offerings[] = self::pathway_to_offering(
                $pathway,
                $stepcounts[$pid] ?? 0,
                $steptypes[$pid] ?? [],
                $assignments[$pid] ?? null,
                $firstcourses[$pid] ?? null,
                pathway_service::pathway_image_url($pid)
            );
        }
 
        return $offerings;
    }
 
    /**
     * Returns available pathway catalogue facets for a user.
     */
    public static function get_facets(int $userid): array {
        if ($userid <= 0 || !self::is_ready()) {
            return [];
        }
 
        $context = context_system::instance();
        if (!has_capability('local/lernhive_pathways:viewcatalogue', $context, $userid)) {
            return [];
        }
 
        try {

            }
        );
    }
 
    /**
     * Contribute the "My programmes" section to block_lernhive_my.
     *
     * @param collect_sections $hook Dashboard collection hook.
     */
    public static function contribute_my_sections(collect_sections $hook): void {
        $hook->add_sections(my_pathways_section_provider::get_sections($hook->userid));
    }
 
    /**
     * Contribute visible pathway offerings to the central learning catalogue.
     *
     * @param collect_offerings $hook
     */
    public static function contribute_catalog_offerings(collect_offerings $hook): void {
        $hook->add_offerings(pathway_catalog_provider::get_offerings($hook->userid, $hook->filter));
    }
 
    /**
     * Contribute Pathways-owned catalogue facets.
     *
     * @param collect_facets $hook
     */
    public static function contribute_catalog_facets(collect_facets $hook): void {
        $hook->add_facets(pathway_catalog_provider::get_facets($hook->userid));
    }
 
    /**
     * Name the pathway on the login and signup page (task38).
     *
     * Only for the public catalogue detail page, and only when a logged-out
     * visitor may see that pathway there; the name never comes from the URL.
     *
     * @param resolve_offer_name $hook
     */
    public static function resolve_login_offer_name(resolve_offer_name $hook): void {

        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();
 

            return self::collect_page($userid, $filter, $sortid, $lastpage, $perpage);
        }
        return [
            'offerings' => array_slice($result['offerings'], $page * $perpage, $perpage),
            'total' => $result['total'],
            'page' => $page,
        ];
    }
 
    /**
     * Dispatch the hook, filter, sort and count.
     *
     * @param int $userid Viewer id.
     * @param search_filter $filter Filter, possibly with a window.
     * @param string $sortid Sort mode id.
     * @return array{offerings:offering_data[],total:int}
     */
    private static function collect(int $userid, search_filter $filter, string $sortid): 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];
        });
 
        // Providers that reported a full count (they applied the visibility
        // rules themselves) count with it; every other provider with what
        // survived the filters above.
        $totals = $hook->get_totals();
        $total = array_sum($totals);
        foreach ($offerings as $offering) {
            if (!array_key_exists($offering->sourcecomponent, $totals)) {
                $total++;
            }
        }

     * Merging the sorted heads of every provider yields the same first
     * `($page + 1) * $perpage` offerings as sorting everything.
     *
     * @param int $userid Viewer id, 0 for the public catalogue.
     * @param search_filter $filter Resolved filter values.
     * @param string $sortid Sort mode id.
     * @param int $page Zero-based page.
     * @param int $perpage Offerings per page.
     * @return array{offerings:offering_data[],total:int,page:int} The page (clamped to the last one) and the total.
     */
    public static function collect_page(
        int $userid,
        search_filter $filter,
        string $sortid,
        int $page,
        int $perpage
    ): array {
        $perpage = max(1, $perpage);
        $page = max(0, $page);
        $result = self::collect($userid, $filter->with_window($sortid, ($page + 1) * $perpage), $sortid);
        $lastpage = max(0, (int) ceil($result['total'] / $perpage) - 1);
        if ($page > $lastpage) {
            // A stale deep link past the end shows the last page instead of nothing.
            return self::collect_page($userid, $filter, $sortid, $lastpage, $perpage);
        }
        return [
            'offerings' => array_slice($result['offerings'], $page * $perpage, $perpage),
            'total' => $result['total'],
            'page' => $page,
        ];
    }
 
    /**
     * Dispatch the hook, filter, sort and count.
     *
     * @param int $userid Viewer id.
     * @param search_filter $filter Filter, possibly with a window.
     * @param string $sortid Sort mode id.
     * @return array{offerings:offering_data[],total:int}
     */

            ? 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');
        // Real paging over the whole result (task36): providers build cards
        // only for the window, the counts come from their full match counts.
        // A host without paging shows the first page.
        $result = catalog_registry::collect_page($this->userid, $this->filter, $sortid, $this->page ?? 0, self::PER_PAGE);
        $offerings = $result['offerings'];
        $matchcount = $result['total'];
        $totalcount = catalog_registry::collect_page($this->userid, new search_filter(), $sortid, 0, 1)['total'];
        $pagingbar = '';
        if ($this->page !== null && $matchcount > self::PER_PAGE) {
            $pagingbar = $output->render(new \paging_bar(
                $matchcount,
                $result['page'],
                self::PER_PAGE,
                $this->url($this->rawparams)
            ));
        }
        $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) {

 
// 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, null, $dateerror);
    echo $OUTPUT->render_from_template(
        'local_lernhive/catalog_page',
        $renderable->export_for_template($OUTPUT)
    );
} else {
    $renderable = new catalog_page($userid, $filter, $rawparams, null, null, $dateerror, $page);
    echo $OUTPUT->render_from_template(
        'local_lernhive/catalog_page',
        $renderable->export_for_template($OUTPUT)
    );
}
 
echo html_writer::end_div();
echo $OUTPUT->footer();