var FA__WF_HASH_ID = "g1wBM";
var FA__BASE_URL = "https:\/\/aspeninstitute.tfaforms.net";
var FA__BASE_URL_ORIGIN = new URL(FA__BASE_URL).origin;
var FA__CONTAINER = null;
var FA__injectedStyles = [];
var FA__isInitialLoad = true;

/**
 * Appends the JS-embed signalling values as query params instead of sending them as the
 * X-Requested-With / X-FA-Embedded headers. Neither header is CORS-safelisted, so sending
 * them cross-origin forces an OPTIONS preflight; passing them as params keeps the request
 * "simple" and skips the preflight. JsEmbedHeadersMiddleware promotes them back into request
 * headers server-side so AJAX/embed detection is unchanged.
 *
 * Relative/root-relative URLs (e.g. a form action of "/api_v2/wf/...") are resolved against
 * FA__BASE_URL_ORIGIN, not window.location.href. This script runs in the host page's context, so
 * resolving against the host location would target the customer's origin instead of FormAssembly.
 */
function FA__withEmbedParams(url) {
    var resolved = new URL(url, FA__BASE_URL_ORIGIN);
    resolved.searchParams.set('X-Requested-With', 'XMLHttpRequest');
    resolved.searchParams.set('X-FA-Embedded', '1');
    resolved.searchParams.set('X-FA-Parent-URL', window.location.href);
    return resolved.toString();
}

/**
 * Fetches a REST URL and renders the HTML response into the embed container.
 */
function FA__fetchAndRender(url) {
    fetch(FA__withEmbedParams(url), {
        redirect: 'follow',
    })
    .then(function (r) { return r.text(); })
    .then(function (html) { FA__renderHtml(html, FA__attachSubmitInterceptor); })
    .catch(function (err) { console.error('FormAssembly embed error:', err); });
}

/**
 * Resume entry point used by the please-wait screen. The server emits an absolute
 * /wf/{token} URL when the lock is released; rewrite it to /rest/wf/{token} so
 * the resumed step stays inside the embed container.
 */
window.FA__resumeInEmbed = function (nextUrl) {
    FA__fetchAndRender(nextUrl.replace('/wf/', '/rest/wf/'));
};

/**
 * Returns the target container element where the workflow will be embedded.
 * Uses data-qp-target-id attribute on the embedding script tag, falling back to document.body.
 */
function FA__getContainer() {
    var script = document.querySelector('script[data-qp-target-id]');
    if (script) {
        var id = script.getAttribute('data-qp-target-id');
        if (id) {
            return document.getElementById(id);
        }
    }
    var fallback = document.createElement('div');
    document.body.appendChild(fallback);
    return fallback;
}

/**
 * Reinitializes form behaviors and components after the container DOM has been replaced.
 * Handles wFORMS behaviors, Kalendae calendar fallback, and reCAPTCHA state reset.
 */
function FA__reinitializeComponents() {
    // wFORMS: clear stale instances and reapply behaviors to new DOM
    if (typeof wFORMS !== 'undefined' && typeof wFORMS.applyBehaviors === 'function') {
        wFORMS.instances = {};
        document.querySelectorAll('body > .kalendae').forEach(function (el) { el.remove(); });

        var forms = FA__CONTAINER.querySelectorAll('form');
        forms.forEach(function (form) { wFORMS.applyBehaviors(form); });

        if (wFORMS.behaviors && wFORMS.behaviors.validation &&
            typeof wFORMS.behaviors.validation.enableResumeLater === 'function') {
            wFORMS.behaviors.validation.enableResumeLater();
        }

        if (wFORMS.behaviors && wFORMS.behaviors.prefill && FA__isInitialLoad) {
            forms.forEach(function (form) {
                wFORMS.behaviors.prefill.skip = false;
                wFORMS.behaviors.prefill.applyTo(form);
            });
            FA__isInitialLoad = false;
        }
    }

    // Kalendae fallback: wFORMS calendar behavior fails to reinitialize on re-render
    if (typeof Kalendae !== 'undefined') {
        var dateFields = FA__CONTAINER.querySelectorAll('.validate-datecal');
        if (dateFields.length > 0 && !document.querySelector('body > .kalendae')) {
            var calBehavior = typeof wFORMS !== 'undefined' && wFORMS.behaviors && wFORMS.behaviors.calendar;
            if (calBehavior) calBehavior.generateDefaultSettings();
            var opts = (calBehavior && calBehavior.instance && calBehavior.instance.prototype.defaultOptions)
                || { format: 'MM/DD/YYYY', selection: 'single', side: 'bottom', dayOutOfMonthClickable: true };
            dateFields.forEach(function (input) { new Kalendae.Input(input, opts); });
        }
    }

    // jSignature fallback: if applyBehaviors didn't create the signature canvas, call applyTo directly
    if (typeof wFORMS !== 'undefined' && wFORMS.behaviors && wFORMS.behaviors.esignature) {
        if (FA__CONTAINER.querySelector('.wformsSigDiv') && !FA__CONTAINER.querySelector('.wformsSigDiv canvas')) {
            FA__CONTAINER.querySelectorAll('form').forEach(function (form) {
                if (form.querySelector('.wFormsSignature')) {
                    wFORMS.behaviors.esignature.applyTo(form);
                }
            });
        }
    }

    // reCAPTCHA: reset state so the widget re-renders on the new DOM.
    // The enterprise script is skipped on subsequent forms (already loaded), so gCaptchaReadyCallback
    // never fires and captchaReady stays 0. Set it directly since grecaptcha IS available.
    var captchaDiv = FA__CONTAINER.querySelector('#g-recaptcha-render-div');
    if (captchaDiv) {
        window.hasCaptchaRendered = false;
        window.isCreatingCaptcha = false;
        if (typeof grecaptcha !== 'undefined' && grecaptcha.enterprise &&
            typeof grecaptcha.enterprise.render === 'function') {
            window.captchaReady = 1;
        }
        if (typeof disableSubmitButton === 'function') disableSubmitButton();
        if (typeof wformsReadyCallback === 'function') wformsReadyCallback();
    }

    // ALTCHA: the custom element auto-upgrades immediately on DOM insertion, so its load event
    // may fire before inline scripts attach a listener. Re-attach and handle the already-loaded case.
    var altchaWidget = FA__CONTAINER.querySelector('altcha-widget');
    if (altchaWidget) {
        altchaWidget.addEventListener('load', function () {
            requestAnimationFrame(function () { altchaWidget.classList.add('visible'); });
        });
        if (altchaWidget.value) altchaWidget.classList.add('visible');
    }
}

/**
 * Injects HTML into the container, injects styles into <head>, then loads external scripts
 * sequentially before re-running inline scripts and reinitializing components.
 */
function FA__renderHtml(html, callback) {
    // Parse into a temporary element to separate node types
    var tmp = document.createElement('div');
    tmp.innerHTML = html;

    FA__injectedStyles.forEach(function (el) { el.remove(); });
    FA__injectedStyles = [];

    Array.from(tmp.querySelectorAll('link[rel="stylesheet"], style')).forEach(function (el) {
        var href = el.getAttribute('href');
        if (href && document.querySelector('link[href="' + href + '"]')) return;
        var clone = el.cloneNode(true);
        document.head.appendChild(clone);
        FA__injectedStyles.push(clone);
    });

    // Collect scripts in document order. Inline scripts can depend on a preceding <script src>
    // having already executed (e.g. the jQuery noConflict dance in form_common_header.thtml),
    // so we must preserve original ordering rather than splitting external and inline scripts.
    var scripts = [];
    Array.from(tmp.querySelectorAll('script')).forEach(function (s) {
        // Skip the DOMContentLoaded dispatcher — we'll fire the event manually
        if (s.getAttribute('data-for') === 'FA__DOMContentLoadedEventDispatch') {
            s.parentNode.removeChild(s);
            return;
        }
        // Skip inline noConflict blocks — FA$ is managed once after scripts load
        if (!s.src && s.textContent.indexOf('noConflict') !== -1) {
            s.parentNode.removeChild(s);
            return;
        }
        scripts.push(s);
        s.parentNode.removeChild(s);
    });

    // Move the already-parsed nodes into the container (no second parse).
    FA__CONTAINER.replaceChildren.apply(
        FA__CONTAINER,
        Array.prototype.slice.call(tmp.childNodes)
    );

    // If the new step has a different localization script (e.g., switching from French to Spanish),
    // remove the old one so wForms system text (validation messages, buttons) matches the form's language.
    scripts.forEach(function (s) {
        if (s.src && s.src.indexOf('localization-') !== -1) {
            var existing = document.querySelector('script[src*="localization-"]');
            if (existing && existing.getAttribute('src') !== s.getAttribute('src')) {
                existing.parentNode.removeChild(existing);
            }
        }
    });

    // jSignature scripts must reload when the esignature page re-renders because the wFORMS
    // object is recreated during form step renders, losing the esignature behavior registration.
    var hasJsignatureScripts = scripts.some(function (s) {
        return s.src && s.src.indexOf('jsignature/') !== -1;
    });
    if (hasJsignatureScripts) {
        scripts.forEach(function (s) {
            var src = s.getAttribute('src');
            if (src) {
                var existing = document.querySelector('script[src="' + src + '"]');
                if (existing) existing.parentNode.removeChild(existing);
            }
        });
    }

    // Run scripts in document order, then reinitialize components
    FA__loadScriptsSequentially(scripts, function () {
        document.dispatchEvent(new Event('FA__DOMContentLoaded'));
        if (typeof window.FA$ === 'undefined' && typeof $ !== 'undefined' && typeof $.noConflict === 'function') {
            window.FA$ = $.noConflict(true);
        }
        FA__reinitializeComponents();

        var correctionLink = FA__CONTAINER.querySelector('#make-correction');
        if (correctionLink) {
            correctionLink.addEventListener('click', function (e) {
                e.preventDefault();
                FA__fetchAndRender(correctionLink.href.replace('/wf/', '/rest/wf/'));
            });
        }

        // Save-and-resume "Resume this form now" link points at /wf/{token}; rewrite to the
        // REST equivalent so the resumed step renders inside the embed container rather than
        // navigating the host page out of it (mirrors the #make-correction handler above).
        var resumeLink = FA__CONTAINER.querySelector('#tfa_resumeFormNowButton');
        if (resumeLink) {
            resumeLink.addEventListener('click', function (e) {
                e.preventDefault();
                FA__fetchAndRender(resumeLink.href.replace('/wf/', '/rest/wf/'));
            });
        }

        FA__CONTAINER.querySelectorAll('.forgotPasswordLink, .assistanceLink').forEach(function (link) {
            link.setAttribute('target', '_blank');
            var href = link.getAttribute('href');
            if (href && href.charAt(0) === '/' && href.charAt(1) !== '/') {
                link.setAttribute('href', FA__BASE_URL_ORIGIN + href);
            }
        });

        if (callback) callback();
    });
}

/**
 * Warms all external script downloads in parallel, then executes scripts in
 * document order. Preloading only parallelizes the network fetch; execution
 * order is preserved so dependency chains (jQuery -> wFORMS -> validation) are
 * unaffected. Scripts are same-origin as FA__BASE_URL, so a plain (no-crossorigin)
 * preload matches the later <script src> request and is reused from cache.
 */
function FA__loadScriptsSequentially(scripts, callback) {
    scripts.forEach(function (s) {
        if (!s.src) return;
        var alreadyLoaded = Array.from(document.scripts).some(function (d) {
            return d.src === s.src;
        });
        if (alreadyLoaded) return;
        if (document.querySelector('link[rel="preload"][href="' + s.src + '"]')) return;
        var preload = document.createElement('link');
        preload.rel = 'preload';
        preload.as = 'script';
        preload.href = s.src;
        document.head.appendChild(preload);
    });
    FA__runScriptsSequentially(scripts, callback);
}

/**
 * Executes scripts in order: external scripts wait for onload (now fast — the
 * bytes are already in cache from the preload above), inline scripts run on
 * append. DOMContentLoaded references in inline scripts are rewritten to
 * FA__DOMContentLoaded.
 */
function FA__runScriptsSequentially(scripts, callback) {
    if (!scripts.length) {
        callback();
        return;
    }
    var scriptEl = scripts.shift();

    if (scriptEl.src) {
        // Skip if already loaded. Compare resolved URLs (the .src IDL getter normalizes them)
        // because some form partials emit root-relative src attributes (e.g. calendar.thtml).
        // A literal-attribute selector would miss those.
        var alreadyLoaded = Array.from(document.scripts).some(function (s) {
            return s.src === scriptEl.src;
        });
        if (alreadyLoaded) {
            FA__runScriptsSequentially(scripts, callback);
            return;
        }

        var newScript = document.createElement('script');
        Array.from(scriptEl.attributes).forEach(function (attr) {
            newScript.setAttribute(attr.name, attr.value);
        });
        newScript.onload = function () { FA__runScriptsSequentially(scripts, callback); };
        newScript.onerror = function () { FA__runScriptsSequentially(scripts, callback); };
        document.head.appendChild(newScript);
        return;
    }

    var inlineScript = document.createElement('script');
    Array.from(scriptEl.attributes).forEach(function (attr) {
        inlineScript.setAttribute(attr.name, attr.value);
    });
    inlineScript.textContent = scriptEl.textContent.replace(
        /(['"])DOMContentLoaded\1/g, "'FA__DOMContentLoaded'"
    );
    document.head.appendChild(inlineScript);
    FA__runScriptsSequentially(scripts, callback);
}

/**
 * POSTs the form via fetch, handles redirects and cross-origin responses, and renders the result inline.
 */
function FA__submitAndProcessResponse(form) {
    var formData = new FormData(form);
    var action = form.getAttribute('action');

    // Rewrite non-REST /wf/ action URLs to /rest/wf/ to maintain REST context
    if (action && action.indexOf('/api_v2/wf/') !== -1 && action.indexOf('/rest/') === -1) {
        action = action.replace('/api_v2/wf/', '/api_v2/rest/wf/');
    }

    fetch(FA__withEmbedParams(action), {
        method: 'POST',
        body: formData,
        redirect: 'follow',
    })
    .then(function (response) {
        var redirectUrl = response.headers.get('X-Redirect-Url');
        if (redirectUrl) {
            window.location.href = redirectUrl;
            return null;
        }
        if (response.type === 'opaque' || (response.url && new URL(response.url).origin !== FA__BASE_URL_ORIGIN)) {
            window.onbeforeunload = null;
            window.location.href = response.url;
            return null;
        }
        return response.text();
    })
    .then(function (html) {
        if (html !== null && html.trim() !== '') {
            FA__renderHtml(html, FA__attachSubmitInterceptor);
        }
    })
    .catch(function (err) {
        console.error('FormAssembly embed error:', err);
        window.onbeforeunload = null;
        HTMLFormElement.prototype.submit.call(form);
    });
}

/**
 * Attaches a submit interceptor to any form inside the container.
 */
function FA__attachSubmitInterceptor() {
    var form = FA__CONTAINER.querySelector('form');
    if (!form) return;

    // Native browser validation blocks the submit event when custom web components (e.g. ALTCHA)
    // have unfocusable required fields. wFORMS handles all validation, so native checks are redundant.
    form.setAttribute('novalidate', '');

    form.submit = function () {
        FA__submitAndProcessResponse(form);
    };

    form.addEventListener('submit', function (event) {
        event.preventDefault();
        event.stopImmediatePropagation();

        var validationInstance = wFORMS && wFORMS.instances && wFORMS.instances.validation && wFORMS.instances.validation[0];
        if (validationInstance && typeof validationInstance.run === 'function') {
            if (!validationInstance.run(event, form)) return;
        }

        FA__submitAndProcessResponse(form);
    }, true);
}

/**
 * Loads the first workflow step from the REST start endpoint and initialises the embed.
 */
function FA__loadWorkflow() {
    FA__CONTAINER = FA__getContainer();
    FA__CONTAINER.innerHTML = '';

    // Intercept clicks on links that use the tfa_next referrer pattern (save-and-resume,
    // start new form, etc.) and load the FA path directly within the embed.
    FA__CONTAINER.addEventListener('click', function (e) {
        var link = e.target.closest('a[href*="tfa_next="]');
        if (!link) return;
        e.preventDefault();
        var tfaNext = new URL(link.href).searchParams.get('tfa_next');
        if (tfaNext) {
            FA__fetchAndRender(FA__BASE_URL_ORIGIN + '/rest' + decodeURIComponent(tfaNext));
        }
    });

    if (window !== window.parent && typeof ResizeObserver === 'function') {
        var embedScript = document.querySelector('script[data-qp-target-id]');
        var resizeParams = new URLSearchParams(window.location.search);
        if (embedScript && embedScript.src) {
            try {
                resizeParams = new URL(embedScript.src).searchParams;
            } catch (e) { /* ignore malformed src */ }
        }
        if (resizeParams.get('disableResize') !== '1') {
            var FA__iframeUniqueId = resizeParams.get('faIframeUniqueId') || '';
            var lastHeight = 0;
            var resizeObserver = new ResizeObserver(function() {
                var h = document.body.scrollHeight;
                if (h !== lastHeight) {
                    lastHeight = h;
                    parent.postMessage(h + ',' + FA__iframeUniqueId + ',' + window.location.href, '*');
                }
            });
            resizeObserver.observe(document.body);
        }
    }

    var parentParams = new URLSearchParams(window.location.search);

    var tfaNext = parentParams.get('tfa_next');
    if (tfaNext) {
        FA__fetchAndRender(FA__BASE_URL_ORIGIN + '/rest' + decodeURIComponent(tfaNext));
        return;
    }

    var url = new URL(FA__BASE_URL + '/rest/wf' + FA__WF_HASH_ID);

    parentParams.forEach(function (value, key) { url.searchParams.set(key, value); });

    var script = document.querySelector('script[data-qp-target-id]');
    if (script && script.src) {
        try {
            new URL(script.src).searchParams.forEach(function (value, key) {
                if (key !== 'key') url.searchParams.set(key, value);
            });
        } catch (e) { /* ignore malformed src */ }
    }

    fetch(FA__withEmbedParams(url.toString()), {
        redirect: 'follow',
    })
    .then(function (response) { return response.text(); })
    .then(function (html) {
        FA__renderHtml(html, FA__attachSubmitInterceptor);
    })
    .catch(function (err) {
        console.error('FormAssembly embed error:', err);
    });
}

if (document.readyState === 'loading' || document.readyState === 'interactive') {
    document.addEventListener('DOMContentLoaded', FA__loadWorkflow);
} else {
    FA__loadWorkflow();
}