(function () {
    var remoteBridgeVersion = '20260610.2';

    function safeCall(fn, args) {
        try {
            if (typeof fn === 'function') {
                return fn.apply(window, args || []);
            }
        } catch (error) {
            post('debugLog', {
                message: String((error && error.message) || error),
            });
        }
        return null;
    }

    function readObject(value) {
        return value && typeof value === 'object' && !Array.isArray(value)
            ? value
            : {};
    }

    function readString(value) {
        if (value === null || value === undefined) {
            return '';
        }
        return String(value).trim();
    }

    function readPositiveInteger(value) {
        if (typeof value === 'number' && isFinite(value)) {
            return value > 0 ? Math.floor(value) : 0;
        }
        var text = readString(value);
        if (!/^[0-9]+$/.test(text)) {
            return 0;
        }
        var parsed = Number(text);
        return isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
    }

    function normalizeAdapterConfig(config, adapter) {
        if (adapter !== 'vivagames_v1') {
            return config;
        }
        var appId = readPositiveInteger(config.app_id);
        if (appId <= 0) {
            appId = readPositiveInteger(config.appId);
        }
        if (appId > 0) {
            config.app_id = appId;
            config.appId = appId;
        }
        return config;
    }

    function post(action, body) {
        var message = JSON.stringify({ action: action, payload: body || {} });
        if (postToChannel('GameBridgeChannel', message)) {
            return;
        }
        if (postToChannel('BaishunBridgeChannel', message)) {
            return;
        }
        if (postToChannel('LeaderBridgeChannel', message)) {
            return;
        }
        postToChannel('NativeBridge', message);
    }

    function postToChannel(name, message) {
        if (window[name] && window[name].postMessage) {
            window[name].postMessage(message);
            return true;
        }
        if (
            window.webkit &&
            window.webkit.messageHandlers &&
            window.webkit.messageHandlers[name] &&
            window.webkit.messageHandlers[name].postMessage
        ) {
            window.webkit.messageHandlers[name].postMessage(message);
            return true;
        }
        return false;
    }

    function launchPayload() {
        return readObject(window.hyappGameLaunchPayload);
    }

    function launchConfig() {
        var payload = launchPayload();
        return readObject(window.hyappGameLaunchConfig || payload.launchConfig);
    }

    function launchEntry() {
        var payload = launchPayload();
        return readObject(window.hyappGameEntry || payload.entry);
    }

    function detectAdapter(config, payload) {
        var values = [
            config.adapterType,
            config.adapter_type,
            config.platformCode,
            config.platform_code,
            config.vendorType,
            config.vendor_type,
            payload.vendorType,
            payload.vendor_type,
            payload.platformCode,
            payload.platform_code,
            payload.gameId,
            payload.game_id,
        ]
            .map(readString)
            .join('|')
            .toLowerCase();
        if (values.indexOf('vivagames') >= 0) {
            return 'vivagames_v1';
        }
        if (values.indexOf('baishun') >= 0) {
            return 'baishun_v1';
        }
        if (values.indexOf('leadercc') >= 0) {
            return 'leadercc_v1';
        }
        if (values.indexOf('zeeone') >= 0) {
            return 'zeeone_v1';
        }
        if (values.indexOf('reyou') >= 0 || values.indexOf('hotgame') >= 0) {
            return 'reyou_v1';
        }
        if (values.indexOf('yomi') >= 0) {
            return 'yomi_v4';
        }
        return 'generic';
    }

    function stringifyParams(body) {
        try {
            return JSON.stringify(body || {});
        } catch (_) {
            return '{}';
        }
    }

    function notifyVivaGames(method, body) {
        var params = body || {};
        safeCall(window.OnCallGame, [method, params]);
        try {
            window.postMessage(
                { method: method, params: stringifyParams(params) },
                '*'
            );
        } catch (_) {}
        try {
            if (
                window.parent &&
                window.parent !== window &&
                window.parent.postMessage
            ) {
                window.parent.postMessage(
                    { method: method, params: stringifyParams(params) },
                    '*'
                );
            }
        } catch (_) {}
    }

    function installAlias(name, action) {
        var fn = function (body) {
            return callNativeBridge(action || name, body);
        };
        fn.postMessage = function (body) {
            callNativeBridge(action || name, body);
        };
        window[name] = fn;
        window.webkit = window.webkit || {};
        window.webkit.messageHandlers = window.webkit.messageHandlers || {};
        window.webkit.messageHandlers[name] = { postMessage: fn.postMessage };
    }

    function parseBridgePayload(value) {
        if (typeof value === 'string') {
            var text = value.trim();
            if (!text) {
                return {};
            }
            try {
                var decoded = JSON.parse(text);
                return decoded && typeof decoded === 'object'
                    ? decoded
                    : { value: decoded };
            } catch (_) {
                return { raw: text };
            }
        }
        if (value && typeof value === 'object') {
            return value;
        }
        if (value === null || value === undefined) {
            return {};
        }
        return { value: value };
    }

    function actionFromPayload(payload, fallbackAction) {
        return (
            readString(
                payload.type ||
                    payload.action ||
                    payload.method ||
                    payload.name ||
                    payload.cmd ||
                    payload.event
            ) || fallbackAction
        );
    }

    function invokeNamedCallback(callbackName, payload) {
        var text = readString(callbackName);
        if (
            !/^[A-Za-z_$][0-9A-Za-z_$]*(\.[A-Za-z_$][0-9A-Za-z_$]*)*$/.test(
                text
            )
        ) {
            return false;
        }
        var parts = text.split('.');
        var target = window;
        for (var i = 0; i < parts.length; i += 1) {
            target = target[parts[i]];
            if (target === null || target === undefined) {
                return false;
            }
        }
        if (typeof target !== 'function') {
            return false;
        }
        safeCall(target, [payload || {}]);
        return true;
    }

    function yomiActionResult(action, payload) {
        var normalized = readString(action).toLowerCase();
        if (normalized === 'insufficient') {
            return {
                action: 'insufficient',
                result: 'success',
                balance: payload && payload.balance,
            };
        }
        if (normalized === 'hidesplash') {
            return { action: 'hideSplash', result: 'success' };
        }
        if (normalized === 'closegame') {
            return { action: 'closeGame', result: 'success' };
        }
        return { action: action, result: 'success' };
    }

    function postYomiAction(action, input) {
        var payload = parseBridgePayload(input);
        var normalized = actionFromPayload(payload, action);
        if (!normalized) {
            normalized = 'NativeBridge';
        }
        payload.type = payload.type || normalized;
        payload.action = payload.action || normalized;
        post(normalized, payload);
        invokeNamedCallback(
            payload.callback || payload.callbackName || payload.cb,
            yomiActionResult(normalized, payload)
        );
        return yomiActionResult(normalized, payload);
    }

    function extractYomiBalance(payload) {
        var body = parseBridgePayload(payload);
        if (body.balance !== null && body.balance !== undefined) {
            return body.balance;
        }
        if (body.amount !== null && body.amount !== undefined) {
            return body.amount;
        }
        if (body.coin !== null && body.coin !== undefined) {
            return body.coin;
        }
        if (body.balanceLabel !== null && body.balanceLabel !== undefined) {
            return body.balanceLabel;
        }
        return undefined;
    }

    function notifyYomiGame(action, body) {
        var normalized = readString(action);
        if (normalized === 'onBalanceUpdate') {
            var balance = extractYomiBalance(body);
            if (balance === undefined) {
                safeCall(window.onBalanceUpdate, []);
            } else {
                safeCall(window.onBalanceUpdate, [balance]);
            }
        }
        if (normalized === 'setSound') {
            var payload = parseBridgePayload(body);
            var soundEnabled =
                payload.bool !== undefined
                    ? payload.bool
                    : payload.enabled !== undefined
                      ? payload.enabled
                      : payload.value;
            safeCall(window.setSound, [!!soundEnabled]);
        }
        if (normalized === 'passiveCloseGame') {
            safeCall(window.passiveCloseGame, []);
        }
        try {
            window.dispatchEvent(
                new CustomEvent('yomiBridgeAction', {
                    detail: { action: normalized, payload: body || {} },
                })
            );
        } catch (_) {}
    }

    function installYomiPostMessageListener() {
        if (window.__hyappYomiPostMessageListenerInstalled) {
            return;
        }
        window.__hyappYomiPostMessageListenerInstalled = true;
        window.addEventListener('message', function (event) {
            var data = parseBridgePayload(event && event.data);
            if (readString(data.from).toLowerCase() !== 'yomi') {
                return;
            }
            var action = actionFromPayload(data, '');
            if (!action) {
                return;
            }
            postYomiAction(action, data);
        });
    }

    function installYomiBridgeAliases(nativeBridge) {
        var previousYomi = window.yomi || {};
        var yomiBridge = {};
        var previousUpdateCoin =
            typeof nativeBridge.updateCoin === 'function'
                ? nativeBridge.updateCoin.bind(nativeBridge)
                : null;

        yomiBridge.postMessage = function (message) {
            var payload = parseBridgePayload(message);
            return postYomiAction(
                actionFromPayload(payload, 'NativeBridge'),
                payload
            );
        };
        yomiBridge.closeGame = function (body) {
            return postYomiAction('closeGame', body || {});
        };
        yomiBridge.hideSplash = function (body) {
            return postYomiAction('hideSplash', body || {});
        };
        yomiBridge.insufficient = function (body) {
            return postYomiAction('insufficient', body || {});
        };
        yomiBridge.onBalanceUpdate = function (body) {
            notifyYomiGame('onBalanceUpdate', body || {});
        };
        yomiBridge.setSound = function (body) {
            notifyYomiGame('setSound', body || {});
        };
        yomiBridge.passiveCloseGame = function () {
            notifyYomiGame('passiveCloseGame', {});
        };
        Object.keys(previousYomi).forEach(function (key) {
            if (yomiBridge[key] === undefined) {
                yomiBridge[key] = previousYomi[key];
            }
        });
        window.yomi = yomiBridge;
        window.webkit = window.webkit || {};
        window.webkit.messageHandlers = window.webkit.messageHandlers || {};
        window.webkit.messageHandlers.yomi = {
            postMessage: yomiBridge.postMessage,
        };

        nativeBridge.insufficient = function (body) {
            postYomiAction('insufficient', body || {});
        };
        nativeBridge.hideSplash = function (body) {
            postYomiAction('hideSplash', body || {});
        };
        nativeBridge.onBalanceUpdate = function (body) {
            notifyYomiGame('onBalanceUpdate', body || {});
        };
        nativeBridge.setSound = function (body) {
            notifyYomiGame('setSound', body || {});
        };
        nativeBridge.passiveCloseGame = function () {
            notifyYomiGame('passiveCloseGame', {});
        };
        nativeBridge.updateCoin = function (body) {
            if (previousUpdateCoin) {
                previousUpdateCoin(body || {});
            }
            notifyYomiGame('onBalanceUpdate', body || {});
        };

        installYomiPostMessageListener();
    }

    function notifyReyouRechargeSuccess(body) {
        var payload = body || {};
        var notified = false;
        [window.rechargeSuccess, window.onRechargeSuccess].forEach(
            function (fn) {
                if (typeof fn === 'function') {
                    safeCall(fn, [payload]);
                    notified = true;
                }
            }
        );
        try {
            window.dispatchEvent(
                new CustomEvent('rechargeSuccess', { detail: payload })
            );
        } catch (_) {}
        return notified;
    }

    function installReyouBridgeAliases(nativeBridge) {
        var jsBridge = window.JsBridge || {};
        jsBridge.recharge = function (body) {
            return callNativeBridge('gameRecharge', body || {});
        };
        jsBridge.quit = function (body) {
            return callNativeBridge('closeGame', body || {});
        };
        window.JsBridge = jsBridge;

        installAlias('recharge', 'gameRecharge');
        installAlias('quit', 'closeGame');

        nativeBridge.recharge = function (body) {
            callNativeBridge('gameRecharge', body || {});
        };
        nativeBridge.quit = function (body) {
            callNativeBridge('closeGame', body || {});
        };
        nativeBridge.rechargeSuccess = function (body) {
            notifyReyouRechargeSuccess(body || {});
        };
        nativeBridge.updateCoin = function (body) {
            notifyReyouRechargeSuccess(body || {});
            callNativeBridge('refreshBalance', body || {});
        };
    }

    function callNativeBridge(action, body) {
        var config = launchConfig();
        var payload = launchPayload();
        var adapter = detectAdapter(config, payload);
        config = normalizeAdapterConfig(config, adapter);
        var normalized = readString(action);
        if (normalized === 'getConfig') {
            post('getConfig', body || {});
            if (adapter === 'vivagames_v1') {
                notifyVivaGames('getConfig', config);
            }
            return config;
        }
        if (normalized === 'getLaunchPayload') {
            post('getLaunchPayload', body || {});
            return payload;
        }
        post(normalized || 'NativeBridge', body || {});
        if (adapter === 'vivagames_v1') {
            notifyVivaGames(normalized || 'NativeBridge', body || {});
        }
        return null;
    }

    function installNativeBridge() {
        var config = launchConfig();
        var payload = launchPayload();
        var entry = launchEntry();
        var adapter = detectAdapter(config, payload);
        config = normalizeAdapterConfig(config, adapter);
        var nativeBridge = window.NativeBridge || {};
        var oldPostMessage =
            typeof nativeBridge.postMessage === 'function'
                ? nativeBridge.postMessage.bind(nativeBridge)
                : null;

        window.__hyappRemoteGameBridge = {
            adapter: adapter,
            version: remoteBridgeVersion,
            installedAt: Date.now(),
        };
        window.hyappGameLaunchPayload = payload;
        window.hyappGameLaunchConfig = config;
        window.hyappGameEntry = entry;
        window.__baishunLastConfig = config;
        window.baishunBridgeConfig = config;
        window.leaderLaunchPayload = payload;
        window.leaderLaunchConfig = config;
        window.leaderLaunchEntry = entry;

        nativeBridge.config = config;
        nativeBridge.launchConfig = config;
        nativeBridge.entry = entry;
        nativeBridge.launchPayload = payload;
        nativeBridge.getConfigSync = function () {
            return launchConfig();
        };
        nativeBridge.getLaunchPayloadSync = function () {
            return launchPayload();
        };
        nativeBridge.postMessage = function (body) {
            if (oldPostMessage) {
                oldPostMessage(
                    typeof body === 'string' ? body : stringifyParams(body)
                );
                return;
            }
            callNativeBridge('NativeBridge', body);
        };
        nativeBridge.getConfig = function (bodyOrCallback) {
            var currentConfig = launchConfig();
            if (typeof bodyOrCallback === 'function') {
                safeCall(bodyOrCallback, [currentConfig, launchPayload()]);
            }
            callNativeBridge('getConfig', bodyOrCallback || {});
            return currentConfig;
        };
        nativeBridge.getLaunchPayload = function (bodyOrCallback) {
            var currentPayload = launchPayload();
            if (typeof bodyOrCallback === 'function') {
                safeCall(bodyOrCallback, [currentPayload]);
            }
            callNativeBridge('getLaunchPayload', bodyOrCallback || {});
            return currentPayload;
        };
        nativeBridge.destroy = function (body) {
            callNativeBridge('destroy', body || {});
        };
        nativeBridge.closeGame = function (body) {
            callNativeBridge('closeGame', body || {});
        };
        nativeBridge.gameStart = function (body) {
            callNativeBridge('gameStart', body || {});
        };
        nativeBridge.gameLoading = function (body) {
            callNativeBridge('gameLoading', body || {});
        };
        nativeBridge.gameLoaded = function (body) {
            callNativeBridge('gameLoaded', body || {});
        };
        nativeBridge.loadComplete = function (body) {
            callNativeBridge('loadComplete', body || {});
        };
        nativeBridge.gameRecharge = function (body) {
            callNativeBridge('gameRecharge', body || {});
        };
        nativeBridge.pay = function (body) {
            callNativeBridge('pay', body || {});
        };
        nativeBridge.copyText = function (body) {
            callNativeBridge('copyText', body || {});
        };
        nativeBridge.refreshBalance = function (body) {
            callNativeBridge('refreshBalance', body || {});
        };
        nativeBridge.refreshBlance = function (body) {
            callNativeBridge('refreshBalance', body || {});
        };
        nativeBridge.debugLog = function (body) {
            callNativeBridge('debugLog', body || {});
        };
        installReyouBridgeAliases(nativeBridge);
        installYomiBridgeAliases(nativeBridge);
        window.NativeBridge = nativeBridge;

        [
            ['getConfig', 'getConfig'],
            ['destroy', 'destroy'],
            ['closeGame', 'closeGame'],
            ['hideSplash', 'hideSplash'],
            ['insufficient', 'insufficient'],
            ['gameStart', 'gameStart'],
            ['gameLoading', 'gameLoading'],
            ['gameLoaded', 'gameLoaded'],
            ['loadComplete', 'loadComplete'],
            ['gameRecharge', 'gameRecharge'],
            ['pay', 'pay'],
            ['copyText', 'copyText'],
            ['refreshBalance', 'refreshBalance'],
            ['refreshBlance', 'refreshBalance'],
            ['debugLog', 'debugLog'],
        ].forEach(function (item) {
            installAlias(item[0], item[1]);
        });

        if (adapter === 'vivagames_v1') {
            safeCall(window.OnCallGame, ['getConfig', config]);
        }
        signalReady(config, payload);
    }

    function signalReady(config, payload) {
        [
            ['hyappGameBridgeReady', payload],
            ['hyappRemoteGameBridgeReady', window.__hyappRemoteGameBridge],
            ['baishunBridgeReady', config],
            ['leaderLaunchConfig', payload],
            ['launchConfig', config],
        ].forEach(function (item) {
            try {
                window.dispatchEvent(
                    new CustomEvent(item[0], { detail: item[1] })
                );
                if (document && document.dispatchEvent) {
                    document.dispatchEvent(
                        new CustomEvent(item[0], { detail: item[1] })
                    );
                }
            } catch (_) {}
        });
    }

    window.HYAppGameBridge = window.HYAppGameBridge || {};
    window.HYAppGameBridge.install = installNativeBridge;
    window.HYAppGameBridge.version = remoteBridgeVersion;
    installNativeBridge();
})();