/******************************************/
/* Загрузка JS */
/******************************************/

(async () => {
    const _scriptCache = new Map();      // normalizedUrl -> Promise<HTMLScriptElement>
    const _nodePromise = new WeakMap();  // scriptNode -> Promise<HTMLScriptElement>

    /**
     * Возвращает «каноническое» представление URL БЕЗ параметра v.
     * Используется для поиска уже существующих элементов на странице.
     */
    function canonicalUrl(src) {
        const u = new URL(src, document.baseURI);
        u.searchParams.delete("v");
        return u.href;
    }

    /**
     * Возвращает URL С параметром v — именно такой мы ставим в src при вставке.
     */
    function versionedUrl(src) {
        const u = new URL(src, document.baseURI);
        u.searchParams.set("v", window.version);
        return u.href;
    }

    function isElement(node) {
        return !!node && node.nodeType === 1;
    }

    /**
     * Ищет <script> на странице, сравнивая canonical-варианты URL
     * (т.е. без учёта параметра v).
     */
    function findScriptByUrl(canonical) {
        const scripts = document.querySelectorAll("script[src]");
        for (const s of scripts) {
            try {
                const existing = new URL(s.src, document.baseURI);
                existing.searchParams.delete("v");
                if (existing.href === canonical) return s;
            } catch {}
        }
        return null;
    }

    function insertScript(script, target, position) {
        switch (position) {
            case "append":
                target.append(script);
                return;
            case "prepend":
                target.prepend(script);
                return;
            case "before":
                if (!target.parentNode) throw new Error("Для position='before' у target нет parentNode");
                target.before(script);
                return;
            case "after":
                if (!target.parentNode) throw new Error("Для position='after' у target нет parentNode");
                target.after(script);
                return;
            default:
                throw new TypeError(`Неизвестная позиция вставки: ${String(position)}`);
        }
    }

    function runOnReady(promise, onReady) {
        if (typeof onReady !== "function") return promise;
        return promise.then((script) =>
            Promise.resolve(onReady(script)).then(() => script)
        );
    }

    function makePendingPromise({ script, canonical, timeout, createdHere }) {
        const promise = new Promise((resolve, reject) => {
            let settled = false;
            let timerId = null;

            const cleanup = () => {
                script.removeEventListener("load", onLoad);
                script.removeEventListener("error", onError);
                if (timerId !== null) {
                    clearTimeout(timerId);
                    timerId = null;
                }
            };

            const finishResolve = () => {
                if (settled) return;
                settled = true;
                cleanup();
                script.dataset.loadScriptStatus = "loaded";
                resolve(script);
            };

            const finishReject = (err) => {
                if (settled) return;
                settled = true;
                cleanup();
                script.dataset.loadScriptStatus = "failed";
                _scriptCache.delete(canonical);

                if (createdHere && script.isConnected) {
                    script.remove();
                }
                reject(err);
            };

            const onLoad = () => finishResolve();
            const onError = () => finishReject(new Error(`Failed to load script: ${script.src}`));

            script.addEventListener("load", onLoad, { once: true });
            script.addEventListener("error", onError, { once: true });

            if (timeout !== false && timeout !== null && timeout !== 0) {
                const t = Number(timeout);
                if (!Number.isFinite(t) || t < 0) {
                    finishReject(new TypeError(`Некорректный timeout: ${String(timeout)}`));
                    return;
                }
                if (t > 0) {
                    timerId = setTimeout(() => {
                        finishReject(new Error(`Timeout (${t}ms) while loading: ${script.src}`));
                    }, t);
                }
            }
        });

        _nodePromise.set(script, promise);
        return promise;
    }

    /**
     * loadScript(src, options)
     */
    window.loadScript = function loadScript(src, options = {}) {
        let canonical, versioned;
        try {
            canonical = canonicalUrl(src);
            versioned = versionedUrl(src);
        } catch {
            return Promise.reject(new TypeError(`Invalid script URL: ${String(src)}`));
        }

        const {
            position = "append",
            target: rawTarget = document.head || document.body || document.documentElement,
            attributes = {},
            timeout = 15000,
            onReady,
            assumeExistingIsLoaded = true
        } = options;

        const target = isElement(rawTarget)
            ? rawTarget
            : (document.head || document.body || document.documentElement);

        if (!target) {
            return Promise.reject(new Error("Не найден target для вставки script"));
        }

        // Кеш работает по canonical (без v)
        if (_scriptCache.has(canonical)) {
            return runOnReady(_scriptCache.get(canonical), onReady);
        }

        // Ищем существующий <script> тоже по canonical (без v)
        let existing = findScriptByUrl(canonical);
        if (existing) {
            const pending = _nodePromise.get(existing);
            if (pending) {
                _scriptCache.set(canonical, pending);
                return runOnReady(pending, onReady);
            }

            if (existing.dataset.loadScriptStatus === "loaded") {
                const p = Promise.resolve(existing);
                _scriptCache.set(canonical, p);
                return runOnReady(p, onReady);
            }

            if (existing.dataset.loadScriptStatus === "failed") {
                if (existing.isConnected) existing.remove();
                existing = null;
            } else {
                if (assumeExistingIsLoaded) {
                    const p = Promise.resolve(existing);
                    _scriptCache.set(canonical, p);
                    return runOnReady(p, onReady);
                }
                const p = makePendingPromise({
                    script: existing,
                    canonical,
                    timeout,
                    createdHere: false
                });
                _scriptCache.set(canonical, p);
                return runOnReady(p, onReady);
            }
        }

        // Создаём новый <script> — вот тут ставим versioned URL (с ?v=...)
        const script = document.createElement("script");
        script.src = versioned;
        script.dataset.loadScriptStatus = "pending";
        script.defer = true;

        for (const [key, value] of Object.entries(attributes || {})) {
            if (value == null || value === false) continue;
            if (key === "src") continue;

            if (key in script) {
                try {
                    script[key] = value;
                    continue;
                } catch {}
            }

            if (value === true) script.setAttribute(key, "");
            else script.setAttribute(key, String(value));
        }

        const p = makePendingPromise({
            script,
            canonical,
            timeout,
            createdHere: true
        });

        _scriptCache.set(canonical, p);

        try {
            insertScript(script, target, position);
        } catch (err) {
            _scriptCache.delete(canonical);
            return Promise.reject(err);
        }

        return runOnReady(p, onReady);
    };

    /**
     * loadScripts(list, options)
     */
    window.loadScripts = async function loadScripts(list, options = {}) {
        if (!Array.isArray(list)) {
            throw new TypeError("loadScripts: list должен быть массивом");
        }

        const {
            mode = "parallel",
            stopOnError = true,
            onReady,
            scriptOptions = {},
            ...rest
        } = options;

        const allowedScriptOptionKeys = new Set([
            "position",
            "target",
            "attributes",
            "timeout",
            "assumeExistingIsLoaded",
            "onReady"
        ]);

        const legacyScriptOptions = {};
        for (const [k, v] of Object.entries(rest)) {
            if (allowedScriptOptionKeys.has(k)) legacyScriptOptions[k] = v;
        }

        const baseScriptOptions = { ...legacyScriptOptions, ...scriptOptions };

        const items = list.map((item) => {
            if (typeof item === "string") {
                return { src: item, options: {} };
            }
            if (item && typeof item === "object" && typeof item.src === "string") {
                return { src: item.src, options: item.options || {} };
            }
            throw new TypeError("Элемент list должен быть строкой URL или объектом { src, options }");
        });

        const calls = items.map(({ src, options: perItemOptions }) => {
            const merged = { ...baseScriptOptions, ...perItemOptions };
            return () => window.loadScript(src, merged);
        });

        let result;

        if (mode === "parallel") {
            const promises = calls.map((fn) => fn());
            result = stopOnError ? await Promise.all(promises) : await Promise.allSettled(promises);
        } else if (mode === "sequential") {
            if (stopOnError) {
                const loaded = [];
                for (const run of calls) loaded.push(await run());
                result = loaded;
            } else {
                const settled = [];
                for (const run of calls) {
                    try {
                        settled.push({ status: "fulfilled", value: await run() });
                    } catch (error) {
                        settled.push({ status: "rejected", reason: error });
                    }
                }
                result = settled;
            }
        } else {
            throw new TypeError(`loadScripts: неизвестный mode=${String(mode)}`);
        }

        if (typeof onReady === "function") {
            await onReady(result);
        }

        return result;
    };
})();


/******************************************/
/* Загрузка CSS */
/******************************************/

(async () => {
    const _cssCache = new Map();

    function canonicalUrl(href) {
        const u = new URL(href, document.baseURI);
        u.searchParams.delete("v");
        return u.href;
    }

    function versionedUrl(href) {
        const u = new URL(href, document.baseURI);
        u.searchParams.set("v", window.version);
        return u.href;
    }

    function findLinkByUrl(canonical) {
        const links = document.querySelectorAll('link[href]');
        for (const link of links) {
            try {
                const rel = (link.getAttribute("rel") || "").toLowerCase();
                const isStylesheet = rel === "stylesheet";
                const isPreloadStyle = rel === "preload" && (link.getAttribute("as") || "").toLowerCase() === "style";
                if (!isStylesheet && !isPreloadStyle) continue;

                const existing = new URL(link.href, document.baseURI);
                existing.searchParams.delete("v");
                if (existing.href === canonical) return link;
            } catch {}
        }
        return null;
    }

    window.loadCss = async function loadCss(list, options = {}) {
        if (!Array.isArray(list)) {
            throw new TypeError("loadCss: list должен быть массивом");
        }

        const {
            anchorSelector = null,
            position = "after",
            mode = "parallel",
            stopOnError = true,
        } = options;

        if (position !== "before" && position !== "after") {
            throw new TypeError(`loadCss: неизвестная позиция "${String(position)}", допустимы "before" и "after"`);
        }

        const items = list.map((item) => {
            if (typeof item === "string") return item;
            if (item && typeof item === "object" && typeof item.href === "string") return item.href;
            throw new TypeError('Элемент list должен быть строкой URL или объектом { href }');
        });

        const anchor = anchorSelector ? document.querySelector(anchorSelector) : null;

        const entries = [];
        let lastInserted = null;

        for (const href of items) {
            let canonical, versioned;
            try {
                canonical = canonicalUrl(href);
                versioned = versionedUrl(href);
            } catch {
                entries.push({
                    promise: Promise.reject(new TypeError(`Invalid CSS URL: ${String(href)}`)),
                });
                continue;
            }

            if (_cssCache.has(canonical)) {
                entries.push({ promise: _cssCache.get(canonical), alreadyExisted: true });
                continue;
            }

            const existing = findLinkByUrl(canonical);
            if (existing) {
                const p = Promise.resolve(existing);
                _cssCache.set(canonical, p);
                entries.push({ promise: p, alreadyExisted: true });
                continue;
            }

            // Создаём новый <link> с preload-паттерном
            const link = document.createElement("link");
            link.rel = "preload";
            link.as = "style";
            link.href = versioned;

            const p = new Promise((resolve, reject) => {
                link.addEventListener("load", () => {
                    // Файл загружен — переключаем на stylesheet
                    link.onload = null;
                    link.rel = "stylesheet";
                    resolve(link);
                }, { once: true });

                link.addEventListener("error", () => {
                    _cssCache.delete(canonical);
                    if (link.isConnected) link.remove();
                    reject(new Error(`Failed to load CSS: ${versioned}`));
                }, { once: true });
            });

            _cssCache.set(canonical, p);

            if (lastInserted) {
                lastInserted.after(link);
            } else if (anchor && anchor.parentNode) {
                if (position === "after") {
                    anchor.after(link);
                } else {
                    anchor.before(link);
                }
            } else {
                (document.head || document.documentElement).append(link);
            }

            lastInserted = link;
            entries.push({ promise: p, alreadyExisted: false });
        }

        const promises = entries.map((e) => e.promise);

        if (mode === "sequential") {
            if (stopOnError) {
                const results = [];
                for (const p of promises) results.push(await p);
                return results;
            } else {
                const settled = [];
                for (const p of promises) {
                    try {
                        settled.push({ status: "fulfilled", value: await p });
                    } catch (error) {
                        settled.push({ status: "rejected", reason: error });
                    }
                }
                return settled;
            }
        }

        return stopOnError
            ? await Promise.all(promises)
            : await Promise.allSettled(promises);
    };
})();