<!-- Usercentrics V2 Embed -->
<script id="usercentrics-cmp" src="https://app.usercentrics.eu/browser-ui/latest/loader.js"
    data-settings-id="XXXXXXXXX" async></script>

<!-- Termageddon Geolocation Script - Optimized Version (with consent-persistence fix) -->
<script id="termageddon_usercentrics_geolocation">
    const termageddon_usercentrics_geolocation = (config = {}) => {
        const {
            debug = false,
            psl_hide = true,
            show_locations = {}
        } = config;

        const EU_COUNTRIES = ["AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE", "NO", "IS", "LI"];
        const WIDGET_SELECTORS = "div#usercentrics-root, aside#usercentrics-cmp-ui";
        const PSL_SELECTORS = "#usercentrics-psl, .usercentrics-psl";

        // Utility functions
        const getSessionStorage = (key) => {
            try {
                const value = sessionStorage.getItem(key);
                return value ? JSON.parse(value) : null;
            } catch (error) {
                console.warn("Failed to parse session storage:", error);
                return null;
            }
        };

        const getQueryParam = (param) => {
            try {
                return new URLSearchParams(window.location.search).get(param);
            } catch (error) {
                return null;
            }
        };

        const shouldShowBasedOnLocation = (countryCode, regionCode) => {
            // Handle EU countries
            if (show_locations.EU) {
                if (show_locations.EU === true && EU_COUNTRIES.includes(countryCode)) {
                    return true;
                }
                if (Array.isArray(show_locations.EU) && show_locations.EU.includes(countryCode)) {
                    return true;
                }
            }

            // Check specific country configuration
            const countryConfig = show_locations[countryCode];
            if (!countryConfig) return false;
            if (countryConfig === true) return true;
            if (Array.isArray(countryConfig)) return countryConfig.includes(regionCode);

            return false;
        };

        const setElementStyles = (elements, styles) => {
            elements.forEach(element => {
                Object.entries(styles).forEach(([property, value]) => {
                    if (value === null) {
                        element.style.removeProperty(property);
                    } else {
                        element.style.setProperty(property, value, 'important');
                    }
                });
            });
        };

        const showConsentWidget = () => {
            // Show privacy settings links
            if (psl_hide) {
                document.querySelectorAll(PSL_SELECTORS).forEach(el => {
                    el.style.display = '';
                });
            }

            // Remove forced hiding styles
            const widgets = document.querySelectorAll(WIDGET_SELECTORS);
            setElementStyles(widgets, {
                'display': null,
                'visibility': null,
                'opacity': null,
                'pointer-events': null
            });

            // Only force the first layer open if consent is actually still
            // required (visitor hasn't responded yet, or Usercentrics has
            // flagged a resurface as due). isConsentRequired() covers BOTH
            // "accept" and "deny" outcomes.
            if (window.UC_UI?.showFirstLayer && window.UC_UI?.isConsentRequired?.()) {
                try {
                    UC_UI.showFirstLayer();
                } catch (error) {
                    // Fallback: ensure widgets are visible
                    widgets.forEach(el => el.style.display = '');
                }
            }
        };

        const hideConsentWidget = () => {
            // Hide privacy settings links
            if (psl_hide) {
                document.querySelectorAll(PSL_SELECTORS).forEach(el => {
                    el.style.display = 'none';
                });
            }

            // Forcefully hide consent widgets
            const widgets = document.querySelectorAll(WIDGET_SELECTORS);
            setElementStyles(widgets, {
                'display': 'none',
                'visibility': 'hidden',
                'opacity': '0',
                'pointer-events': 'none'
            });

            // Auto-accept consents if not already accepted
            if (window.UC_UI?.areAllConsentsAccepted && window.UC_UI?.acceptAllConsents) {
                try {
                    if (!UC_UI.areAllConsentsAccepted()) {
                        UC_UI.acceptAllConsents().then(() => {
                            UC_UI.closeCMP?.();
                        }).catch(() => {
                            // Silent fail - consent management will handle this
                        });
                    }
                } catch (error) {
                    // Silent fail - consent management will handle this
                }
            }
        };

        const processGeolocation = () => {
            // Verify Usercentrics is loaded
            if (!window.UC_UI) {
                console.error("Usercentrics not loaded");
                return;
            }

            // Check for query parameter override
            if (getQueryParam("enable-usercentrics") === "") {
                showConsentWidget();
                return;
            }

            // On a first-ever (cold) page load, Usercentrics' IP-based
            // geolocation lookup can still be in flight when UC_UI_INITIALIZED
            // fires, so "uc_user_country" may not be in session storage yet.
            // Poll briefly instead of checking once and giving up - this is
            // why the banner previously worked only after a refresh (by then
            // the lookup from the first load had already completed and cached).
            const maxAttempts = 20;      // 20 x 150ms = up to 3 seconds
            const intervalMs = 150;
            let attempts = 0;

            const tryGetLocation = () => {
                const locationData = getSessionStorage("uc_user_country");

                if (locationData?.regionCode && locationData?.countryCode) {
                    const { countryCode, regionCode } = locationData;
                    const shouldShow = shouldShowBasedOnLocation(countryCode, regionCode);

                    if (shouldShow) {
                        showConsentWidget();
                    } else {
                        hideConsentWidget();
                    }
                    return;
                }

                attempts++;
                if (attempts < maxAttempts) {
                    setTimeout(tryGetLocation, intervalMs);
                } else {
                    console.warn("UC: No valid location data found after waiting. Ensure Usercentrics v2 is being used.");
                }
            };

            // Small initial delay for initialization, then start polling
            setTimeout(tryGetLocation, 50);
        };

        // Initialize when Usercentrics is ready
        if (window.UC_UI) {
            processGeolocation();
        } else {
            window.addEventListener("UC_UI_INITIALIZED", processGeolocation);
        }
    };
</script>

<script>
    // Initialize geolocation - only show for California
    termageddon_usercentrics_geolocation({
        debug: false,
        psl_hide: true,
        show_locations: {
            US: ["CA"], // Only California for US states - add comma separated abbreviations to add more states
            CA: true,   // All of Canada
            GB: true,   // All of Great Britain
            EU: true,   // All EU countries
        },
    });
</script>