/**
 * Alpha Air 专用节点清理脚本
 * - 压掉提供者、三网、家宽等 Alpha Air 专属文案
 * - 普通节点只保留地区，非倍率高级节点保留供应商，倍率节点保留倍率
 * - 按地区内“普通 -> 倍率 -> 高级”排序并连续编号
 * - 不追加订阅后缀，整合订阅最后仍交给 rename.js 处理
 */
// noinspection JSUnusedGlobalSymbols
const COMMON_SCRIPT_VERSION = '20260702-1';
const COMMON_SCRIPT_URL = `https://git.orionc.me/orion/script/raw/branch/main/substore/common.js?v=${COMMON_SCRIPT_VERSION}`;
const hasCurrentRenameUtils = utils => Boolean(
    utils && utils.version === COMMON_SCRIPT_VERSION
);

async function loadRenameUtils() {
    if (typeof globalThis !== 'undefined' && hasCurrentRenameUtils(globalThis.SubStoreRenameUtils)) {
        return globalThis.SubStoreRenameUtils;
    }

    const cache = typeof scriptResourceCache !== 'undefined' ? scriptResourceCache : null;
    let script = cache && cache.get(COMMON_SCRIPT_URL);
    if (!script) {
        const response = await $substore.http.get({ url: COMMON_SCRIPT_URL });
        script = response && (response.body || response.data || response);
        if (cache) cache.set(COMMON_SCRIPT_URL, script);
    }

    new Function(String(script))();
    if (!hasCurrentRenameUtils(globalThis.SubStoreRenameUtils)) {
        throw new Error('Loaded common.js is missing current rename utilities');
    }
    return globalThis.SubStoreRenameUtils;
}

async function operator(proxies) {
    const utils = await loadRenameUtils();
    const regionAliases = [
        ['美国夏威夷', 'US HNL'],
        ['家宽夏威夷', 'US HNL'],
        ['夏威夷', 'US HNL'],
        ['Hawaii', 'US HNL'],
        ['United States', 'US'],
        ['America', 'US'],
        ['USA', 'US'],
        ['美国', 'US'],
        ['美西', 'US'],
        ['Japan', 'JP'],
        ['日本', 'JP'],
        ['Taiwan', 'TW'],
        ['台湾', 'TW'],
        ['Hong Kong', 'HK'],
        ['香港', 'HK'],
        ['Singapore', 'SG'],
        ['新加坡', 'SG'],
        ['Netherlands', 'NL'],
        ['荷兰', 'NL'],
        ['Korea', 'KR'],
        ['韩国', 'KR'],
        ['Germany', 'DE'],
        ['德国', 'DE'],
        ['United Kingdom', 'UK'],
        ['英国', 'UK']
    ];
    const regionResolver = utils.createRegionResolver(regionAliases);

    const providerOf = name => {
        if (/SkyStroll/i.test(name)) return 'SkyStroll';
        if (/isif/i.test(name)) return 'ISIF';
        if (/搬瓦工|Bandwagon|BWH|BWG/i.test(name)) return 'BWH';
        return '';
    };

    const alphaAirRegionPrefixOf = name => {
        if (/\bhk\b/i.test(name)) return 'HK';
        if (/\bsg\b/i.test(name)) return 'SG';
        if (/\bjp\b/i.test(name)) return 'JP';
        if (/\btw\b/i.test(name)) return 'TW';
        if (/\bus\b/i.test(name)) return 'US';

        return regionResolver.aliasRegionPrefixOf(name);
    };

    const regionPrefixOf = (name, flagRegionCode) => {
        if (/Hinet|Seednet/i.test(name)) return 'TW';

        return alphaAirRegionPrefixOf(name) ||
            utils.leadingRegionPrefixOf(name) ||
            flagRegionCode ||
            '';
    };

    const normalizeProxy = (proxy, originalIndex) => {
        const rawName = typeof proxy.name === 'string' ? proxy.name : '';
        const cleanName = utils.stripSubscriptionSuffix(rawName, 'Alpha Air');
        const { flag, text } = utils.splitLeadingOrInlineFlag(cleanName);
        const flagRegionCode = utils.flagToRegionCode(flag);
        const regionPrefix = regionPrefixOf(text, flagRegionCode);
        const regionCode = regionPrefix.split(/\s+/)[0];
        const cityCode = regionPrefix.split(/\s+/)[1] || '';
        const multiplier = utils.multiplierOf(text);
        const provider = multiplier ? '' : providerOf(text);
        const normalizedFlag = utils.regionCodeToFlag(regionCode);

        return {
            proxy,
            originalIndex,
            countryCode: regionCode,
            cityCode,
            normalizedFlag,
            regionPrefix,
            provider,
            multiplier,
            providerRank: provider ? 1 : 0,
            multiplierValue: utils.multiplierValueOf(multiplier),
            normalizedName: [normalizedFlag, regionPrefix, provider, multiplier].filter(Boolean).join(' ').trim()
        };
    };

    const countryOrder = Object.create(null);
    let countryOrderCount = 0;
    const normalizedItems = proxies.map((proxy, proxyIndex) => {
        const normalizedItem = normalizeProxy(proxy, proxyIndex);
        if (
            normalizedItem.countryCode &&
            countryOrder[normalizedItem.countryCode] === undefined
        ) {
            countryOrder[normalizedItem.countryCode] = countryOrderCount++;
        }
        return normalizedItem;
    });

    normalizedItems.sort((firstItem, secondItem) => {
        if (!firstItem.countryCode || !secondItem.countryCode) {
            return firstItem.originalIndex - secondItem.originalIndex;
        }

        const firstOrder = countryOrder[firstItem.countryCode];
        const secondOrder = countryOrder[secondItem.countryCode];
        if (firstOrder !== secondOrder) return firstOrder - secondOrder;
        if (firstItem.providerRank !== secondItem.providerRank) {
            return firstItem.providerRank - secondItem.providerRank;
        }
        if (firstItem.multiplierValue !== secondItem.multiplierValue) {
            return firstItem.multiplierValue - secondItem.multiplierValue;
        }

        const firstCityRank = firstItem.cityCode ? 1 : 0;
        const secondCityRank = secondItem.cityCode ? 1 : 0;
        if (firstCityRank !== secondCityRank) return firstCityRank - secondCityRank;

        return firstItem.originalIndex - secondItem.originalIndex;
    });

    const nextSequence = utils.createSequenceCounter();
    return normalizedItems.map(item => {
        if (!item.normalizedName || !item.countryCode) return item.proxy;

        item.proxy.name = [
            item.normalizedFlag,
            item.regionPrefix,
            nextSequence(item.countryCode),
            item.provider,
            item.multiplier
        ].filter(Boolean).join(' ').trim();
        return item.proxy;
    });
}