import {
    DATA_IMAGE_URL_PREFIX,
    IMAGE_FIELD_NAMES,
    MAX_IMAGE_URL_SEARCH_DEPTH,
    PROTOCOL_RELATIVE_IMAGE_URL_PATTERN,
    REMOTE_IMAGE_URL_PATTERN,
    SIDEBAR_GAME_ROW_CONTAINER_SELECTOR,
    SIDEBAR_GAME_ROW_IMAGE_SELECTOR,
    SIDEBAR_GAME_ROW_MORE_SELECTOR,
    SIDEBAR_GAME_ROW_TITLE_SELECTOR,
    SIDEBAR_GAME_ROW_TOOLTIP_ID_PATTERN,
    STEAM_APP_ID_FIELD_NAMES,
    STEAM_APP_ID_PATTERN,
    STEAM_CONTAINER_FIELD_PATTERN,
    STEAM_CONTAINER_ID_FIELD_NAMES,
    STEAM_PLATFORM,
    WEMOD_STEAM_COMMUNITY_CDN_BASE_URL,
} from './constants.js';
import { isRecord, safeString, toStringId } from './runtime.js';

export function pickImageUrl(...values) {
    for (const value of values) {
        const imageUrl = normalizeImageUrl(value);
        if (imageUrl) {
            return imageUrl;
        }
    }

    return null;
}

export function normalizeImageUrl(value, depth = 0) {
    if (typeof value === 'string') {
        const trimmed = value.trim();
        if (REMOTE_IMAGE_URL_PATTERN.test(trimmed) || trimmed.startsWith(DATA_IMAGE_URL_PREFIX)) {
            return trimmed;
        }

        if (PROTOCOL_RELATIVE_IMAGE_URL_PATTERN.test(trimmed)) {
            return `https:${trimmed}`;
        }

        return null;
    }

    if (depth > MAX_IMAGE_URL_SEARCH_DEPTH || !value) {
        return null;
    }

    if (Array.isArray(value)) {
        for (const entry of value) {
            const imageUrl = normalizeImageUrl(entry, depth + 1);
            if (imageUrl) {
                return imageUrl;
            }
        }

        return null;
    }

    if (!isRecord(value)) {
        return null;
    }

    for (const key of IMAGE_FIELD_NAMES) {
        const imageUrl = normalizeImageUrl(value[key], depth + 1);
        if (imageUrl) {
            return imageUrl;
        }
    }

    return null;
}

export function getSteamClientIconUrl(...values) {
    for (const value of values) {
        const steamAppId = toStringId(value);
        if (steamAppId && STEAM_APP_ID_PATTERN.test(steamAppId)) {
            return `${WEMOD_STEAM_COMMUNITY_CDN_BASE_URL}/${steamAppId}/client_icon/96.webp`;
        }
    }

    return null;
}

export function getSidebarGameRowClientIcons() {
    const byTitleId = new Map();
    const byTitleName = new Map();
    if (typeof document === 'undefined') {
        return { byTitleId, byTitleName };
    }

    const containers = document.querySelectorAll(SIDEBAR_GAME_ROW_CONTAINER_SELECTOR);
    for (const container of containers) {
        const imageElement = container.querySelector(SIDEBAR_GAME_ROW_IMAGE_SELECTOR);
        const titleElement = container.querySelector(SIDEBAR_GAME_ROW_TITLE_SELECTOR);
        const moreButton = container.querySelector(SIDEBAR_GAME_ROW_MORE_SELECTOR);
        if (!imageElement || !titleElement) {
            continue;
        }

        const backgroundImageUrl = getCssBackgroundImageUrl(
            safeString(imageElement.style?.backgroundImage) ||
                getComputedStyle(imageElement).backgroundImage,
        );
        if (!backgroundImageUrl) {
            continue;
        }

        const tooltipId = safeString(moreButton?.getAttribute?.('data-tooltip-trigger-for'));
        const titleId = tooltipId.match(SIDEBAR_GAME_ROW_TOOLTIP_ID_PATTERN)?.[1] ?? null;
        const titleName = normalizeTitleMatchKey(titleElement.textContent);

        if (titleId) {
            byTitleId.set(titleId, backgroundImageUrl);
        }

        if (titleName) {
            byTitleName.set(titleName, backgroundImageUrl);
        }
    }

    return { byTitleId, byTitleName };
}

export function getSidebarGameRowClientIconUrl(sidebarIcons, titleId, ...names) {
    const normalizedTitleId = toStringId(titleId);
    if (normalizedTitleId && sidebarIcons.byTitleId.has(normalizedTitleId)) {
        return sidebarIcons.byTitleId.get(normalizedTitleId) ?? null;
    }

    for (const name of names) {
        const normalizedName = normalizeTitleMatchKey(name);
        if (normalizedName && sidebarIcons.byTitleName.has(normalizedName)) {
            return sidebarIcons.byTitleName.get(normalizedName) ?? null;
        }
    }

    return null;
}

export function findSteamAppId(...roots) {
    const seen = new Set();
    const queue = roots.map((value) => ({ value, depth: 0, steamContext: false }));

    while (queue.length > 0) {
        const current = queue.shift();
        const value = current?.value;
        const depth = current?.depth ?? 0;
        const steamContext = current?.steamContext ?? false;

        if (!value || depth > MAX_IMAGE_URL_SEARCH_DEPTH || seen.has(value)) {
            continue;
        }

        if (typeof value === 'string' || typeof value === 'number') {
            const steamAppId = steamContext ? toStringId(value) : null;
            if (steamAppId && STEAM_APP_ID_PATTERN.test(steamAppId)) {
                return steamAppId;
            }
            continue;
        }

        seen.add(value);

        if (Array.isArray(value)) {
            for (const entry of value) {
                queue.push({ value: entry, depth: depth + 1, steamContext });
            }
            continue;
        }

        if (!isRecord(value)) {
            continue;
        }

        for (const [key, entry] of Object.entries(value)) {
            const steamAppId = getSteamAppIdFromEntry(key, entry, steamContext);
            if (steamAppId) {
                return steamAppId;
            }

            if (isRecord(entry) || Array.isArray(entry)) {
                queue.push({
                    value: entry,
                    depth: depth + 1,
                    steamContext: steamContext || STEAM_CONTAINER_FIELD_PATTERN.test(key),
                });
            }
        }
    }

    return null;
}

export function getInstalledAppSteamAppId(platform, sku) {
    if (safeString(platform).toLowerCase() !== STEAM_PLATFORM) {
        return null;
    }

    return sku;
}

function normalizeTitleMatchKey(value) {
    const normalized = safeString(value).trim().toLowerCase().replace(/\s+/g, ' ');
    return normalized || null;
}

function getCssBackgroundImageUrl(value) {
    const backgroundImage = safeString(value);
    if (!backgroundImage || backgroundImage === 'none') {
        return null;
    }

    const match = backgroundImage.match(/url\((['"]?)(.*?)\1\)/i);
    if (!match?.[2]) {
        return null;
    }

    return normalizeImageUrl(match[2]);
}

function getSteamAppIdFromEntry(key, entry, steamContext) {
    if (STEAM_APP_ID_FIELD_NAMES.has(key)) {
        const steamAppId = toStringId(entry);
        if (steamAppId && STEAM_APP_ID_PATTERN.test(steamAppId)) {
            return steamAppId;
        }
    }

    if (steamContext && STEAM_CONTAINER_ID_FIELD_NAMES.has(key)) {
        const steamAppId = toStringId(entry);
        if (steamAppId && STEAM_APP_ID_PATTERN.test(steamAppId)) {
            return steamAppId;
        }
    }

    return null;
}