<?php
namespace DayTidy;

use Webilia\WP\Helpers\Arr;
use Webilia\WP\Helpers\Str;
use Webilia\WP\Interfaces\Initiable;
use DayTidy\Plugin\Profile;
use DayTidy\Admin\Screens;
use DayTidy\Plugin\Engagement;
use Webilia\UI\WordPress\Assets as UIAssets;
use DayTidy\Posts\Booking as BookingPost;
use Closure;
use Webilia\UI\Notice;
use DayTidy\Posts\Offering;
use DayTidy\DisplayViews\Config as ViewConfig;
use DayTidy\SingleOffering\PageResolver;
use DayTidy\SingleOffering\Config as SingleConfig;
use WP_Post;
use WP_Scripts;
use WP_Styles;

class Assets implements Initiable
{
    protected Profile $profile;

    /**
     * @var array<string, mixed[]>
     * @static
     */
    protected static array $params = [];

    /** @var array<string, bool> */
    private static array $frontendProfiles = [];

    /** @var string[] */
    private static array $frontendScripts = [];

    /** @var string[] */
    private static array $frontendStyles = [];

    private static bool $frontendMedia = false;

    /**
     * Constructor
     */
    public function __construct()
    {
        // Plugin Profile
        $this->profile = Profile::getInstance();
    }

    public function init(): void
    {
        // Include needed assets (CSS, JavaScript etc.) in the WordPress backend
        add_action('admin_enqueue_scripts', [$this, 'backend'], 0);

        // Include needed assets (CSS, JavaScript etc.) in the WordPress frontend
        add_action('wp_enqueue_scripts', [$this, 'frontend'], 0);
        add_action('wp_enqueue_scripts', [$this, 'adminBar'], 1);
        add_action('wp_footer', [$this, 'lateFrontendAssets'], 19);
        add_action('wp_footer', [$this, 'lateFrontendAssets'], 10000);
        add_filter('script_loader_tag', [$this, 'scriptAttributes'], 10, 2);

        // Register DayTidy function to be called in WordPress footer hook
        if (is_admin()) add_action('admin_footer', [$this, 'loadFooter'], 9999);
        else add_action('wp_footer', [$this, 'loadFooter'], 9999);
    }

    public function frontend(): void
    {
        if (!$this->allowed()) return;

        self::enqueueFrontend($this->detectedProfiles() ?: ['base']);
    }

    /**
     * Renderers and programmatic integrations declare their actual requirements.
     * An explicit filter override can still opt out of product frontend assets.
     *
     * @param string[] $profiles
     */
    public static function enqueueFrontend(array $profiles): void
    {
        if (is_admin() && !wp_doing_ajax()) return;
        if (!apply_filters('DayTidy/F__DayTidy/Assets__allowed/frontend', true)) return;

        $assets = new self();
        $definitions = [
            'base' => ['layout', 'surfaces', 'buttons', 'icons'],
            'booking' => ['forms', 'modal', 'notice-dismiss', 'busy', 'badge'],
            'payment' => ['forms', 'notice-dismiss', 'busy'],
            'portal' => ['forms', 'notice-dismiss', 'busy', 'badge'],
            'views' => ['notice-dismiss', 'busy', 'badge'],
            'calendar' => ['notice-dismiss', 'busy'],
            'single-offering' => ['badge'],
            'dashboard-manage' => ['forms', 'notice-dismiss', 'busy', 'badge'],
            'dashboard-editor' => ['forms', 'modal', 'notice-dismiss', 'busy', 'badge'],
            'dashboard-resources' => ['forms', 'modal', 'notice-dismiss', 'busy', 'badge'],
        ];
        $profiles = array_values(array_unique(array_merge(['base'], $profiles)));
        foreach ($profiles as $profile)
        {
            if (!isset($definitions[$profile]) || isset(self::$frontendProfiles[$profile])) continue;
            self::$frontendProfiles[$profile] = true;
            $scripts = wp_scripts()->queue;
            $styles = wp_styles()->queue;
            UIAssets::enqueue($definitions[$profile], Engagement::uiUrl());
            self::theme();
            $assets->icons();
            if ($profile === 'dashboard-editor') $assets->colorpicker();

            wp_enqueue_script('daytidy-frontend', self::url('dist/js/frontend.min.js'), ['jquery'], $assets->version(), true);
            wp_enqueue_style('daytidy-frontend', self::url('dist/css/frontend.css'), ['daytidy-ui'], $assets->version());
            if ($profile === 'base')
            {
                $assets->localize();
                do_action('DayTidy/A__DayTidy/Assets__frontend/assets');
            }
            else if ($profile !== 'single-offering')
            {
                $entry = 'frontend-' . $profile;
                $dependencies = ['daytidy-frontend', 'webilia-ui-v1-notice', 'webilia-ui-v1-busy'];
                if ($profile === 'dashboard-editor') $dependencies[] = 'wp-color-picker';
                if (in_array($profile, ['booking', 'dashboard-editor', 'dashboard-resources'], true))
                {
                    $dependencies[] = 'webilia-ui-v1-modal';
                    wp_enqueue_script('daytidy-frontend-forms', self::url('dist/js/frontend-forms.min.js'), ['daytidy-frontend', 'webilia-ui-v1-busy', 'webilia-ui-v1-modal', 'webilia-ui-v1-notice'], $assets->version(), true);
                    wp_enqueue_style('daytidy-frontend-forms', self::url('dist/css/frontend-forms.css'), ['daytidy-frontend', 'webilia-ui-v1-forms'], $assets->version());
                    $dependencies[] = 'daytidy-frontend-forms';
                }

                // The resource screen shares the editor entrypoint for its modal validation.
                if ($profile === 'dashboard-resources') $entry = 'frontend-dashboard-editor';
                wp_enqueue_script('daytidy-' . $entry, self::url('dist/js/' . $entry . '.min.js'), $dependencies, $assets->version(), true);
            }

            if (in_array($profile, ['booking', 'portal', 'views', 'calendar', 'single-offering', 'dashboard-manage', 'dashboard-editor', 'dashboard-resources'], true))
            {
                $style_profiles = ['calendar' => 'views', 'dashboard-resources' => 'dashboard-editor'];
                $style = $style_profiles[$profile] ?? $profile;
                wp_enqueue_style('daytidy-frontend-' . $style, self::url('dist/css/frontend-' . $style . '.css'), ['daytidy-frontend'], $assets->version());
            }

            if (in_array($profile, ['dashboard-editor', 'dashboard-resources'], true)) $assets->media();
            if ($profile === 'dashboard-editor')
            {
                $assets->editor();
                $assets->fontawesome();
            }

            self::$frontendScripts = array_values(array_unique(array_merge(self::$frontendScripts, array_diff(wp_scripts()->queue, $scripts), ['daytidy-frontend'])));
            self::$frontendStyles = array_values(array_unique(array_merge(self::$frontendStyles, array_diff(wp_styles()->queue, $styles), ['daytidy-frontend'])));
        }
    }

    /**
     * AJAX fragments carry the registered dependency graph, including WordPress
     * localization/inline configuration. No script tags are embedded in form HTML.
     *
     * @return array<string, mixed>
     */
    public static function frontendManifest(): array
    {
        if (!self::$frontendProfiles) return [];
        self::captureFrontendAssets();
        $manifest = [
            'styles' => self::dependencyManifest(wp_styles(), self::$frontendStyles),
            'scripts' => self::dependencyManifest(wp_scripts(), self::$frontendScripts),
        ];
        if (self::$frontendMedia)
        {
            // AJAX has no footer in which WordPress can print its inert media
            // templates. Carry them alongside the dependency graph for mounting.
            ob_start();
            wp_print_media_templates();
            $manifest['media_templates'] = (string) ob_get_clean();
        }

        return $manifest;
    }

    /** Keep extension-owned enqueues in the AJAX graph, regardless of handle prefix. */
    public static function captureFrontendEnqueues(callable $enqueue): void
    {
        $scripts = wp_scripts()->queue;
        $styles = wp_styles()->queue;
        $enqueue();
        if (!self::$frontendProfiles) return;
        self::$frontendScripts = array_values(array_unique(array_merge(self::$frontendScripts, array_diff(wp_scripts()->queue, $scripts))));
        self::$frontendStyles = array_values(array_unique(array_merge(self::$frontendStyles, array_diff(wp_styles()->queue, $styles))));
    }

    /**
     * @param WP_Scripts|WP_Styles $registry
     * @param string[] $handles
     * @return array<int, array<string, mixed>>
     */
    private static function dependencyManifest($registry, array $handles): array
    {
        $items = [];
        $visited = [];
        $collect = static function (string $handle) use (&$collect, &$items, &$visited, $registry): void
        {
            if (isset($visited[$handle]) || !isset($registry->registered[$handle])) return;
            $visited[$handle] = true;
            $asset = $registry->registered[$handle];
            foreach ($asset->deps as $dependency) $collect($dependency);
            $src = $asset->src;
            if ($src && !preg_match('#^(https?:)?//#', $src)) $src = $registry->base_url . $src;
            $version = $asset->ver === false ? $registry->default_version : $asset->ver;
            if ($src && $version !== null) $src = add_query_arg('ver', $version, $src);
            $item = ['handle' => $handle, 'src' => $src ?: '', 'deps' => $asset->deps];
            if ($registry instanceof WP_Scripts)
            {
                $translations = $registry->print_translations($handle, false);
                $item['before'] = array_merge(isset($asset->extra['data']) ? [$asset->extra['data']] : [], $translations ? [$translations] : [], (array) ($asset->extra['before'] ?? []));
                $item['after'] = (array) ($asset->extra['after'] ?? []);
                $item['attributes'] = (array) ($asset->extra['daytidy_attributes'] ?? []);
            }
            else $item['media'] = $asset->args ?: 'all';
            $items[] = $item;
        };
        foreach ($handles as $handle) $collect($handle);
        return $items;
    }

    private static function captureFrontendAssets(): void
    {
        foreach (wp_scripts()->queue as $handle)
        {
            if (strpos($handle, 'daytidy-') === 0 || strpos($handle, 'daytidy-paypal-') === 0 || in_array($handle, ['stripe', 'wp-color-picker', 'editor', 'quicktags', 'wp-tinymce'], true)) self::$frontendScripts[] = $handle;
        }

        foreach (wp_styles()->queue as $handle)
        {
            if (strpos($handle, 'daytidy-') === 0 || in_array($handle, ['wp-color-picker', 'media-views', 'editor-buttons', 'dashicons'], true)) self::$frontendStyles[] = $handle;
        }

        self::$frontendScripts = array_values(array_unique(self::$frontendScripts));
        self::$frontendStyles = array_values(array_unique(self::$frontendStyles));
    }

    public function lateFrontendAssets(): void
    {
        if (!self::$frontendProfiles) return;
        // wp_head may already have printed the initial styles. WP handles prevent
        // duplicate output while dependencies added by late renderers still print.
        self::captureFrontendAssets();
        wp_print_styles(self::$frontendStyles);
        if (did_action('wp_print_footer_scripts')) wp_scripts()->do_items(self::$frontendScripts, 1);
    }

    /** @return string[] */
    private function detectedProfiles(): array
    {
        $profiles = [];
        if (is_singular(Offering::PT) && Modules::enabled(SingleConfig::MODULE)
            && (new PageResolver())->isGenerated((int) get_queried_object_id())) $profiles[] = 'single-offering';
        $query = $GLOBALS['wp_query'] ?? null;
        foreach (($query->posts ?? []) as $post)
        {
            if ($post instanceof WP_Post && !post_password_required($post))
            {
                $profiles = array_merge($profiles, $this->contentProfiles($post->post_content));
            }
        }

        return array_values(array_unique($profiles));
    }

    /**
     * Parse only; never render shortcode/block callbacks during early detection.
     * Referenced synced blocks use a visited set to prevent cyclic traversal.
     *
     * @param int[] $visited
     * @return string[]
     */
    private function contentProfiles(string $content, array $visited = []): array
    {
        $profiles = [];
        global $shortcode_tags;
        $tags = array_values(array_filter(array_keys($shortcode_tags), static function (string $tag): bool
        {
            return $tag === 'daytidy' || strpos($tag, 'daytidy-') === 0;
        }));
        if (!$tags) return [];
        preg_match_all('/' . get_shortcode_regex($tags) . '/s', $content, $matches, PREG_SET_ORDER);
        foreach ($matches as $match)
        {
            if ($match[1] === '[' && $match[6] === ']') continue;
            if (!shortcode_exists($match[2])) continue;
            if ($match[2] === 'daytidy-customer-portal') $profiles[] = 'portal';
            else if ($match[2] === 'daytidy-dashboard')
            {
                $mode = filter_input(INPUT_GET, 'mode', FILTER_UNSAFE_RAW);
                $modes = ['editor' => 'dashboard-editor', 'resources' => 'dashboard-resources'];
                $profiles[] = $modes[$mode] ?? 'dashboard-manage';
            }
            else if (in_array($match[2], ['daytidy-booking', 'daytidy-seg-booking'], true)) $profiles[] = 'booking';
            else if ($match[2] !== 'daytidy') $profiles[] = 'single-offering';
            else
            {
                $atts = shortcode_parse_atts($match[3]);
                $id = is_array($atts) ? absint($atts['id'] ?? 0) : 0;
                if ($id && get_post_status($id) === 'publish' && get_post_type($id) === 'daytidy-view')
                {
                    $config = ViewConfig::get($id);
                    $profiles[] = $config['type'] === 'full_calendar' ? 'calendar' : 'views';
                }
            }
        }

        $blocks = parse_blocks($content);
        $walk = function (array $blocks) use (&$walk, &$profiles, $visited): void
        {
            foreach ($blocks as $block)
            {
                $ref = absint($block['attrs']['ref'] ?? 0);
                if ($block['blockName'] === 'core/block' && $ref && !in_array($ref, $visited, true))
                {
                    $post = get_post($ref);
                    if ($post instanceof WP_Post) $profiles = array_merge($profiles, $this->contentProfiles($post->post_content, array_merge($visited, [$ref])));
                }

                if (!empty($block['innerBlocks'])) $walk($block['innerBlocks']);
            }
        };
        $walk($blocks);
        return $profiles;
    }

    public function scriptAttributes(string $tag, string $handle): string
    {
        $attributes = wp_scripts()->get_data($handle, 'daytidy_attributes');
        if (!is_array($attributes)) return $tag;
        foreach ($attributes as $name => $value)
        {
            if (strpos($name, 'data-') !== 0) continue;
            $tag = str_replace('<script ', '<script ' . esc_attr($name) . '="' . esc_attr($value) . '" ', $tag);
        }

        return $tag;
    }

    public function adminBar(): void
    {
        if ($this->allowed() || !is_admin_bar_showing()) return;
        if (!current_user_can(Capabilities::ACCESS_ADMIN) && !Capabilities::canAccessFrontendDashboard()) return;

        wp_enqueue_style('daytidy-admin-bar', $this->url('dist/css/admin-bar.css'), [], $this->version());
        self::tokens();
    }

    public function backend(): void
    {
        $screen = get_current_screen();
        $is_daytidy_screen = $this->allowed('backend');

        // Taxonomy metabox adjustments can add inline rules to this handle.
        if ($is_daytidy_screen) wp_enqueue_style('daytidy-wp-backend', $this->url('dist/css/wp-backend.css'), ['daytidy-backend', 'daytidy-ui'], $this->version());

        if (!$is_daytidy_screen) return;

        $customization_screen = isset($_GET['page'], $_GET['tab'])
            && is_string($_GET['page']) && is_string($_GET['tab'])
            && sanitize_key(wp_unslash($_GET['page'])) === 'daytidy-settings'
            && sanitize_key(wp_unslash($_GET['tab'])) === 'customization';
        if ($customization_screen) $this->colorpicker();

        $components = Screens::components();
        UIAssets::enqueue($components, Engagement::uiUrl());
        self::theme();

        // Include DayTidy backend script file
        $dependencies = ['jquery', 'jquery-ui-sortable', 'webilia-ui-v1-busy', 'webilia-ui-v1-modal', 'webilia-ui-v1-notice'];
        if ($customization_screen) $dependencies[] = 'wp-color-picker';
        if (in_array('toast', $components, true)) $dependencies[] = 'webilia-ui-v1-toast';
        wp_enqueue_script('daytidy-backend', $this->url('dist/js/backend.min.js'), $dependencies, $this->version(), true);

        // Include the heavy bookings calendar script only where that UI can render.
        $this->bookingsBackend();

        // Include DayTidy backend CSS file
        wp_enqueue_style('daytidy-backend', $this->url('dist/css/backend.css'), ['daytidy-ui'], $this->version());

        // Localized Data
        $this->localize();

        // Fontawesome
        $this->fontawesome();

        // Shared UI icons
        $this->icons();

        // Include Add-on Assets
        do_action('DayTidy/A__DayTidy/Assets__backend/assets');
    }

    private function bookingsBackend(): void
    {
        $screen = get_current_screen();
        if (!$screen || $screen->base !== 'edit' || $screen->post_type !== BookingPost::PT) return;
        if (class_exists('\DayTidy\Modules\Booking\Core\Admin\BookingsOperationsPage')
            && \DayTidy\Modules\Booking\Core\Admin\BookingsOperationsPage::isFilteredListRequest()
        ) return;
        if (!apply_filters('DayTidy/F__DayTidy/Assets__bookings_backend/enabled', false, $screen)) return;

        wp_enqueue_script('daytidy-backend-bookings', $this->url('dist/js/backend-bookings.min.js'), ['daytidy-backend'], $this->version(), true);
    }

    public function editor(): void
    {
        // Dependency
        $dependency = ['daytidy-backend', 'jquery-ui-sortable'];

        // Frontend Dependency
        if (!is_admin() || wp_doing_ajax()) $dependency = ['daytidy-frontend', 'jquery-ui-sortable'];

        // Include DayTidy frontend script file
        wp_enqueue_script('daytidy-editor', $this->url('dist/js/editor.min.js'), $dependency, $this->version(), true);

        // Include Add-on Assets
        do_action('DayTidy/A__DayTidy/Assets__editor/assets');
    }

    /**
     * Include DayTidy localize data
     * @return void
     */
    public function localize(): void
    {
        // JS Handle
        $handle = is_admin() && !wp_doing_ajax() ? 'daytidy-backend' : 'daytidy-frontend';

        wp_localize_script($handle, 'daytidy', [
            'ajaxurl' => admin_url('admin-ajax.php'),
            'js_date_format' => 'YYYY/MM/DD',
            'js_datetime_format' => 'YYYY/MM/DD HH:mm',
            'admin_classes' => [
                'accordion' => Html::get_daytidy_class('accordion', 'admin'),
                'accordion-header' => Html::get_daytidy_class('accordion-header', 'admin'),
                'checkbox-switcher' => Html::get_daytidy_class('checkbox-switcher', 'admin'),
                'description--sm-relaxed' => Html::get_daytidy_class('description--sm-relaxed', 'admin'),
                'fields' => Html::get_daytidy_class('fields', 'admin'),
                'fields-label' => Html::get_daytidy_class('fields-label', 'admin'),
                'switch' => Html::get_daytidy_class('switch', 'admin'),
                'title' => Html::get_daytidy_class('title', 'admin'),
                'title--lg' => Html::get_daytidy_class('title--lg', 'admin'),
            ],
            'fe_classes' => [
                'accordion' => Html::get_daytidy_class('accordion', 'fe'),
                'accordion-header' => Html::get_daytidy_class('accordion-header', 'fe'),
                'checkbox-switcher' => Html::get_daytidy_class('checkbox-switcher', 'fe'),
                'description--sm-relaxed' => Html::get_daytidy_class('description--sm-relaxed', 'fe'),
                'description--xs' => Html::get_daytidy_class('description--xs', 'fe'),
                'fields' => Html::get_daytidy_class('fields', 'fe'),
                'fields-label' => Html::get_daytidy_class('fields-label', 'fe'),
                'switch' => Html::get_daytidy_class('switch', 'fe'),
                'title' => Html::get_daytidy_class('title', 'fe'),
                'title--lg' => Html::get_daytidy_class('title--lg', 'fe'),
            ],
            'i18n' => [
                'dismiss_toast' => __('Dismiss notification', 'daytidy'),
                'loading' => __('Loading...', 'daytidy'),
                'search_offerings' => __('Search offerings...', 'daytidy'),
            ],
            'notices' => array_map(static function (string $tone): string
            {
                return Notice::render(['tone' => $tone, 'message_html' => '', 'dismissible' => true, 'dismiss_label' => esc_html__('Dismiss notice', 'daytidy')]);
            }, array_combine(['info', 'success', 'warning', 'danger'], ['info', 'success', 'warning', 'danger'])),
        ]);
    }

    /**
     * Include fontawesome file
     *
     * @return void
     */
    public function fontawesome(): void
    {
        // Include Fontawesome CSS file
        wp_enqueue_style('daytidy-fontawesome', $this->url('packages/fontawesome/css/fontawesome.min.css'), [], $this->version());
    }

    public function icons(): void
    {
        UIAssets::enqueue(['icons'], Engagement::uiUrl());
        wp_enqueue_style('daytidy-icon-scope', $this->url('dist/css/icon-scope.css'), ['webilia-ui-v1-icons'], $this->profile->version());
    }

    public static function tokens(): void
    {
        if (wp_style_is('daytidy-tokens', 'enqueued')) return;

        $profile = Profile::getInstance();
        wp_enqueue_style('daytidy-tokens', $profile->url() . '/assets/dist/css/tokens.css', [], (new self())->version());
        if (!is_admin() || wp_doing_ajax())
        {
            $color = Config::general()->primaryColorOverride();
            if ($color !== '') wp_add_inline_style('daytidy-tokens', ':root { --daytidy-primary-color: ' . $color . '; }');
        }
    }

    public static function theme(): void
    {
        self::tokens();
        $profile = Profile::getInstance();
        wp_enqueue_style('daytidy-ui', $profile->url() . '/assets/dist/css/shared-ui.css', ['daytidy-tokens', 'webilia-ui-v1-tokens'], (new self())->version());
    }

    public function colorpicker(): void
    {
        // WordPress registers these handles only for admin requests.
        if (!wp_script_is('iris', 'registered'))
        {
            wp_register_script('iris', admin_url('js/iris.min.js'), ['jquery-ui-draggable', 'jquery-ui-slider', 'jquery-touch-punch'], '1.1.1', true);
        }

        if (!wp_script_is('wp-color-picker', 'registered'))
        {
            $suffix = SCRIPT_DEBUG ? '' : '.min';
            wp_register_script('wp-color-picker', admin_url('js/color-picker' . $suffix . '.js'), ['iris'], false, true);
            wp_set_script_translations('wp-color-picker');
        }

        if (!wp_style_is('wp-color-picker', 'registered'))
        {
            $suffix = SCRIPT_DEBUG ? '' : '.min';
            wp_register_style('wp-color-picker', admin_url('css/color-picker' . $suffix . '.css'));
        }

        // Include WordPress color picker JavaScript file
        wp_enqueue_script('wp-color-picker');

        // Include WordPress color picker CSS file
        wp_enqueue_style('wp-color-picker');
    }

    public function datepicker(): void
    {
        // Use WordPress core's registered Moment dependency.
        wp_enqueue_script('moment');

        // Include date range picker JavaScript file
        wp_enqueue_script('daytidy-drp', $this->url('packages/date-range-picker/drp.min.js'), ['moment'], $this->version(), true);

        // Include date range picker CSS file
        wp_enqueue_style('daytidy-drp', $this->url('packages/date-range-picker/drp.min.css'), [], $this->version());
    }

    public function media(): void
    {
        $scripts = wp_scripts()->queue;
        $styles = wp_styles()->queue;
        wp_enqueue_media();
        if (self::$frontendProfiles)
        {
            self::$frontendMedia = true;
            self::$frontendScripts = array_values(array_unique(array_merge(self::$frontendScripts, array_diff(wp_scripts()->queue, $scripts))));
            self::$frontendStyles = array_values(array_unique(array_merge(self::$frontendStyles, array_diff(wp_styles()->queue, $styles))));
        }
    }

    /**
     * @param string|Closure $param
     * @return void
     */
    public static function footer($param): void
    {
        self::params($param);
    }

    /**
     * @param string|Closure $param
     * @param string $key
     * @return void
     */
    public static function params($param, string $key = 'footer'): void
    {
        // Closure
        if ($param instanceof Closure)
        {
            ob_start();
            call_user_func($param);
            $param = ob_get_clean();
        }

        // Invalid Key & Param
        if ((is_string($param) and Str::trim($param) === '') or Str::trim($key) === '') return;

        // Register the key for removing PHP notices
        if (!isset(self::$params[$key])) self::$params[$key] = [];

        // Add it to the params
        self::$params[$key][] = (string) $param;
    }

    public function loadFooter(): void
    {
        if (!Arr::filled(self::$params, 'footer')) return;

        // Remove duplicate strings
        $strings = array_unique(self::$params['footer']);

        // Escape registered form markup when it reaches the footer.
        foreach ($strings as $string)
        {
            // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped -- DayTidy Kses filters the generated form markup at output.
            echo PHP_EOL . Kses::form($string) . PHP_EOL;
        }
    }

    /**
     * @param string $client
     * @return bool
     */
    public function allowed(string $client = 'frontend'): bool
    {
        // Frontend
        if ($client == 'frontend') return (bool) apply_filters('DayTidy/F__DayTidy/Assets__allowed/frontend', count($this->detectedProfiles()) > 0 || count(self::$frontendProfiles) > 0);
        else
        {
            if (Screens::owns(get_current_screen())) return true;
            return apply_filters('DayTidy/F__DayTidy/Assets__allowed/backend', false);
        }
    }

    public function version(): string
    {
        $version = $this->profile->version();
        if (defined('WP_DEBUG') and WP_DEBUG) $version .= '.'.time();

        return $version;
    }

    /**
     * @param string $asset
     * @return string
     */
    public static function url(string $asset): string
    {
        return Profile::getInstance()->url().'/assets/'.Str::trim($asset, '/ ');
    }

    /**
     * @param string $asset
     * @return string
     */
    public function path(string $asset): string
    {
        return $this->profile->path().'/assets/'.Str::trim($asset, '/ ');
    }
}