// Run with TYPESCRIPT_PATH pointing to typescript/lib/typescript.js if it is not installed locally.
const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const vm = require('node:vm');
const ts = require(process.env.TYPESCRIPT_PATH || 'typescript');
const root = path.resolve(__dirname, '..');
const readJSON = file => JSON.parse(fs.readFileSync(path.join(root, file), 'utf8').replace(/^\uFEFF/, ''));
const level = n => readJSON(`assets/custom/Json/level${n}.json`);
const atlasPaths = ['BlockBtnUI', 'door', 'down'];
const imagePaths = fs.readdirSync(path.join(root, 'assets/Block')).filter(n => n.endsWith('.png'))
    .map(n => n.slice(0, -4)).sort();
const filePaths = imagePaths.concat(atlasPaths.map(name => name + '.plist')).sort();
const sorted = values => [...new Set(values)].sort();
const tick = () => new Promise(resolve => setImmediate(resolve));

// Parse the real XML independently with Python's standard library, so stale Cocos
// .meta files cannot make the runtime layout tests pass against the wrong atlas.
const plistFixtures = JSON.parse(require('node:child_process').execFileSync(process.env.PYTHON || 'python', [
    '-c', 'import json,plistlib,sys,pathlib; print(json.dumps({pathlib.Path(p).stem:plistlib.loads(pathlib.Path(p).read_bytes()) for p in sys.argv[1:]}))',
    ...atlasPaths.map(name => path.join(root, 'assets/Block', name + '.plist'))
], { encoding: 'utf8' }));
const atlasPlistFixture = name => JSON.parse(JSON.stringify(plistFixtures[name]));

async function waitFor(check, message) {
    for (let i = 0; i < 1000 && !check(); i++) await tick();
    assert.ok(check(), message);
}

function releaseHeldDownloads(state) {
    state.hold.clear();
    for (const [key, finish] of [...state.deferred]) if (key.startsWith('download:')) finish();
}

function fireTimer(state, delay) {
    const timers = [...state.timers.entries()].filter(([, timer]) => timer.delay === delay);
    assert.equal(timers.length, 1, `expected one ${delay}ms timer`);
    const [id, timer] = timers[0];
    state.timers.delete(id);
    timer.cb();
}

function fixture(previous) {
    const state = {
        loads: [], plistLoads: [], jsonLoads: [], downloads: 0, releases: [], scenes: [], errors: [], loadingEvents: [], mapsInitialized: 0,
        bundleLoads: [], requests: [], logs: [], consoleLogs: [], gameListeners: [], sceneListeners: [], timers: new Map(), requestAborts: 0,
        fileRequests: [], activeDownloads: new Set(), maxActiveDownloads: 0,
        directRequests: [], directories: new Set(['http://usr']), cacheWrites: 0,
        manifest: { statusCode: 200, data: { version: '1.0.0' } }, manifestError: null,
        plists: new Map(atlasPaths.map(name => [name, atlasPlistFixture(name)])), textures: new Map(), mkdirCalls: [], mkdirError: null, offline: false,
        fail: new Set(), badJson: new Set(), deferred: new Map(), hold: new Set(), disk: new Map(), caches: new Map(), temps: new Map(),
        nativeFiles: new Map(), storage: new Map(), assets: new Map(), save: true, scene: { name: 'HomeScene' }
    };
    if (previous) {
        for (const key of ['disk', 'caches', 'storage', 'downloads', 'directories']) state[key] = previous[key];
    }
    const cache = {
        getCache: url => state.caches.get(url) || '',
        getTemp: url => state.temps.get(url) || '',
        tempFiles: { remove: url => state.temps.delete(url) },
        removeCache: url => state.caches.delete(url),
        cacheFile(url, temp) {
            state.cacheWrites++;
            if (!state.save || !state.disk.has(temp)) return;
            const local = 'saved/' + url;
            state.disk.set(local, state.disk.get(temp));
            state.caches.set(url, local);
        }
    };
    const stats = filename => {
        if (state.directories.has(filename)) {
            return { size: 0, isFile: () => false, isDirectory: () => true };
        }
        if (!state.disk.has(filename)) throw new Error('ENOENT');
        return { size: 12, isFile: () => true, isDirectory: () => false };
    };
    function requestManifest(options) {
        state.requests.push(options);
        const finish = () => state.manifestError || state.offline
            ? options.fail(state.manifestError || new Error('offline')) : options.success(state.manifest);
        if (state.hold.has('version')) state.deferred.set('version', finish);
        else queueMicrotask(finish);
        return { abort() { state.requestAborts++; } };
    }
    const fsManager = {
        statSync: stats,
        readFileSync: file => state.disk.get(file),
        mkdirSync(directory) {
            state.mkdirCalls.push(directory);
            if (state.mkdirError) throw state.mkdirError;
            if (state.disk.has(directory)) throw new Error('mkdirSync:fail file already exists ' + directory);
            if (state.directories.has(directory)) throw new Error('mkdirSync:fail file already exists ' + directory);
            state.directories.add(directory);
        },
        unlinkSync(file) {
            if (!state.disk.delete(file)) throw new Error('unlinkSync:fail no such file ' + file);
        },
        renameSync(source, target) {
            if (!state.disk.has(source)) throw new Error('renameSync:fail no such file ' + source);
            state.disk.set(target, state.disk.get(source));
            state.disk.delete(source);
        },
        copyFile(options) {
            queueMicrotask(() => {
                if (!state.save || !state.disk.has(options.srcPath)) return options.fail(new Error('copyFile:fail'));
                state.disk.set(options.destPath, state.disk.get(options.srcPath));
                options.success();
            });
        }
    };
    const remoteName = remote => {
        const match = String(remote).match(/([^/]+)\.(png|plist)(?:\?|$)/);
        return match ? match[1] + (match[2] === 'plist' ? '.plist' : '') : '';
    };
    const wx = {
        env: { USER_DATA_PATH: 'http://usr' },
        getFileSystemManager: () => fsManager,
        request: requestManifest,
        downloadFile(options) {
            const name = remoteName(options.url);
            state.directRequests.push({ name, url: options.url, filePath: options.filePath });
            state.fileRequests.push(name);
            state.activeDownloads.add(name);
            state.maxActiveDownloads = Math.max(state.maxActiveDownloads, state.activeDownloads.size);
            const key = 'download:' + name;
            const finish = () => {
                state.deferred.delete(key);
                state.activeDownloads.delete(name);
                if (state.offline || state.fail.has(name) || !state.save) {
                    options.fail(new Error(state.save ? 'network error' : 'storage full'));
                    return;
                }
                state.downloads++;
                state.disk.set(options.filePath, name.endsWith('.plist') ? JSON.stringify(state.plists.get(name.slice(0, -6))) : 'valid');
                options.success({ statusCode: 200, filePath: options.filePath });
            };
            if (state.hold.has(key)) state.deferred.set(key, finish);
            else queueMicrotask(finish);
            return { abort() {} };
        }
    };
    const tt = {};
    let timerId = 0;
    class Texture2D {
        constructor(name, url) {
            this.name = name; this.url = url; this.packable = true; this.refs = 0;
            const png = fs.readFileSync(path.join(root, 'assets/Block', name + '.png'));
            this.width = png.readUInt32BE(16); this.height = png.readUInt32BE(20);
        }
        addRef() { this.refs++; }
        decRef() {
            assert.ok(this.refs > 0, 'reference must be owned before releasing');
            if (--this.refs === 0) {
                this.destroyed = true;
                state.releases.push(this.name);
                state.textures.delete(this.url);
            }
        }
    }
    class SpriteFrame {
        constructor(texture, rect, rotated, offset, originalSize) {
            this.texture = texture; this.rect = rect; this.rotated = rotated;
            this.offset = offset; this.originalSize = originalSize;
            this.insetTop = this.insetBottom = this.insetLeft = this.insetRight = 0;
            state.assets.set(texture.name, this);
        }
        getTexture() { return this.texture; }
        destroy() {
            assert.ok(!this.destroyed, 'dynamic frame must be destroyed only once');
            this.destroyed = true;
            state.assets.delete(this.name);
        }
    }
    function createScene(name) {
        const scene = { name, loading: false };
        scene.controller = {
            openLoad() { scene.loading = true; state.loadingEvents.push(name + ':open'); },
            closeLoad() { scene.loading = false; state.loadingEvents.push(name + ':close'); }
        };
        scene.canvas = { getComponent: type => type === (name === 'HomeScene' ? 'JiaZai' : 'SceneManager') ? scene.controller : null };
        return scene;
    }
    state.scene = createScene('HomeScene');
    const cc = {
        SpriteFrame, Texture2D, JsonAsset: class {}, Component: class {},
        Director: { EVENT_AFTER_SCENE_LAUNCH: 'after-scene-launch' },
        rect: (x, y, width, height) => ({ x, y, width, height }),
        v2: (x, y) => ({ x, y }), size: (width, height) => ({ width, height }),
        find: () => state.scene.canvas || null,
        isValid: object => !!object && !object.destroyed,
        _decorator: { ccclass: value => typeof value === 'function' ? value : type => type, property: () => {} },
        debug: { DebugMode: { INFO: 1, ERROR: 3 } },
        game: { config: { debugMode: 1 }, EVENT_SHOW: 'show',
            on: (event, callback, target) => state.gameListeners.push({ event, callback, target }),
            off: (event, callback, target) => {
                state.gameListeners = state.gameListeners.filter(item =>
                    item.event !== event || item.callback !== callback || item.target !== target);
            },
            emit: (event, payload) => state.gameListeners.filter(item => item.event === event)
                .forEach(({ callback, target }) => callback.call(target, payload)) },
        log: (...args) => state.logs.push(args), warn() {}, error() {}, fx: { GameConfig: {
            BLOCK_IMAGE_BASE_URL: 'https://cdn.test/remote/Block/', BLOCK_IMAGE_VERSION: '1.0.0'
        } },
        sys: { OS_IOS: 'iOS', OS_ANDROID: 'Android',
            localStorage: { getItem: key => state.storage.get(key), setItem: (key, value) => state.storage.set(key, value) } },
        director: {
            on: (event, callback, target) => state.sceneListeners.push({ event, callback, target }),
            off: (event, callback, target) => {
                state.sceneListeners = state.sceneListeners.filter(item =>
                    item.event !== event || item.callback !== callback || item.target !== target);
            },
            getScene: () => state.scene,
            preloadScene: (name, cb) => queueMicrotask(() => cb(null)),
            loadScene: name => {
                state.scenes.push(name);
                if (state.scene.controller) state.scene.controller.destroyed = true;
                state.scene = createScene(name);
                state.sceneListeners.forEach(({ callback, target }) => callback.call(target));
            }
        }
    };
    const customBundle = {
        getInfoWithPath(name) { return fs.existsSync(path.join(root, 'assets/custom', name + '.json')) ? { path: name } : null; },
        load(name, type, cb) {
            state.jsonLoads.push(name);
            const finish = () => state.fail.has(name) ? cb(new Error('JSON download failed'))
                : cb(null, { json: state.badJson.has(name) ? {} : readJSON('assets/custom/' + name + '.json') });
            if (state.hold.has(name)) state.deferred.set(name, finish);
            else queueMicrotask(finish);
        }
    };
    const url = (name, version = '1.0.0') => `https://cdn.test/remote/Block/${name.endsWith('.plist') ? name : name + '.png'}?v=${version}`;
    const userFile = (name, version = '1.0.0') => `http://usr/Block/${version}/${name.endsWith('.plist') ? name : name + '.png'}`;
    const imageName = remote => remoteName(remote);
    const download = (remote, reload) => {
        let file = !reload && (state.nativeFiles.get(remote + '@native') || cache.getCache(remote) || cache.getTemp(remote));
        if (file && !state.disk.has(file)) throw new Error('missing local file');
        if (!file) {
            if (state.offline || state.fail.has(imageName(remote))) throw new Error('network error');
            state.downloads++;
            file = 'temp/' + state.downloads;
            state.disk.set(file, imageName(remote).endsWith('.plist') ? JSON.stringify(state.plists.get(imageName(remote).slice(0, -6))) : 'valid');
            state.temps.set(remote, file);
            cache.cacheFile(remote, file);
        }
        state.nativeFiles.set(remote + '@native', file);
        return file;
    };
    const downloading = new Map();
    const requestFile = (remote, reload, cb) => {
        if (downloading.has(remote)) { downloading.get(remote).push(cb); return; }
        const callbacks = [cb];
        downloading.set(remote, callbacks);
        state.fileRequests.push(imageName(remote));
        state.activeDownloads.add(imageName(remote));
        state.maxActiveDownloads = Math.max(state.maxActiveDownloads, state.activeDownloads.size);
        const finish = () => {
            let error, file;
            try { file = download(remote, reload); } catch (err) { error = err; }
            downloading.delete(remote);
            state.activeDownloads.delete(imageName(remote));
            state.deferred.delete(key);
            callbacks.forEach(callback => callback(error, file));
        };
        const key = 'download:' + imageName(remote);
        if (state.hold.has(key)) state.deferred.set(key, finish);
        else finish();
    };
    const requestNative = (remote, options, cb) => requestFile(remote, options.reload, cb);
    cc.assetManager = {
        getBundle: () => null,
        releaseAsset(asset) {
            asset.destroyed = true;
            if (asset instanceof Texture2D) state.textures.delete(asset.url);
        },
        cacheManager: cache,
        downloader: {
            // Deliberately no bundleVers/remoteServerAddress: raw PNGs do not depend on a build.
            maxRetryCount: 3, maxConcurrency: 8,
            downloadFile(remote, options, progress, cb) {
                return requestManifest({ url: remote, ...options,
                    success: response => cb(response.statusCode === 200 ? null : new Error('HTTP error'), response.data),
                    fail: error => cb(error)
                });
            }
        },
        _files: { get: key => state.nativeFiles.get(key), remove: key => state.nativeFiles.delete(key) }, _parsed: { remove() {} },
        loadBundle: (name, options, cb) => queueMicrotask(() => {
            state.bundleLoads.push(name);
            assert.notEqual(name, 'Block', 'Block must not use any Cocos build artifacts');
            (cb || options)(null, customBundle);
        }),
        loadRemote(remote, options, cb) {
            const cachedUrl = [...state.caches, ...state.temps].find(([, file]) => file === remote)?.[0];
            const nativeKey = [...state.nativeFiles].find(([, file]) => file === remote)?.[0];
            const name = imageName(cachedUrl || (nativeKey && nativeKey.replace(/@native$/, '')) || remote);
            (name.endsWith('.plist') ? state.plistLoads : state.loads).push({ name, url: remote, reload: options.reload });
            const consume = (error, file) => {
                try {
                    if (error) throw error;
                    if (state.disk.get(file) === 'corrupt') throw new Error('decode error');
                    if (name.endsWith('.plist')) {
                        cb(null, { _nativeAsset: JSON.parse(state.disk.get(file)), name });
                        return;
                    }
                    const texture = state.textures.get(remote) || new Texture2D(name, remote);
                    state.textures.set(remote, texture);
                    cb(null, texture);
                } catch (error) { cb(error); }
            };
            const finish = () => state.disk.has(remote) ? consume(null, remote)
                : requestNative(remote, options, consume);
            const key = options.reload && state.hold.has(name + ':retry') ? name + ':retry' : name;
            if (state.hold.has(key)) state.deferred.set(key, finish);
            else queueMicrotask(finish);
        }
    };
    const modules = new Map();
    function load(file) {
        const absolute = path.resolve(root, file);
        if (modules.has(absolute)) return modules.get(absolute).exports;
        const mod = { exports: {} };
        modules.set(absolute, mod);
        const source = fs.readFileSync(absolute, 'utf8');
        const output = ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2017, module: ts.ModuleKind.CommonJS, experimentalDecorators: true } }).outputText;
        vm.runInNewContext(output, {
            module: mod, exports: mod.exports, cc,
            wx, tt,
            console: { log: (...args) => { state.consoleLogs.push(args); state.logs.push(args); }, warn() {}, error() {} }, window: {},
            setTimeout: (cb, delay) => {
                const id = ++timerId;
                if (delay < 1000) queueMicrotask(cb);
                else state.timers.set(id, { cb, delay });
                return id;
            },
            clearTimeout: id => state.timers.delete(id),
            require(request) {
                const target = path.resolve(path.dirname(absolute), request) + '.ts';
                if (['BlockTexturePaths.ts', 'GameplayAtlasFrames.ts', 'BlockAssetManager.ts', 'GameConfig.ts', 'GameTool.ts', 'Map.ts'].includes(path.basename(target))) return load(target);
                return { MiniGameSdk: { API: {} }, default: {} };
            }
        }, { filename: absolute });
        return mod.exports;
    }
    const Manager = load('assets/Script/module/Tool/BlockAssetManager.ts').default;
    const pathsModule = load('assets/Script/module/Tool/BlockTexturePaths.ts');
    const collect = pathsModule.collectBlockTexturePaths;
    function config() {
        const Config = load('assets/Script/module/Config/GameConfig.ts').GameConfig;
        cc.fx.GameConfig = Config;
        Config.BLOCK_IMAGE_BASE_URL = 'https://cdn.test/remote/Block/';
        cc.fx.GameTool = load('assets/Script/module/Tool/GameTool.ts').GameTool;
        Config.GM_INFO = { level: 49, otherLevel: 0, GameplayType: 0 };
        Config.showBlockLoadError = (error, retry) => state.errors.push({ error, retry });
        return Config;
    }
    function map() {
        const MapController = load('assets/Script/Map.ts').default;
        return Object.assign(Object.create(MapController.prototype), {
            blockAssetsReady: false,
            initMap() { state.mapsInitialized++; },
            showEnterNewModeIfNeeded() {}
        });
    }
    return { state, cc, wx, tt, Manager, manager: Manager.instance, collect, pathsModule, config, cache, url, userFile, createScene, map, load };
}

test('home warmup cannot cancel entry when its level JSON arrives late', async () => {
    const { config, cc, state } = fixture();
    const Config = config();
    cc.fx.GameTool.shouldPreloadGameplayPopupInstances = () => true;
    cc.fx.GameTool.areGameplayPopupSubpackagesDownloaded = () => true;
    cc.fx.GameTool.ensureGameplayPopupSubpackagesDownloaded = () => Promise.resolve(true);
    cc.fx.GameTool.warmupHomeGameplayPopupAssets = () => Promise.resolve(true);
    state.scene.controller.playGameEntryTransition = force => assert.equal(force, true);
    Config.applyLevelData(level(50), false, 0, 50);
    state.hold.add('Json/level50');
    state.hold.add('door');
    const warmup = Config.warmupHomeBlockAssets();
    await waitFor(() => state.deferred.has('Json/level50'), 'home level JSON is pending');
    Config.enterGameSceneWhenReady();
    await waitFor(() => state.deferred.has('door'), 'entry atlas decode is pending');
    state.deferred.get('Json/level50')();
    await tick();
    state.deferred.get('door')();
    await warmup;
    await waitFor(() => [...state.timers.values()].some(timer => timer.delay === 1000), 'first entry transition is ready');
    assert.deepEqual(state.scenes, [], 'scene launch waits for the transition');
    fireTimer(state, 1000);
    await waitFor(() => state.scenes.length > 0, 'formal entry must still launch GameScene');
    assert.deepEqual(state.scenes, ['GameScene']);
    assert.equal(state.errors.length, 0);
});

test('home warmup preserves a prepared entry until transition and resumes after returning home', async () => {
    const { manager, cc } = fixture();
    const current = [{ block: 0, color: 1 }];
    const other = [{ block: 1, color: 2 }];
    assert.equal(await manager.prepareWindow(current), true);
    const frame = manager.getFrame('1color0');
    assert.equal(await manager.prepareWindow(other, { homeWarmup: true }), false);
    assert.equal(manager.getFrame('1color0'), frame, 'prepared entry texture must remain valid');
    cc.director.loadScene('GameScene');
    manager.activateScene(current);
    manager.releaseScene();
    cc.director.loadScene('HomeScene');
    assert.equal(await manager.prepareWindow(other, { homeWarmup: true }), true);
    assert.ok(manager.getFrame('2color1'));
});

test('home warmup yields to a later formal entry and shares pending atlas loads', async () => {
    const { manager, state, cc } = fixture();
    state.hold.add('door');
    const warmup = manager.prepareWindow([{ block: 0, color: 1 }],
        { homeWarmup: true, extraPaths: atlasPaths });
    await waitFor(() => state.deferred.has('door'), 'warmup atlas decode is pending');
    const current = [{ block: 1, color: 2 }];
    const entry = manager.prepareWindow(current, { extraPaths: atlasPaths });
    state.deferred.get('door')();
    assert.equal(await warmup, false);
    assert.equal(await entry, true);
    cc.director.loadScene('GameScene');
    manager.activateScene(current, atlasPaths);
    assert.ok(manager.getFrame('2color1'));
    assert.equal(state.plistLoads.filter(load => load.name === 'door.plist').length, 1);
});

test('remote atlases preserve every imported frame and release shared textures once', async () => {
    const { manager, state, cc } = fixture();
    await manager.prepareWindow([], { extraPaths: atlasPaths });
    assert.equal(state.downloads, 6);
    manager.activateScene([], atlasPaths);
    const children = [];
    for (const atlas of atlasPaths) {
        const plist = atlasPlistFixture(atlas);
        const numbers = value => value.match(/-?\d+(?:\.\d+)?/g).map(Number);
        for (const [filename, data] of Object.entries(plist.frames)) {
            const name = filename.replace(/\.png$/, '');
            const frame = manager.getAtlasFrame(atlas, name);
            children.push(frame);
            assert.equal(frame, manager.getAtlasFrame(atlas, name));
            assert.equal(frame.getTexture(), manager.getFrame(atlas).getTexture());
            const [x, y, width, height] = numbers(data.frame);
            assert.deepEqual({ ...frame.rect }, { x, y, width, height });
            assert.equal(frame.rotated, data.rotated);
            assert.deepEqual([frame.offset.x, frame.offset.y], numbers(data.offset));
            assert.deepEqual([frame.originalSize.width, frame.originalSize.height], numbers(data.sourceSize));
            assert.deepEqual([frame.insetTop, frame.insetBottom, frame.insetLeft, frame.insetRight],
                atlas === 'door' && name === 'turn_bg' ? [0, 0, 30, 30] : [0, 0, 0, 0]);
        }
        assert.equal(manager.getFrame(atlas).getTexture().refs, 1);
    }
    manager.releaseScene();
    assert.ok(children.every(frame => !frame.destroyed), 'GameScene destruction keeps common frames');
    cc.director.loadScene('HomeScene');
    assert.ok(children.every(frame => frame.destroyed));
    assert.deepEqual(state.releases.sort(), atlasPaths.slice().sort());
    assert.deepEqual([...manager.getLoadedPaths()], []);
});

test('remote atlases gate gameplay, retry failure, and reuse cache offline', async () => {
    const { manager, state, userFile, config, map } = fixture();
    const Config = config();
    Config.applyLevelData(level(50), false, 0, 50);
    let loading = 0;
    state.fail.add('door');
    await assert.rejects(Config.prepareBlockWindow(() => loading++));
    assert.ok(loading > 0);
    state.fail.clear();
    assert.equal(await Config.prepareBlockWindow(), true);
    assert.ok(atlasPaths.every(name => state.disk.has(userFile(name))));
    await map().prepareBlockAssets();
    assert.equal(state.mapsInitialized, 1);
    const before = state.downloads;
    manager.releaseScene();
    state.offline = true;
    assert.equal(await Config.prepareBlockWindow(() => assert.fail('cache should not show loading')), true);
    assert.equal(state.downloads, before);
    assert.ok(atlasPaths.every(name => manager.getFrame(name)));
});

test('remote atlases finish loading before any block texture enters memory', async () => {
    const { manager, state } = fixture();
    state.hold.add('door');
    const ready = manager.prepareWindow([{ block: 0, color: 1 }], { extraPaths: atlasPaths });
    await waitFor(() => state.deferred.has('door'), 'door decode is pending');
    assert.deepEqual(state.loads.map(load => load.name).sort(), atlasPaths.slice().sort());
    assert.ok(!state.fileRequests.includes('1color0'));
    state.deferred.get('door')();
    assert.equal(await ready, true);
    assert.equal(state.loads[state.loads.length - 1].name, '1color0');
});

test('remote atlases apply the 5000 MB boundary only to iOS', async () => {
    const { manager, state, cc, wx, config } = fixture();
    config();
    const gameTool = cc.fx.GameTool;
    const cases = [
        ['ios', 4096, false], ['ios', 4999, false], ['ios', 5000, true], ['ios', 8192, true],
        ['ios', undefined, false], ['ios', 0, false], ['ios', 'invalid', false], ['ios', Infinity, false],
        ['android', 2048, true], ['android', undefined, true], ['android', 8192, true],
        ['devtools', 8192, false]
    ];
    for (const [platform, memorySize, retain] of cases) {
        wx.getDeviceInfo = () => ({ platform, memorySize });
        assert.equal(gameTool.shouldRetainGameplayAtlasesOnHome(), retain, `${platform}/${memorySize}`);
        await manager.prepareWindow([], { extraPaths: atlasPaths });
        cc.director.loadScene('GameScene');
        manager.activateScene([], atlasPaths);
        const original = manager.getFrame('door');
        manager.releaseScene();
        cc.director.loadScene('HomeScene');
        assert.equal(!original.destroyed, retain, `HomeScene: ${platform}/${memorySize}`);
        if (retain) {
            const loads = state.loads.length;
            await manager.prepareWindow([], { extraPaths: atlasPaths });
            assert.equal(state.loads.length, loads);
            assert.equal(manager.getFrame('door'), original);
        }
    }
    wx.getDeviceInfo = () => ({ memorySize: 8192 });
    cc.sys.os = cc.sys.OS_ANDROID;
    assert.equal(gameTool.shouldRetainGameplayAtlasesOnHome(), true);
    cc.sys.os = cc.sys.OS_IOS;
    assert.equal(gameTool.shouldRetainGameplayAtlasesOnHome(), true);
    wx.getDeviceInfo = () => { throw new Error('device info unavailable'); };
    assert.equal(gameTool.shouldRetainGameplayAtlasesOnHome(), false);
});

test('remote atlases low-memory iOS warnings preserve active and pending gameplay, then release at home', async () => {
    const { manager, cc, wx, config } = fixture();
    config();
    const gameTool = cc.fx.GameTool;
    cc.sys.WECHAT_GAME = cc.sys.platform = 'wechat';
    wx.getDeviceInfo = () => ({ platform: 'ios', memorySize: 4096 });
    await manager.prepareWindow([], { extraPaths: atlasPaths });
    cc.director.loadScene('GameScene');
    manager.activateScene([], atlasPaths);
    const frame = manager.getFrame('door');
    gameTool.handleMemoryWarning();
    assert.equal(gameTool.isLowMemoryMode(), true);
    assert.ok(!frame.destroyed);
    manager.releaseScene();
    cc.director.loadScene('HomeScene');
    assert.ok(frame.destroyed);

    gameTool._lowMemoryMode = false;
    await manager.prepareWindow([], { extraPaths: atlasPaths });
    const pending = manager.getFrame('door');
    gameTool.handleMemoryWarning();
    assert.equal(gameTool.isLowMemoryMode(), true);
    assert.equal(gameTool._memoryWarningCount, 2);
    assert.ok(!pending.destroyed, 'warning preserves textures prepared for the next game');
});

test('Android and high-memory iOS warnings leave state, resources and GC untouched', async () => {
    const { manager, state, cc, wx, config } = fixture();
    config();
    cc.sys.WECHAT_GAME = cc.sys.platform = 'wechat';
    const gameTool = cc.fx.GameTool;
    let events = 0, cleanups = 0, gcCalls = 0;
    cc.game.on(gameTool.MEMORY_WARNING_EVENT, () => events++);
    gameTool.releaseHomeGameplayPopupWarmup = () => cleanups++;
    wx.triggerGC = () => gcCalls++;
    for (const [platform, memorySize] of [
        ['android', 2048], ['android', 8192], ['android', undefined],
        ['ios', 5000], ['ios', 8192]
    ]) {
        wx.getDeviceInfo = () => ({ platform, memorySize });
        await manager.prepareWindow([], { extraPaths: atlasPaths });
        cc.director.loadScene('HomeScene');
        const frame = manager.getFrame('door');
        const timers = state.timers.size;
        gameTool.handleMemoryWarning({ level: 10 });
        gameTool.handleMemoryWarning({ level: 15 });
        assert.equal(gameTool.isLowMemoryMode(), false, `${platform}/${memorySize}`);
        assert.equal(gameTool._memoryWarningCount, 0);
        assert.equal(events, 0);
        assert.equal(cleanups, 0);
        assert.equal(gcCalls, 0);
        assert.equal(state.timers.size, timers);
        assert.ok(!frame.destroyed);
        cc.director.loadScene('HomeScene');
        assert.equal(manager.getFrame('door'), frame);
    }
});

test('remote atlases stay identical across GameScene replay and next level, then release on HomeScene', async () => {
    const { manager, state, cc, userFile } = fixture();
    const first = [{ block: 0, color: 1 }], next = [{ block: 1, color: 2 }];
    const options = { extraPaths: atlasPaths };
    await manager.prepareWindow(first, options);
    cc.director.loadScene('GameScene');
    manager.activateScene(first, atlasPaths);
    const original = atlasPaths.map(name => manager.getFrame(name));
    const child = manager.getAtlasFrame('door', 'wall1');
    // 重玩先销毁旧场景，再准备新场景。
    manager.releaseScene();
    cc.director.loadScene('GameScene');
    await manager.prepareWindow(first, options);
    manager.activateScene(first, atlasPaths);
    // 下一关先准备，随后销毁旧场景。
    await manager.prepareWindow(next, options);
    manager.releaseScene();
    cc.director.loadScene('GameScene');
    manager.activateScene(next, atlasPaths);
    atlasPaths.forEach((name, index) => assert.equal(manager.getFrame(name), original[index]));
    assert.equal(manager.getAtlasFrame('door', 'wall1'), child);
    assert.equal(state.loads.filter(load => atlasPaths.includes(load.name)).length, 3);
    assert.ok(!state.releases.some(name => atlasPaths.includes(name)));
    manager.releaseScene();
    cc.director.loadScene('HomeScene');
    assert.ok(child.destroyed);
    assert.ok(original.every(frame => frame.destroyed));
    assert.deepEqual([...manager.getLoadedPaths()], []);
    assert.ok(atlasPaths.every(name => state.disk.has(userFile(name))), 'disk cache survives returning home');
    const downloads = state.downloads;
    await manager.prepareWindow(next, options);
    assert.equal(state.downloads, downloads);
    atlasPaths.forEach((name, index) => assert.notEqual(manager.getFrame(name), original[index]));
    assert.equal(state.sceneListeners.length, 1);
});

test('remote atlases returning home cancels in-flight entry and frees late textures', async () => {
    const { manager, state, cc } = fixture();
    state.hold.add('door');
    const ready = manager.prepareWindow([{ block: 0, color: 1 }], { extraPaths: atlasPaths });
    await waitFor(() => state.deferred.has('door'), 'door decode is pending');
    cc.director.loadScene('HomeScene');
    assert.deepEqual([...manager.getLoadedPaths()], []);
    state.deferred.get('door')();
    assert.equal(await ready, false);
    assert.deepEqual([...manager.getLoadedPaths()], []);
    assert.ok(!state.fileRequests.includes('1color0'));
    assert.deepEqual(state.releases.sort(), atlasPaths.slice().sort());
});

test('remote atlases background cache completes the three PNGs before downloading blocks', async () => {
    const { manager, state } = fixture();
    state.hold.add('download:door');
    manager.startBackgroundCache();
    await waitFor(() => state.deferred.has('download:door'), 'background door download is pending');
    await tick();
    assert.deepEqual(state.fileRequests.slice().sort(), atlasPaths.concat(atlasPaths.map(name => name + '.plist')).sort());
    assert.equal(state.loads.length, 0, 'background caching must not decode textures');
    state.hold.clear();
    state.deferred.get('download:door')();
    await waitFor(() => !manager.backgroundRunning, 'background cache completes');
    assert.deepEqual(state.fileRequests.slice(0, 6).sort(), atlasPaths.concat(atlasPaths.map(name => name + '.plist')).sort());
    assert.equal(state.downloads, filePaths.length);
    assert.equal(state.loads.length, 0);
});

test('remote atlases use new-version plist coordinates and new frame names without compiled layout data', async () => {
    const first = fixture();
    await first.manager.prepareWindow([], { extraPaths: ['door'] });
    const old = first.manager.getAtlasFrame('door', 'wall1');
    const updated = fixture(first.state);
    updated.state.manifest.data.version = '1.0.1';
    const plist = updated.state.plists.get('door');
    plist.frames['wall1.png'] = {
        frame: '{{10,20},{50,30}}', offset: '{2,-3}', sourceSize: '{60,40}', rotated: true
    };
    plist.frames['remote_only.png'] = {
        frame: '{{100,200},{20,40}}', offset: '{0,0}', sourceSize: '{20,40}', rotated: false
    };
    await updated.manager.prepareWindow([], { extraPaths: ['door'] });
    const frame = updated.manager.getAtlasFrame('door', 'wall1');
    assert.notDeepEqual({ ...frame.rect }, { ...old.rect });
    assert.deepEqual({ ...frame.rect }, { x: 10, y: 20, width: 50, height: 30 });
    assert.equal(frame.rotated, true);
    assert.deepEqual({ ...frame.offset }, { x: 2, y: -3 });
    assert.ok(updated.manager.getAtlasFrame('door', 'remote_only'));
    assert.deepEqual(updated.state.directRequests.map(request => request.url),
        [updated.url('door.plist', '1.0.1'), updated.url('door', '1.0.1')]);
    assert.ok(updated.state.disk.has(updated.userFile('door.plist', '1.0.1')));
    const offline = fixture(updated.state);
    offline.state.offline = true;
    const downloads = offline.state.downloads;
    await offline.manager.prepareWindow([], { extraPaths: ['door'] });
    assert.equal(offline.state.downloads, downloads);
    assert.deepEqual({ ...offline.manager.getAtlasFrame('door', 'wall1').rect }, { ...frame.rect });
});

test('remote atlases missing or malformed plist prevents PNG/block loading and exposes retry', async () => {
    const { manager, state } = fixture();
    const blocks = [{ block: 0, color: 1 }], options = { extraPaths: ['door'] };
    state.fail.add('door.plist');
    await assert.rejects(manager.prepareWindow(blocks, options));
    assert.equal(state.loads.length, 0);
    state.fail.clear();
    const original = state.plists.get('door');
    state.plists.set('door', { metadata: {}, frames: {} });
    await assert.rejects(manager.prepareWindow(blocks, options), /plist/);
    assert.equal(state.loads.length, 0);
    // A corrected server file replaces the bad cached descriptor on retry.
    state.plists.set('door', original);
    assert.equal(await manager.prepareWindow(blocks, options), true);
    assert.ok(manager.getAtlasFrame('door', 'wall1'));
});

test('remote atlases reject mismatched PNG dimensions and invalid plist frame bounds', async () => {
    const { manager, state, load } = fixture();
    state.plists.get('door').metadata.size = '{1024,4096}';
    await assert.rejects(manager.prepareWindow([], { extraPaths: ['door'] }), /PNG/);
    assert.deepEqual([...manager.getLoadedPaths()], []);
    assert.equal(state.textures.size, 0, 'mismatched decoded textures must be released');
    const { parseGameplayAtlas } = load('assets/Script/module/Tool/GameplayAtlasFrames.ts');
    const invalid = atlasPlistFixture('door');
    invalid.frames['wall1.png'].frame = '{{10000,10000},{50,30}}';
    assert.throws(() => parseGameplayAtlas(invalid, 'door'), /plist/);
});

test('remote atlases a corrupt local plist is removed and downloaded again', async () => {
    const { manager, state, userFile } = fixture();
    state.disk.set(userFile('door.plist'), 'not XML or parsed plist');
    let loading = 0;
    await manager.prepareWindow([], { extraPaths: ['door'], onRemoteRequired: () => loading++ });
    assert.ok(loading > 0);
    assert.equal(state.plistLoads.length, 2);
    assert.equal(state.directRequests.filter(request => request.name === 'door.plist').length, 1);
    assert.ok(manager.getAtlasFrame('door', 'wall1'));
});

test('remote atlases replace all prefab dependencies and restore default sprites without overriding state', async () => {
    const { manager, load } = fixture();
    await manager.prepareWindow([], { extraPaths: atlasPaths });
    const Binding = load('assets/Script/module/Tool/RemoteAtlasBindings.ts').default;
    const bindingUuid = readJSON('assets/Script/module/Tool/RemoteAtlasBindings.ts.meta').uuid;
    const uuids = new Set();
    for (const atlas of atlasPaths) {
        const meta = readJSON(`assets/Block/${atlas}.plist.meta`);
        uuids.add(meta.uuid); uuids.add(meta.rawTextureUuid);
        Object.values(meta.subMetas).forEach(data => uuids.add(data.uuid));
    }
    function scan(directory) {
        for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
            const file = path.join(directory, entry.name);
            if (entry.isDirectory()) { scan(file); continue; }
            if (!/\.(prefab|fire|anim)$/.test(entry.name)) continue;
            const text = fs.readFileSync(file, 'utf8');
            for (const uuid of uuids) assert.ok(!text.includes(uuid), `${file} still references ${uuid}`);
            if (!entry.name.endsWith('.prefab')) continue;
            const data = JSON.parse(text);
            for (const component of data.filter(item => item.frameKeys && item.sprites)) {
                assert.ok(component.__type__ === bindingUuid || component.__type__ === compressUuid(bindingUuid));
                assert.equal(component.sprites.length, component.frameKeys.length);
                assert.ok(data[component.node.__id__]._components.some(ref => data[ref.__id__] === component));
                const binding = new Binding();
                binding.frameKeys = component.frameKeys;
                binding.sprites = component.sprites.map(ref => {
                    assert.equal(data[ref.__id__].__type__, 'cc.Sprite');
                    assert.equal(data[ref.__id__]._spriteFrame, null);
                    return { spriteFrame: null };
                });
                binding.onLoad();
                binding.sprites.forEach((sprite, index) => {
                    const [atlas, name] = component.frameKeys[index].split('/');
                    assert.equal(sprite.spriteFrame, manager.getAtlasFrame(atlas, name));
                });
                const override = {};
                binding.sprites[0].spriteFrame = override;
                binding.onLoad();
                assert.equal(binding.sprites[0].spriteFrame, override);
            }
        }
    }
    scan(path.join(root, 'assets'));
});

function compressUuid(uuid) {
    const hex = uuid.replace(/-/g, '');
    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    let value = hex.slice(0, 5);
    for (let i = 5; i < hex.length; i += 3) {
        const part = parseInt(hex.slice(i, i + 3), 16);
        value += alphabet[part >> 6] + alphabet[part & 63];
    }
    return value;
}

test('all shipped levels resolve to small images, including hidden/switch/stack/cycle states', () => {
    const { collect, pathsModule } = fixture();
    assert.deepEqual([...pathsModule.allBlockTexturePaths()], imagePaths);
    const files = fs.readdirSync(path.join(root, 'assets/custom/Json')).filter(n => /^level\d+\.json$/.test(n));
    for (const name of files) {
        const data = readJSON('assets/custom/Json/' + name).BLOCK_INFO[0];
        const before = JSON.stringify(data);
        for (const image of collect(data)) assert.ok(imagePaths.includes(image), `${name}: ${image}`);
        assert.equal(JSON.stringify(data), before, 'reading next level must not mutate it');
    }
    assert.deepEqual([...collect([{ block: 2, color: 11, type: 1, stacking: 7, lock: false }])], ['0color2', '11color2', '12color2', '7color2']);
    assert.deepEqual([...collect([{ block: 0, color: 10, type: 16 }])], ['10color0', 'question0']);
    assert.deepEqual([...collect([{ block: 1, color: 9, type: 20, colorArray: '81' }])], ['2color1', '9color1']);
    assert.deepEqual([...collect([{ block: 23, color: 1 }])], []);
});

test('50 -> 51 releases only old exclusive frames; restart reuses both levels', async () => {
    const { manager, collect, state } = fixture();
    const a = level(50).BLOCK_INFO[0], b = level(51).BLOCK_INFO[0], c = level(52).BLOCK_INFO[0];
    await manager.prepareWindow(a, b);
    assert.deepEqual([...manager.getLoadedPaths()], sorted([...collect(a), ...collect(b)]));
    manager.activateScene(a);
    const shared = collect(a).find(name => collect(b).includes(name));
    const original = manager.getFrame(shared);
    await manager.prepareWindow(b, c);
    assert.ok(manager.getLoadedPaths().includes(collect(a)[0]), 'old scene stays visible until destroyed');
    manager.releaseScene();
    manager.activateScene(b);
    assert.deepEqual([...manager.getLoadedPaths()], sorted([...collect(b), ...collect(c)]));
    assert.equal(manager.getFrame(shared), original);
    const count = state.loads.length;
    await manager.prepareWindow(b, c);
    assert.equal(state.loads.length, count);
    for (const frame of state.assets.values()) { assert.equal(frame.texture.refs, 1); assert.equal(frame.texture.packable, false); }
    assert.equal(state.textures.size, state.assets.size, 'no orphaned raw textures after level transitions');
});

test('failed new window rolls back without freeing current/next; retry is possible', async () => {
    const { manager, state } = fixture();
    const old = [{ block: 0, color: 1 }], next = [{ block: 1, color: 2 }];
    await manager.prepareWindow(old, next);
    manager.activateScene(old);
    const original = [...manager.getLoadedPaths()];
    state.fail.add('9color22');
    await assert.rejects(manager.prepareWindow([{ block: 22, color: 9 }], []));
    assert.deepEqual([...manager.getLoadedPaths()], original);
    state.fail.clear();
    assert.equal(await manager.prepareWindow([{ block: 22, color: 9 }], []), true);
    manager.releaseScene();
    assert.deepEqual([...manager.getLoadedPaths()], ['9color22']);
});

test('late completion of a cancelled window cannot pin obsolete textures', async () => {
    const { manager, state } = fixture();
    state.hold.add('1color0');
    const oldRequest = manager.prepareWindow([{ block: 0, color: 1 }], []);
    await tick();
    const latest = manager.prepareWindow([{ block: 1, color: 2 }], []);
    assert.equal(await latest, true);
    state.deferred.get('1color0')();
    assert.equal(await oldRequest, false);
    assert.deepEqual([...manager.getLoadedPaths()], ['2color1']);
    assert.ok(state.releases.includes('1color0'));
});

test('invalid image configuration can retry, and concurrent windows share one texture load', async () => {
    const { manager, state, cc } = fixture();
    const base = cc.fx.GameConfig.BLOCK_IMAGE_BASE_URL;
    cc.fx.GameConfig.BLOCK_IMAGE_BASE_URL = '';
    await assert.rejects(manager.prepareWindow([{ block: 0, color: 1 }], []));
    cc.fx.GameConfig.BLOCK_IMAGE_BASE_URL = base;
    state.hold.add('1color0');
    const first = manager.prepareWindow([{ block: 0, color: 1 }], []);
    await tick();
    const second = manager.prepareWindow([{ block: 0, color: 1 }], []);
    await tick();
    assert.equal(state.loads.length, 1);
    state.deferred.get('1color0')();
    assert.equal(await first, false);
    assert.equal(await second, true);
    assert.equal(manager.getFrame('1color0').getTexture().refs, 1);
});

test('background downloads directly to the versioned user directory without Cocos persistence', async () => {
    const { manager, Manager, state, userFile } = fixture();
    state.disk.set(userFile(imagePaths[0]) + '.tmp', 'interrupted');
    await manager.cacheAllFiles();
    assert.equal(state.loads.length, 0);
    assert.equal(state.assets.size, 0);
    assert.equal(state.downloads, filePaths.length);
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    assert.equal(state.cacheWrites, 0, 'Block must not enter the Cocos persistent-cache queue');
    assert.equal(state.temps.size, 0);
    assert.ok(imagePaths.every(name => state.disk.has(userFile(name))));
    assert.ok(imagePaths.every(name => !state.disk.has(userFile(name) + '.tmp')));
    assert.ok(state.directRequests.every(request => request.filePath === userFile(request.name) + '.tmp'));
    const restarted = new Manager();
    await restarted.cacheAllFiles();
    assert.equal(state.downloads, filePaths.length, 'restart should reuse actual local files');
    assert.deepEqual(state.loadingEvents, [], 'background caching must remain silent');
});

test('background startup, downloads and cache hits remain observable in a non-debug WeChat build', async () => {
    const { manager, Manager, state, cc } = fixture();
    cc.game.config.debugMode = cc.debug.DebugMode.ERROR;
    cc.log = cc.warn = () => {}; // Cocos release boot resets these to no-ops.
    state.hold.add('version');
    manager.startBackgroundCache();
    manager.startBackgroundCache();
    await tick();
    assert.equal(state.requests.length, 1);
    assert.equal(state.gameListeners.length, 1);
    assert.equal(state.downloads, 0, 'version check has not completed');
    for (const message of ['[后台缓存] 启动', '[版本检查] 开始', '任务正在运行']) {
        assert.ok(state.consoleLogs.some(args => args[0].includes(message)));
    }
    state.deferred.get('version')();
    await tick();
    assert.equal(manager.backgroundRunning, false);
    assert.equal(state.downloads, filePaths.length);
    assert.equal(state.loads.length, 0, 'background must still cache files without decoding textures');
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    const lines = state.consoleLogs.map(args => args[0]);
    assert.equal(lines.filter(line => line.includes('[远程下载] 开始')).length, filePaths.length);
    assert.equal(lines.filter(line => line.includes('[远程下载] 成功')).length, filePaths.length);
    assert.ok(lines.some(line => line.includes(`有效持久文件=${filePaths.length}/${filePaths.length}，完整落盘=true`)));
    assert.ok(lines.some(line => line.includes('本轮结束，全部已持久缓存')));
    manager.startBackgroundCache();
    await tick();
    assert.equal(state.downloads, filePaths.length, 'valid cache must not be downloaded for logging');
    assert.ok(state.consoleLogs.some(args => args[0].includes('全部本地缓存有效，无需下载')));
    assert.equal(cc.game.config.debugMode, cc.debug.DebugMode.ERROR, 'do not enable global game logging');
    assert.deepEqual(state.loadingEvents, []);
});

test('background keeps eight files in flight and replenishes each completed slot without waiting for a batch', async t => {
    const { manager, Manager, state } = fixture();
    manager.paths = manager.paths.slice(0, 18);
    for (const name of manager.paths) state.hold.add('download:' + name);
    t.after(() => releaseHeldDownloads(state));
    const background = manager.cacheAllFiles();
    await tick();
    assert.deepEqual(state.fileRequests, [...manager.paths.slice(0, 8)]);
    assert.equal(state.activeDownloads.size, 8);
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    state.deferred.get('download:' + manager.paths[3])();
    await tick();
    assert.equal(state.fileRequests.length, 9, 'one free worker immediately starts the ninth image');
    assert.equal(state.activeDownloads.size, 8, 'the other seven slow images do not block replenishment');
    assert.ok(state.logs.some(args => args[0].includes('在途=8/8')));
    releaseHeldDownloads(state);
    assert.equal((await background).complete, true);
    assert.equal(state.downloads, 18);
    assert.equal(new Set(state.fileRequests).size, 18);
    assert.equal(state.maxActiveDownloads, 8);
    assert.equal(state.loads.length, 0, 'parallel file caching must not decode textures');
});

test('one failed worker does not stop the pool or schedule a retry before the other workers finish', async t => {
    const { manager, Manager, state } = fixture();
    manager.paths = manager.paths.slice(0, 12);
    for (const name of manager.paths.slice(0, 8)) state.hold.add('download:' + name);
    t.after(() => releaseHeldDownloads(state));
    state.fail.add(manager.paths[0]);
    manager.startBackgroundCache();
    await tick();
    manager.startBackgroundCache();
    assert.equal(state.fileRequests.length, 8, 'starting again must not create another pool');
    state.deferred.get('download:' + manager.paths[0])();
    await tick();
    assert.equal(state.fileRequests.length, 12, 'the failed worker continues processing the remaining queue');
    assert.equal(manager.backgroundRunning, true);
    assert.equal(state.timers.size, 0, 'seven requests are still in flight');
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    releaseHeldDownloads(state);
    await tick();
    assert.equal(manager.backgroundRunning, false);
    assert.equal(state.downloads, 11);
    state.fail.clear();
    fireTimer(state, 10000);
    await tick();
    assert.equal(state.fileRequests.length, 13, 'only the one failed file is retried');
    assert.equal(state.downloads, 12);
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
});

test('level entry pauses new background work and the same pool resumes after switching to GameScene', async t => {
    const { manager, Manager, state, config, collect } = fixture();
    const Config = config();
    Config.applyLevelData(level(50), false, 0, 50);
    const needed = sorted([...collect(level(50).BLOCK_INFO[0]), ...collect(level(51).BLOCK_INFO[0])]);
    const foregroundName = collect(level(50).BLOCK_INFO[0])[0];
    const backgroundNames = imagePaths.filter(name => !needed.includes(name)).slice(0, 16);
    const backgroundRequestCount = () => state.fileRequests.filter(name => backgroundNames.includes(name)).length;
    manager.paths = backgroundNames.concat(needed);
    manager.delay = ms => ms === 100 ? tick() : Promise.resolve();
    for (const name of manager.paths.slice(0, 8)) state.hold.add('download:' + name);
    state.hold.add('download:' + foregroundName);
    t.after(() => releaseHeldDownloads(state));
    manager.startBackgroundCache();
    await tick();
    assert.equal(backgroundRequestCount(), 8);
    Config.enterGameSceneWhenReady();
    await tick();
    assert.equal(state.scene.loading, true);
    assert.ok(manager.foregroundLoads > 0);
    for (const name of manager.paths.slice(0, 8)) state.deferred.get('download:' + name)();
    await tick();
    assert.equal(backgroundRequestCount(), 8, 'completed background slots must not be replenished while entering');
    assert.equal(manager.backgroundRunning, true, 'pause must not discard the remaining queue');
    assert.equal(state.logs.filter(args => args[0].includes('暂停派发')).length, 1);
    state.hold.delete('download:' + foregroundName);
    state.deferred.get('download:' + foregroundName)();
    await waitFor(() => state.scenes.length === 1 && !manager.backgroundRunning, 'entry and background caching finish');
    assert.deepEqual(state.scenes, ['GameScene']);
    assert.deepEqual(state.loadingEvents, ['HomeScene:open', 'HomeScene:close']);
    assert.equal(backgroundRequestCount(), 16, 'remaining images download after entering, without another start call');
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    assert.ok(state.logs.some(args => args[0].includes('进关图片处理结束，继续后台缓存')));
    assert.equal(manager.getLoadedPaths().some(name => backgroundNames.includes(name)), false, 'background files stay out of texture memory');
});

test('failed foreground preparation also releases the background pause', async t => {
    const { manager, state } = fixture();
    manager.paths = manager.paths.slice(0, 12).concat('9color22');
    manager.delay = ms => ms === 100 ? tick() : Promise.resolve();
    for (const name of manager.paths.slice(0, 8)) state.hold.add('download:' + name);
    const key = 'download:9color22';
    state.hold.add(key);
    state.fail.add('9color22');
    t.after(() => releaseHeldDownloads(state));
    const background = manager.cacheAllFiles();
    await tick();
    const foreground = assert.rejects(manager.prepareWindow([{ block: 22, color: 9 }], []));
    await tick();
    for (const name of manager.paths.slice(0, 8)) state.deferred.get('download:' + name)();
    await tick();
    assert.equal(state.fileRequests.filter(name => name !== '9color22').length, 8);
    state.hold.delete(key);
    state.deferred.get(key)();
    await foreground;
    state.fail.clear();
    assert.equal((await background).complete, true);
    assert.ok(manager.paths.every(name => state.disk.has(`http://usr/Block/1.0.0/${name}.png`)));
    assert.equal(manager.foregroundLoads, 0);
});

test('foreground rolling pool fills a free slot without waiting for the slowest image of a batch', async t => {
    const { manager, state } = fixture();
    const names = manager.paths.filter(name => /^9color[0-5]$/.test(name));
    const blocks = names.map(name => { const [, color, block] = name.match(/^(\d+)color(\d+)$/); return { color: +color, block: +block }; });
    for (const name of names) state.hold.add('download:' + name);
    t.after(() => releaseHeldDownloads(state));
    const ready = manager.prepareWindow(blocks, {});
    await waitFor(() => state.fileRequests.length === 4, 'first four foreground downloads start');
    state.deferred.get('download:' + names[1])();
    await waitFor(() => state.fileRequests.includes(names[4]), 'a fifth image starts before the first slow image finishes');
    assert.equal(state.activeDownloads.size, 4);
    assert.ok(state.activeDownloads.has(names[0]));
    releaseHeldDownloads(state);
    assert.equal(await ready, true);
});

test('foreground rolling pool stops issuing work on failure and drains pending loads before cleanup', async () => {
    const { manager } = fixture();
    const names = manager.paths.filter(name => /^9color[0-5]$/.test(name));
    const blocks = names.map(name => { const [, color, block] = name.match(/^(\d+)color(\d+)$/); return { color: +color, block: +block }; });
    const pending = [];
    manager.loadFrame = name => new Promise((resolve, reject) => pending.push({ name, resolve, reject }));
    const result = assert.rejects(manager.prepareWindow(blocks, {}), /broken/);
    await waitFor(() => pending.length === 4, 'four workers start');
    pending[0].reject(new Error('broken')); await tick();
    assert.equal(manager.foregroundLoads, 1, 'pause remains held while other image jobs are still running');
    pending.slice(1).forEach(job => job.resolve()); await result;
    assert.equal(pending.length, 4); assert.equal(manager.foregroundLoads, 0);
});

test('entry hold keeps bulk workers paused after foreground decoding until map handoff releases it', async t => {
    const { manager, state } = fixture();
    manager.paths = manager.paths.slice(0, 12).concat('9color22');
    manager.delay = ms => ms === 100 ? tick() : Promise.resolve();
    const release = manager.holdBackgroundDownloads();
    t.after(release);
    const background = manager.cacheAllFiles();
    await tick();
    assert.equal(state.fileRequests.length, 0);
    assert.equal(await manager.prepareWindow([{ block: 22, color: 9 }], {}), true);
    await tick();
    assert.deepEqual(state.fileRequests, ['9color22'], 'bulk downloads cannot resume at the end of prepareWindow');
    assert.equal(manager.foregroundLoads, 0);
    release();
    assert.equal((await background).complete, true);
    assert.equal(manager.entryDownloadHolds, 0);
    assert.ok(manager.paths.every(name => state.disk.has(`http://usr/Block/1.0.0/${name}.png`)));
});

test('Block scheduler gives foreground two extra slots while all eight background requests remain pending', async t => {
    const { manager, state, cc } = fixture();
    manager.delay = ms => ms === 100 ? tick() : Promise.resolve();
    const blocks = [19, 20, 21, 22].map(block => ({ block, color: 9 }));
    const names = blocks.map(block => `9color${block.block}`);
    manager.paths = manager.paths.slice(0, 10).concat(names);
    for (const name of [...manager.paths, ...names]) state.hold.add('download:' + name);
    t.after(() => releaseHeldDownloads(state));
    const background = manager.cacheAllFiles();
    await tick();
    assert.equal(state.activeDownloads.size, 8);
    const foreground = manager.prepareWindow(blocks, []);
    await tick();
    assert.equal(state.activeDownloads.size, 10, 'foreground starts without waiting for any of the eight background requests');
    assert.deepEqual(state.fileRequests.slice(8), names.slice(0, 2));
    for (const name of names.slice(0, 2)) state.deferred.get('download:' + name)();
    await waitFor(() => names.slice(2).every(name => state.deferred.has('download:' + name)), 'queued foreground files start next');
    assert.deepEqual(sorted(state.fileRequests.slice(8)), names);
    assert.equal(state.fileRequests.filter(name => manager.paths.slice(0, 10).includes(name)).length, 8);
    for (const name of names.slice(2)) state.deferred.get('download:' + name)();
    assert.equal(await foreground, true);
    assert.equal(state.downloads, 4, 'all foreground files finish while the background files are still held');
    state.deferred.get('download:' + manager.paths[0])();
    await waitFor(() => state.fileRequests.filter(name => manager.paths.slice(0, 10).includes(name)).length === 9,
        'background replenishment resumes after foreground');
    releaseHeldDownloads(state);
    assert.equal((await background).complete, true);
    assert.equal(state.maxActiveDownloads, 10);
    assert.equal(cc.assetManager.downloader.maxConcurrency, 8, 'global downloader settings remain unchanged');
});

test('background network failures wait ten seconds and retry only missing images without engine retry bursts', async () => {
    const { manager, Manager, state } = fixture();
    state.fail.add('question0');
    manager.startBackgroundCache();
    await tick();
    assert.equal(state.downloads, filePaths.length - 1);
    assert.equal(state.directRequests.filter(request => request.name === 'question0').length, 1);
    assert.equal(state.timers.size, 1);
    assert.ok(state.logs.some(args => args[0].includes('仍缺少1张图片，10秒后重试')));
    state.fail.clear();
    fireTimer(state, 10000);
    await tick();
    assert.equal(state.downloads, filePaths.length);
    assert.equal(state.fileRequests.length, filePaths.length + 1);
    assert.equal(state.directRequests.filter(request => request.name === 'question0').length, 2);
    assert.equal(state.timers.size, 0);
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    assert.equal(state.requests.length, 1, 'background retries do not refetch version metadata');
});

test('legacy Cocos temporary files migrate into the user directory without network requests', async () => {
    const { manager, Manager, state, url, userFile } = fixture();
    manager.paths = manager.paths.slice(0, 12);
    await manager.initialize();
    for (const name of manager.paths) {
        const temp = 'legacy-temp/' + name;
        state.temps.set(url(name), temp);
        state.disk.set(temp, 'valid');
    }
    await manager.cacheAllFiles();
    assert.equal(state.downloads, 0);
    assert.equal(state.directRequests.length, 0);
    assert.equal(state.cacheWrites, 0);
    assert.ok(manager.paths.every(name => state.disk.has(userFile(name))));
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
});

test('failed legacy-file migration retries after ten seconds without downloading a duplicate', async () => {
    const { manager, Manager, state, url, userFile } = fixture();
    manager.paths = manager.paths.slice(0, 4);
    await manager.initialize();
    for (const name of manager.paths) {
        const temp = 'legacy-temp/' + name;
        state.temps.set(url(name), temp);
        state.disk.set(temp, 'valid');
    }
    state.save = false;
    manager.startBackgroundCache();
    await tick();
    assert.equal(state.directRequests.length, 0);
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    assert.ok(state.logs.some(args => args[0].includes('4张旧临时文件待迁移，10秒后重试')));
    state.save = true;
    fireTimer(state, 10000);
    await tick();
    assert.ok(manager.paths.every(name => state.disk.has(userFile(name))));
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    assert.equal(state.timers.size, 0);
});

test('Cocos cache-index writes do not affect direct-cache completion', async () => {
    const { manager, Manager, state } = fixture();
    manager.paths = manager.paths.slice(0, 12);
    await manager.cacheAllFiles();
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    assert.equal(state.cacheWrites, 0);
    assert.equal(state.disk.has('gamecaches/cacheList.json'), false);
});

test('storage-full retries direct downloads after ten seconds', async () => {
    const { manager, Manager, state } = fixture();
    manager.paths = manager.paths.slice(0, 12);
    state.save = false;
    manager.startBackgroundCache();
    await tick();
    assert.equal(state.downloads, 0);
    assert.equal(state.directRequests.length, 12);
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    state.save = true;
    fireTimer(state, 10000);
    await tick();
    assert.equal(state.downloads, 12);
    assert.equal(state.directRequests.length, 24);
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    assert.equal(state.timers.size, 0);
});

test('the ten-second background retry does not delay an immediate foreground level entry', async () => {
    const { manager, state, config, collect } = fixture();
    const Config = config();
    const missing = collect(level(50).BLOCK_INFO[0])[0];
    state.fail.add(missing);
    manager.startBackgroundCache();
    await tick();
    assert.equal([...state.timers.values()].some(timer => timer.delay === 10000), true);
    state.fail.clear();
    Config.applyLevelData(level(50), false, 0, 50);
    Config.enterGameSceneWhenReady();
    await tick();
    assert.deepEqual(state.scenes, ['GameScene']);
    assert.deepEqual(state.loadingEvents, ['HomeScene:open', 'HomeScene:close']);
    assert.equal(state.downloads, filePaths.length);
    const requests = state.fileRequests.length;
    fireTimer(state, 10000);
    await tick();
    assert.equal(state.downloads, filePaths.length);
    assert.equal(state.fileRequests.length, requests, 'the later retry sees the foreground cache and skips downloading');
    assert.equal(state.timers.size, 0);
});

test('foreground and background create the Block cache directory only when it is missing', async () => {
    const { manager, Manager, state } = fixture();
    const directory = 'http://usr/Block/1.0.0';
    const blocks = [{ block: 0, color: 1 }];
    await Promise.all([manager.prepareWindow(blocks, []), manager.cacheAllFiles()]);
    await manager.prepareWindow(blocks, []);
    assert.deepEqual(state.mkdirCalls, [directory]);
    const restarted = new Manager();
    await restarted.cacheAllFiles();
    assert.equal(state.mkdirCalls.length, 1, 'an existing directory survives manager/session initialization');
    state.directories.delete(directory);
    await manager.prepareWindow(blocks, []);
    assert.equal(state.mkdirCalls.length, 2, 'cleared cache directories must be recreated, not remembered by a flag');
    assert.ok(state.directories.has(directory));
});

test('directory creation failures still surface and may be retried; existing files are never deleted', async () => {
    const { manager, state } = fixture();
    const directory = 'http://usr/Block/1.0.0';
    await manager.initialize();
    const permissionError = new Error('mkdirSync:fail permission denied');
    state.mkdirError = permissionError;
    assert.throws(() => manager.ensureUserCacheFolder(), permissionError);
    assert.equal(state.directories.has(directory), false);
    state.mkdirError = null;
    manager.ensureUserCacheFolder();
    assert.ok(state.directories.has(directory));
    assert.equal(state.mkdirCalls.length, 2);
    state.directories.delete(directory);
    state.disk.set(directory, 'a file occupying the directory path');
    assert.throws(() => manager.ensureUserCacheFolder(), /file already exists/);
    assert.equal(state.disk.get(directory), 'a file occupying the directory path');
    assert.equal(state.directories.has(directory), false, 'a same-name file is not a usable directory');
});

test('a complete disk cache loads only the two-level texture window without downloading', async () => {
    const { manager, state, collect } = fixture();
    await manager.cacheAllFiles();
    const downloads = state.downloads;
    const current = level(50).BLOCK_INFO[0], next = level(51).BLOCK_INFO[0];
    await manager.prepareWindow(current, next);
    assert.equal(state.downloads, downloads);
    assert.deepEqual([...state.assets.keys()].sort(), sorted([...collect(current), ...collect(next)]));
});

test('a complete localStorage marker never substitutes for missing user-directory files', async () => {
    const { manager, Manager, state } = fixture();
    state.storage.set(Manager.CACHE_KEY, JSON.stringify({
        version: '1.0.0', baseUrl: 'https://cdn.test/remote/Block/',
        total: filePaths.length, cached: filePaths.length, complete: true
    }));
    await manager.cacheAllFiles();
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    assert.equal(state.downloads, filePaths.length);
});

test('cache eviction, interrupted download, and semantic version changes revalidate completion', async () => {
    const { manager, Manager, state, userFile } = fixture();
    state.fail.add('question0');
    await manager.cacheAllFiles();
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    assert.ok(state.logs.some(args => args[0].includes('[远程下载] 失败 question0.png')));
    state.fail.clear();
    await manager.cacheAllFiles();
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, true);
    state.disk.delete(userFile('1color0'));
    await manager.cacheAllFiles();
    assert.equal(state.downloads, filePaths.length + 1);
    const restarted = fixture(state);
    restarted.state.manifest.data.version = '1.0.1';
    await restarted.manager.cacheAllFiles();
    assert.equal(restarted.state.downloads, filePaths.length * 2 + 1);
    const saved = JSON.parse(restarted.state.storage.get(Manager.CACHE_KEY));
    assert.equal(saved.version, '1.0.1');
    assert.equal(saved.complete, true);
});

test('1.0.0 -> 1.0.1 changes raw PNG cache URLs without any bundle or build hash', async () => {
    const first = fixture();
    await first.manager.cacheAllFiles();
    const { manager, Manager, state, url, userFile } = fixture(first.state);
    state.manifest.data.version = '1.0.1';
    await manager.prepareWindow([{ block: 0, color: 1 }], [{ block: 1, color: 2 }]);
    assert.deepEqual(state.bundleLoads, []);
    assert.equal(state.downloads, filePaths.length + 2, 'both foreground images need the new version');
    assert.ok(state.loads.every(load => load.url.includes('/Block/1.0.1/')));
    assert.ok(state.directRequests.every(request => request.url.endsWith('.png?v=1.0.1')));
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    assert.ok(state.disk.has(userFile('1color0', '1.0.0')), 'do not delete the previous version before replacement completes');
    await manager.cacheAllFiles();
    const saved = JSON.parse(state.storage.get(Manager.CACHE_KEY));
    assert.equal(saved.version, '1.0.1');
    assert.equal(saved.baseUrl, 'https://cdn.test/remote/Block/');
    assert.equal(saved.complete, true);
    assert.equal(state.downloads, filePaths.length * 2, 'a total version bump refreshes all files');
    assert.equal(state.assets.size, 2, 'background update must not decode the other images');
    assert.equal(state.textures.size, 2);
    state.manifest.data.version = '1.0.2';
    await manager.cacheAllFiles();
    await manager.prepareWindow([{ block: 0, color: 1 }], []);
    assert.equal(state.requests.length, 1, 'scene changes and repeated scans keep this session version');
    assert.equal(state.downloads, filePaths.length * 2);
    assert.match(state.requests[0].url, /^https:\/\/cdn\.test\/remote\/Block\/version\.json\?_t=\d+$/);
    assert.equal(state.requests[0].header['Cache-Control'], 'no-cache');
});

test('fully offline restart uses the cached semantic version and images without a bundle config', async () => {
    const first = fixture();
    first.state.manifest.data.version = '1.0.1';
    await first.manager.cacheAllFiles();
    const { manager, state } = fixture(first.state);
    state.offline = true;
    await manager.prepareWindow([{ block: 0, color: 1 }], [{ block: 1, color: 2 }]);
    assert.ok(state.loads.every(load => load.url.includes('/Block/1.0.1/')));
    assert.equal(state.directRequests.length, 0);
    assert.equal(state.downloads, filePaths.length);
    assert.equal(state.assets.size, 2);
    assert.deepEqual(state.bundleLoads, []);
});

test('incomplete new version resumes after a manifest outage without repeating cached downloads', async () => {
    const first = fixture();
    await first.manager.cacheAllFiles();
    const updated = fixture(first.state);
    updated.state.manifest.data.version = '1.0.1';
    updated.state.fail.add('question0');
    await updated.manager.cacheAllFiles();
    let saved = JSON.parse(updated.state.storage.get(updated.Manager.CACHE_KEY));
    assert.equal(saved.version, '1.0.1');
    assert.equal(saved.complete, false);
    assert.equal(updated.state.downloads, filePaths.length * 2 - 1);
    const restarted = fixture(updated.state);
    restarted.state.manifestError = new Error('version service unavailable');
    await restarted.manager.cacheAllFiles();
    saved = JSON.parse(restarted.state.storage.get(restarted.Manager.CACHE_KEY));
    assert.equal(saved.version, '1.0.1');
    assert.equal(saved.complete, true);
    assert.equal(restarted.state.downloads, filePaths.length * 2);
});

test('missing new-version PNG fails entry and retries the new URL instead of using old pixels', async () => {
    const first = fixture();
    await first.manager.cacheAllFiles();
    const { manager, Manager, state } = fixture(first.state);
    state.manifest.data.version = '1.0.1';
    state.fail.add('1color0');
    await assert.rejects(manager.prepareWindow([{ block: 0, color: 1 }], []));
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).version, '1.0.1');
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    assert.equal(state.assets.size, 0);
    state.fail.clear();
    await manager.prepareWindow([{ block: 0, color: 1 }], []);
    assert.ok(state.loads.every(load => load.url.includes('/Block/1.0.1/')));
    assert.ok(state.directRequests.every(request => request.url.endsWith('?v=1.0.1')));
    assert.equal(state.requests.length, 1, 'retry shares the selected semantic version');
    assert.equal(state.downloads, filePaths.length + 1);
});

test('old build-hash records and version hints for a different CDN cannot select a raw-image version', async () => {
    for (const previous of [
        { version: 'fbc07', buildVersion: 'fbc07', complete: true },
        { version: '1.5.0', baseUrl: 'https://another.test/Block/', complete: true }
    ]) {
        const { manager, Manager, state } = fixture();
        state.storage.set(Manager.CACHE_KEY, JSON.stringify(previous));
        state.manifestError = new Error('offline');
        await manager.prepareWindow([{ block: 0, color: 1 }], []);
        assert.ok(state.loads.every(load => load.url.includes('/Block/1.0.0/')));
        assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    }
});

test('missing, malformed or unsafe version metadata falls back without trusting legacy true flags', async () => {
    for (const response of [
        { statusCode: 404 }, { statusCode: 200, data: '{' }, { statusCode: 200, data: null },
        ...['../bad', '1', 'fbc07', '1.0.0?x=1'].map(version => ({ statusCode: 200, data: { version } }))
    ]) {
        const { manager, Manager, state } = fixture();
        state.storage.set(Manager.CACHE_KEY, 'true');
        state.manifest = response;
        await manager.prepareWindow([{ block: 0, color: 1 }], []);
        const saved = JSON.parse(state.storage.get(Manager.CACHE_KEY));
        assert.equal(saved.version, '1.0.0');
        assert.equal(saved.complete, false);
        assert.equal(state.downloads, 1);
    }
});

test('version watchdog falls back once and ignores a late response', async () => {
    const { manager, state } = fixture();
    state.manifest.data.version = '1.0.1';
    state.hold.add('version');
    const pending = manager.prepareWindow([{ block: 0, color: 1 }], []);
    await tick();
    assert.equal(state.loads.length, 0);
    [...state.timers.values()].find(timer => timer.delay === 5000).cb();
    assert.equal(await pending, true);
    assert.equal(state.requestAborts, 1);
    state.deferred.get('version')();
    await tick();
    assert.ok(state.loads.every(load => load.url.includes('/Block/1.0.0/')));
});

test('ByteDance and browser version requests work; browsers never run full file pre-caching', async () => {
    const { manager, wx, tt, state } = fixture();
    tt.request = wx.request;
    tt.downloadFile = wx.downloadFile;
    tt.getFileSystemManager = wx.getFileSystemManager;
    tt.env = wx.env;
    delete wx.request;
    delete wx.downloadFile;
    delete wx.getFileSystemManager;
    state.manifest.data = JSON.stringify({ version: '1.0.1' });
    await manager.prepareWindow([{ block: 0, color: 1 }], []);
    assert.ok(state.loads.every(load => load.url.includes('/Block/1.0.1/')));
    assert.ok(state.directRequests.every(request => request.url.endsWith('?v=1.0.1')));
    const browser = fixture();
    delete browser.wx.request;
    delete browser.wx.downloadFile;
    delete browser.wx.getFileSystemManager;
    browser.cc.assetManager.cacheManager = null;
    browser.state.manifest.data.version = '1.0.2';
    browser.manager.startBackgroundCache();
    assert.ok(browser.state.logs.some(args => args[0].includes('[后台缓存] 跳过：用户缓存环境不可用')));
    await browser.manager.prepareWindow([{ block: 0, color: 1 }], []);
    assert.ok(browser.state.loads.every(load => load.url.endsWith('?v=1.0.2')));
    assert.equal(browser.state.requests.length, 1);
    assert.equal(browser.state.directRequests.length, 0);
    assert.equal(browser.state.storage.size, 0);
});

test('raw SpriteFrames preserve existing PNG crop layout and explicitly release their textures', async () => {
    const { manager, state, pathsModule, url } = fixture();
    for (const name of imagePaths.filter(name => !atlasPaths.includes(name))) {
        const frame = Object.values(readJSON('assets/Block/' + name + '.png.meta').subMetas)[0];
        const trim = pathsModule.BLOCK_TEXTURE_TRIMS[name];
        if (frame.rawWidth === frame.width && frame.rawHeight === frame.height) assert.equal(trim, undefined);
        else assert.deepEqual([...trim], [frame.trimX, frame.trimY, frame.width, frame.height,
            frame.offsetX, frame.offsetY, frame.rawWidth, frame.rawHeight]);
    }
    await manager.prepareWindow([{ block: 20, color: 4 }], [{ block: 0, color: 1 }]);
    const oldFrame = manager.getFrame('4color20'), texture = oldFrame.getTexture();
    assert.deepEqual(oldFrame.rect, { x: 23, y: 0, width: 244, height: 249 });
    assert.deepEqual(oldFrame.originalSize, { width: 267, height: 249 });
    await manager.prepareWindow([{ block: 1, color: 2 }], []);
    assert.equal(oldFrame.destroyed, true);
    assert.equal(texture.refs, 0);
    assert.equal(state.nativeFiles.has(url('4color20') + '@native'), false);
    assert.equal(state.textures.size, 1);
});

for (const scene of ['HomeScene', 'GameScene']) {
    test(scene + ' opens Loading only for missing images after version selection', async () => {
        const { manager, state, config, createScene, collect } = fixture();
        state.scene = createScene(scene);
        state.manifest.data.version = '1.0.1';
        state.hold.add('version');
        const Config = config(), sourceScene = state.scene;
        const held = collect(level(51).BLOCK_INFO[0])[0];
        state.hold.add(held);
        const startup = manager.initialize();
        Config.applyLevelData(level(50), false, 0, 50);
        Config.enterGameSceneWhenReady();
        await tick();
        assert.equal(sourceScene.loading, false, 'version metadata alone must not show image Loading');
        assert.equal(state.requests.length, 1);
        assert.equal(state.loads.length, 0);
        state.deferred.get('version')();
        await startup;
        await tick();
        assert.equal(sourceScene.loading, true);
        assert.equal(state.scenes.length, 0);
        state.deferred.get(held)();
        await tick();
        assert.equal(sourceScene.loading, false);
        assert.ok(state.loads.every(load => load.url.includes('/Block/1.0.1/')));
        assert.ok(state.directRequests.every(request => request.url.endsWith('?v=1.0.1')));
        assert.ok(state.bundleLoads.every(name => name !== 'Block'));
        assert.deepEqual(state.scenes, ['GameScene']);
    });
}

test('corrupt local image is removed and retried from remote before entering memory', async () => {
    const { manager, state, url, userFile } = fixture();
    state.caches.set(url('1color0'), 'bad.png');
    state.disk.set('bad.png', 'corrupt');
    await manager.prepareWindow([{ block: 0, color: 1 }], []);
    assert.deepEqual(state.loads.map(item => item.reload), [false, false]);
    assert.equal(state.downloads, 1);
    assert.equal(state.directRequests.length, 1);
    assert.ok(state.disk.has(userFile('1color0')));
    assert.equal(manager.getFrame('1color0').getTexture().refs, 1);
});

test('next-level lookup uses file number, never replaces current level data or advances progress', async () => {
    const { config, state } = fixture();
    const Config = config();
    const data = level(50);
    data.LEVEL_INFO[0].id = '1001'; // Several shipped JSON ids differ from their actual file number.
    Config.applyLevelData(data, false, 0, 50);
    await Config.prepareBlockWindow();
    assert.equal(Config.BLOCK_INFO, data.BLOCK_INFO);
    assert.equal(Config.LEVEL_INFO, data.LEVEL_INFO);
    assert.equal(Config.GM_INFO.level, 49);
    assert.deepEqual(state.jsonLoads, ['Json/level51']);
});

test('scene transition waits for both levels; failure exposes retry without advancing progress', async () => {
    const { config, state, collect } = fixture();
    const Config = config();
    Config.applyLevelData(level(50), false, 0, 50);
    const onlyNext = collect(level(51).BLOCK_INFO[0]).find(name => !collect(level(50).BLOCK_INFO[0]).includes(name));
    state.fail.add(onlyNext);
    const sourceScene = state.scene;
    Config.enterGameSceneWhenReady();
    assert.equal(sourceScene.loading, false);
    await tick();
    assert.equal(state.scenes.length, 0);
    assert.equal(state.errors.length, 1);
    assert.equal(sourceScene.loading, false, 'close the spinner before showing retry');
    assert.ok(state.logs.some(args => args[0].includes('[远程加载] 失败 ' + onlyNext + '.png')));
    assert.equal(Config.GM_INFO.level, 49);
    state.fail.clear();
    state.errors[0].retry();
    await tick();
    assert.deepEqual(state.scenes, ['GameScene']);
    assert.equal(sourceScene.loading, false);
    assert.deepEqual(state.loadingEvents, ['HomeScene:open', 'HomeScene:close', 'HomeScene:open', 'HomeScene:close']);
});

for (const name of ['HomeScene', 'GameScene']) {
    test(name + ' opens its own Loading until both levels are ready', async () => {
        const { config, state, collect, createScene } = fixture();
        state.scene = createScene(name);
        const sourceScene = state.scene, Config = config();
        Config.applyLevelData(level(50), false, 0, 50);
        const onlyNext = collect(level(51).BLOCK_INFO[0]).find(image => !collect(level(50).BLOCK_INFO[0]).includes(image));
        state.hold.add(onlyNext);
        Config.enterGameSceneWhenReady();
        assert.equal(sourceScene.loading, false);
        await tick();
        assert.equal(sourceScene.loading, true);
        assert.equal(state.scenes.length, 0);
        state.deferred.get(onlyNext)();
        await tick();
        assert.equal(sourceScene.loading, false);
        assert.deepEqual(state.loadingEvents, [name + ':open', name + ':close']);
        assert.deepEqual(state.scenes, ['GameScene']);
    });

    test(name + ' uses valid disk cache without Loading, including Map initialization and replay', async () => {
        const { manager, config, state, collect, createScene, map } = fixture();
        await manager.cacheAllFiles();
        state.logs.length = 0;
        state.scene = createScene(name);
        const sourceScene = state.scene, Config = config();
        const current = level(50).BLOCK_INFO[0], next = level(51).BLOCK_INFO[0];
        const wanted = sorted([...collect(current), ...collect(next)]);
        Config.applyLevelData(level(50), false, 0, 50);
        const held = collect(next).find(image => !collect(current).includes(image));
        state.hold.add(held);
        const downloads = state.downloads;
        Config.enterGameSceneWhenReady();
        await tick();
        assert.equal(sourceScene.loading, false);
        assert.equal(state.scenes.length, 0, 'cached files must still finish decoding before entry');
        assert.deepEqual(state.loadingEvents, []);
        state.deferred.get(held)();
        await tick();
        assert.deepEqual(state.scenes, ['GameScene']);
        const cachedLogs = state.logs.map(args => args[0]).filter(line => line.includes('[进关来源]'));
        assert.equal(cachedLogs.length, wanted.length);
        assert.ok(cachedLogs.every(line => line.includes('-> 本地缓存')));
        for (const image of wanted) assert.ok(cachedLogs.some(line => line.includes(image + '.png')));
        await map().prepareBlockAssets();
        assert.equal(state.mapsInitialized, 1);
        assert.deepEqual(state.jsonLoads, ['Json/level51'], 'only next JSON is memoized');
        assert.deepEqual(state.loadingEvents, [], 'Map must not flash Loading after a prepared entry');
        state.logs.length = 0;
        const loads = state.loads.length;
        Config.enterGameSceneWhenReady();
        await tick();
        const memoryLogs = state.logs.map(args => args[0]).filter(line => line.includes('[进关来源]'));
        assert.equal(memoryLogs.length, wanted.length, 'replay must log sources again even with the same BLOCK_INFO');
        assert.ok(memoryLogs.every(line => line.includes('-> 内存复用')));
        assert.ok(state.logs.some(args => args[0].includes('当前关50 / 下一关51')));
        assert.equal(state.loads.length, loads);
        assert.equal(state.downloads, downloads);
        assert.deepEqual(state.loadingEvents, []);
    });

    test(name + ' opens Loading if a cached image fails decoding and needs a remote retry', async () => {
        const { manager, config, state, collect, createScene, url, userFile } = fixture();
        await manager.cacheAllFiles();
        state.logs.length = 0;
        state.scene = createScene(name);
        const sourceScene = state.scene, Config = config();
        Config.applyLevelData(level(50), false, 0, 50);
        const bad = collect(level(50).BLOCK_INFO[0])[0];
        state.disk.set(userFile(bad), 'corrupt');
        state.nativeFiles.delete(url(bad) + '@native');
        state.hold.add(bad);
        state.hold.add('download:' + bad);
        Config.enterGameSceneWhenReady();
        await tick();
        assert.deepEqual(state.loadingEvents, [], 'file existence alone does not open Loading');
        state.hold.delete(bad);
        state.deferred.get(bad)();
        await waitFor(() => state.deferred.has('download:' + bad), 'remote replacement starts after decode failure');
        assert.equal(sourceScene.loading, true, 'decode failure must notify the entry before retry');
        assert.equal(state.scenes.length, 0);
        state.hold.delete('download:' + bad);
        state.deferred.get('download:' + bad)();
        await tick();
        assert.deepEqual(state.loadingEvents, [name + ':open', name + ':close']);
        assert.deepEqual(state.scenes, ['GameScene']);
        assert.equal(state.downloads, filePaths.length + 1);
        const lines = state.logs.map(args => args[0]).filter(line => line.includes(bad + '.png'));
        assert.ok(lines.some(line => line.includes('-> 本地缓存')));
        assert.ok(lines.some(line => line.includes('-> 远程下载')));
        assert.ok(lines.some(line => line.includes('[远程加载] 开始') && line.includes('进关重试')));
        assert.ok(lines.some(line => line.includes('[远程加载] 成功')));
    });
}

test('each image source distinguishes memory, disk, temporary cache and actual remote need', async () => {
    const { manager, state, url } = fixture();
    await manager.prepareWindow([{ block: 0, color: 1 }], []);
    state.logs.length = 0;
    state.caches.set(url('2color1'), 'disk.png');
    state.disk.set('disk.png', 'valid');
    state.caches.set(url('3color2'), 'evicted.png');
    state.temps.set(url('3color2'), 'temp.png');
    state.disk.set('temp.png', 'valid');
    state.nativeFiles.set(url('5color4') + '@native', 'native.png');
    state.disk.set('native.png', 'valid');
    let remoteNotifications = 0;
    await manager.prepareWindow([{ block: 0, color: 1 }, { block: 1, color: 2 }, { block: 2, color: 3 }],
        [{ block: 3, color: 4 }, { block: 4, color: 5 }],
        { currentLevel: 50, nextLevel: 51, onRemoteRequired: () => remoteNotifications++ });
    assert.equal(remoteNotifications, 1);
    assert.equal(state.downloads, 2, 'valid temporary/native files survive a stale persistent index');
    for (const [name, source, whichLevel] of [
        ['1color0', '内存复用', '当前关50'], ['2color1', '本地缓存', '当前关50'],
        ['3color2', '临时缓存', '当前关50'], ['4color3', '远程下载', '下一关51'], ['5color4', '临时缓存', '下一关51']
    ]) assert.ok(state.logs.some(args => args[0].includes(`${whichLevel} ${name}.png -> ${source}`)));
    const starts = state.logs.map(args => args[0]).filter(line => line.includes('[远程加载] 开始'));
    assert.equal(starts.length, 1);
    assert.ok(starts[0].includes(url('4color3')));
});

test('temporary files are usable without Loading even when persistence has not completed', async () => {
    const { manager, state, config, Manager, map, collect, url } = fixture();
    await manager.initialize();
    const wanted = sorted([...collect(level(50).BLOCK_INFO[0]), ...collect(level(51).BLOCK_INFO[0])]);
    for (const name of wanted) {
        const temp = 'legacy-temp/' + name;
        state.temps.set(url(name), temp);
        state.disk.set(temp, 'valid');
    }
    assert.equal(JSON.parse(state.storage.get(Manager.CACHE_KEY)).complete, false);
    state.logs.length = 0;
    const Config = config();
    Config.applyLevelData(level(50), false, 0, 50);
    Config.enterGameSceneWhenReady();
    await waitFor(() => state.scenes.length === 1, 'temporary images finish decoding');
    await map().prepareBlockAssets();
    assert.deepEqual(state.scenes, ['GameScene']);
    assert.deepEqual(state.loadingEvents, []);
    assert.equal(state.downloads, 0);
    const sources = state.logs.map(args => args[0]).filter(line => line.includes('[进关来源]'));
    assert.ok(sources.length > 0 && sources.every(line => line.includes('-> 临时缓存')));
});

test('foreground waiting for a background download shows Loading and shares the file request', async () => {
    const { manager, state, config, collect, url, userFile } = fixture();
    await manager.cacheAllFiles();
    const Config = config(), sourceScene = state.scene;
    Config.applyLevelData(level(50), false, 0, 50);
    const missing = collect(level(50).BLOCK_INFO[0])[0];
    state.disk.delete(userFile(missing));
    state.logs.length = 0;
    state.hold.add('download:' + missing);
    // Use event-loop yields here so a held foreground request cannot starve the background pause.
    manager.delay = tick;
    const background = manager.cacheAllFiles();
    for (let i = 0; i < filePaths.length * 2 && !state.deferred.has('download:' + missing); i++) await tick();
    assert.equal(state.deferred.has('download:' + missing), true);
    assert.deepEqual(state.loadingEvents, [], 'background downloads alone remain silent');
    Config.enterGameSceneWhenReady();
    await tick();
    assert.equal(sourceScene.loading, true);
    assert.equal(state.scenes.length, 0);
    assert.ok(state.logs.some(args => args[0].includes('[远程加载] 等待后台下载 ' + missing + '.png')));
    state.deferred.get('download:' + missing)();
    await background;
    await tick();
    assert.deepEqual(state.scenes, ['GameScene']);
    assert.deepEqual(state.loadingEvents, ['HomeScene:open', 'HomeScene:close']);
    assert.equal(state.downloads, filePaths.length + 1, 'only one shared download');
    for (const phase of ['开始', '成功']) {
        assert.ok(state.logs.some(args => args[0].includes(`[远程下载] ${phase} ${missing}.png`) && args[0].includes(url(missing))));
    }
});

test('a superseded entry cannot close the latest entry Loading', async () => {
    const { config, state } = fixture();
    const Config = config(), pending = [], sourceScene = state.scene;
    Config.prepareBlockWindow = onRemoteRequired => {
        onRemoteRequired();
        return new Promise(resolve => pending.push(resolve));
    };
    Config.enterGameSceneWhenReady();
    Config.enterGameSceneWhenReady();
    pending[0](true);
    await tick();
    assert.equal(sourceScene.loading, true);
    assert.equal(state.scenes.length, 0);
    pending[1](true);
    await tick();
    assert.equal(sourceScene.loading, false);
    assert.deepEqual(state.scenes, ['GameScene']);
});

test('late remote notifications cannot open Loading for cancelled entries or a different scene', async () => {
    const { config, state, createScene } = fixture();
    const Config = config(), pending = [];
    Config.prepareBlockWindow = onRemoteRequired => new Promise(resolve => pending.push({ onRemoteRequired, resolve }));
    Config.enterGameSceneWhenReady();
    Config.enterGameSceneWhenReady();
    pending[0].onRemoteRequired();
    assert.deepEqual(state.loadingEvents, []);
    state.scene = createScene('GameScene');
    pending[1].onRemoteRequired();
    assert.deepEqual(state.loadingEvents, [], 'must not find and open the new scene controller');
    pending.forEach(request => request.resolve(true));
    await tick();
    assert.deepEqual(state.scenes, []);
});

test('current JSON retrieval and failure do not show image Loading; remote images on retry do', async () => {
    const { config, state, collect } = fixture();
    const Config = config(), sourceScene = state.scene;
    state.hold.add('Json/level50');
    state.fail.add('Json/level50');
    Config.LEVEL_INFO_init(true, 0, false);
    assert.equal(sourceScene.loading, false);
    await tick();
    state.deferred.get('Json/level50')();
    assert.equal(sourceScene.loading, false);
    assert.equal(state.errors.length, 1);
    assert.equal(state.scenes.length, 0);
    assert.deepEqual(state.loadingEvents, []);
    state.fail.clear();
    state.hold.delete('Json/level50');
    const held = collect(level(50).BLOCK_INFO[0])[0];
    state.hold.add(held);
    state.errors[0].retry();
    assert.equal(sourceScene.loading, false);
    await tick();
    assert.equal(sourceScene.loading, true);
    state.deferred.get(held)();
    await tick();
    assert.equal(sourceScene.loading, false);
    assert.deepEqual(state.scenes, ['GameScene']);
    assert.equal(Config.GM_INFO.level, 49);
});

test('leaving while current JSON is pending does not enter a stale level or close the new scene Loading', async () => {
    const { config, state, createScene } = fixture();
    const Config = config();
    state.hold.add('Json/level50');
    Config.LEVEL_INFO_init(true, 0, false);
    await tick();
    state.scene = createScene('GameScene');
    state.scene.controller.openLoad();
    state.deferred.get('Json/level50')();
    await tick();
    assert.equal(state.scene.loading, true);
    assert.equal(state.scenes.length, 0);
});

test('GameScene fallback closes Loading on image failure and reopens it for retry', async () => {
    const { config, state, collect, createScene, map } = fixture();
    state.scene = createScene('GameScene');
    const Config = config(), controller = map();
    Config.applyLevelData(level(50), false, 0, 50);
    state.fail.add(collect(level(50).BLOCK_INFO[0])[0]);
    const first = controller.prepareBlockAssets();
    assert.equal(state.scene.loading, false);
    await first;
    assert.equal(state.scene.loading, false);
    assert.equal(state.mapsInitialized, 0);
    assert.equal(state.errors.length, 1);
    state.fail.clear();
    const retry = state.errors[0].retry();
    await retry;
    assert.equal(state.scene.loading, false);
    assert.equal(state.mapsInitialized, 1);
    assert.equal(controller.blockAssetsReady, true);
    assert.deepEqual(state.loadingEvents, ['GameScene:open', 'GameScene:close', 'GameScene:open', 'GameScene:close']);
});

test('malformed next-level JSON rejects with a retry instead of leaving the load pending', async () => {
    const { config, state } = fixture();
    const Config = config();
    Config.applyLevelData(level(50), false, 0, 50);
    state.badJson.add('Json/level51');
    Config.enterGameSceneWhenReady();
    await tick();
    assert.equal(state.scenes.length, 0);
    assert.equal(state.errors.length, 1);
    state.badJson.clear();
    state.errors[0].retry();
    await tick();
    assert.deepEqual(state.scenes, ['GameScene']);
});

test('an old scene-entry request cannot change scenes after the player has left', async () => {
    const { config, state, collect } = fixture();
    const Config = config();
    Config.applyLevelData(level(50), false, 0, 50);
    const held = collect(level(50).BLOCK_INFO[0])[0];
    state.hold.add(held);
    Config.enterGameSceneWhenReady();
    await tick();
    state.scene = { name: 'AnotherScene' };
    state.deferred.get(held)();
    await tick();
    assert.equal(state.scenes.length, 0);
    assert.equal(state.errors.length, 0);
});

test('returning to a level after its request was cancelled can prepare it again', async () => {
    const { config, state, collect } = fixture();
    const Config = config(), original = level(50);
    Config.applyLevelData(original, false, 0, 50);
    const held = collect(original.BLOCK_INFO[0])[0];
    state.hold.add(held);
    const first = Config.prepareBlockWindow();
    await tick();
    Config.applyLevelData(level(53), false, 0, 53);
    state.deferred.get(held)();
    assert.equal(await first, false);
    Config.applyLevelData(original, false, 0, 50);
    assert.equal(await Config.prepareBlockWindow(), true);
});

test('endless preload and actual next level consume the same random selection', async () => {
    const { config, cc, state } = fixture();
    const Config = config();
    Config.GM_INFO.level = 1920;
    Config.GM_INFO.GameplayType = 1;
    cc.fx.GameTool.getPurelyRandom = () => 52;
    Config.applyLevelData(level(50), false, 0, 50);
    await Config.prepareBlockWindow();
    assert.deepEqual(state.jsonLoads, ['Json/level52']);
    assert.equal(cc.fx.GameTool.getNextLevel(), 52);
    assert.equal(Config.nextEndlessLevel, 0);
});