'use strict';
const v = require('./validation');
// Network/filesystem are injected so publication, retries and login deadlines can be tested offline.
function create(builtin, io, sha256, options = {}) {
    const perf = io.perf || require('./perf').create();
    v.builtin(builtin);
    const environment = options.environment || 'production';
    const warn = error => io.warn && io.warn(error);
    const now = () => io.now();
    const sleep = ms => io.sleep ? io.sleep(ms) : new Promise(resolve => setTimeout(resolve, ms));
    const readState = key => { try { return perf.measure('state.read.' + key.split(':')[0], () => io.readState(key)); } catch (_) { return null; } };
    const save = (key, value) => { try { perf.measure('state.write.' + key.split(':')[0], () => io.writeState(key, value)); } catch (e) { warn(e); } };
    let current = null;
    try { current = v.manifest(readState('manifest'), builtin.contentVersion, environment); } catch (_) {}
    let index = readState('index') || {};
    if (!index || typeof index !== 'object' || Array.isArray(index)) index = {};
    let epoch = 0, started = 0, refreshed = false, refreshing = null, limits = null;
    let active = true, online = true, nextId = 1, mainGroup = 'A', protectAll = false;
    let allReadyRelease = null, playing = null;
    let cacheRevision = 0, maintainedRevision = -1, maintainedManifest = null, maintainedAt = -Infinity, collecting = null, allDemand = false;
    const holds = new Set(), waiters = new Set();
    const entryWaiters = new Set();
    const entryError = code => Object.assign(Error('关卡读取失败，请连接网络！'), { code });
    // Only the caller's foreground wait is cancelled. Shared downloads may still populate cache.
    function waitForEntry(task) {
        if (!online) return Promise.reject(entryError('LEVEL_OFFLINE'));
        let timer, fail;
        return new Promise((resolve, reject) => {
            fail = error => reject(error);
            entryWaiters.add(fail);
            timer = setTimeout(() => fail(entryError('LEVEL_TIMEOUT')), options.entryTimeoutMs || 60000);
            Promise.resolve().then(task).then(resolve, reject);
        }).finally(() => { clearTimeout(timer); entryWaiters.delete(fail); });
    }
    const work = new Map(), downloads = new Map(), packs = new Map(), pins = new Map();
    const prefetching = new Map();
    let lastPrefetch = null;
    const cancelled = () => Error('关卡准备已取消');
    function guard(token) { if (token !== epoch) throw cancelled(); }
    function wake() { for (const resolve of waiters) resolve(); waiters.clear(); }
    function holdBackground() {
        const hold = {}; holds.add(hold); perf.emit('background.hold', { count: holds.size });
        return () => { if (holds.delete(hold)) { perf.emit('background.release', { count: holds.size }); wake(); } };
    }
    async function checkpoint(token, background = () => false) {
        guard(token);
        while (!active || !online || (holds.size && background())) { await new Promise(resolve => waiters.add(resolve)); guard(token); }
    }
    function retry(key, task) {
        const token = epoch, fullKey = token + ':' + key;
        if (work.has(fullKey)) return work.get(fullKey);
        const job = (async () => {
            let attempt = 0;
            for (;;) {
                await checkpoint(token);
                try { const result = await task(); guard(token); return result; }
                catch (error) {
                    guard(token); warn(error);
                    perf.emit('retry', { task: key, attempt: attempt + 1, delayMs: [2000, 5000, 10000, 30000, 60000][Math.min(attempt, 4)] });
                    await sleep([2000, 5000, 10000, 30000, 60000][Math.min(attempt++, 4)]);
                }
            }
        })().finally(() => work.delete(fullKey));
        work.set(fullKey, job); job.catch(() => {}); return job;
    }
    function background(key, task) { retry(key, task).catch(warn); }
    function refresh() {
        if (refreshed) return Promise.resolve(current);
        if (refreshing) return refreshing;
        const token = epoch;
        const finish = perf.begin('manifest.refresh', { epoch: token });
        const job = (async () => {
            await checkpoint(token);
            const response = await io.fetchManifest();
            const m = perf.measure('manifest.validate', () => v.manifest(response, builtin.contentVersion, environment));
            guard(token); current = m; refreshed = true; allReadyRelease = null; save('manifest', m);
            perf.emit('manifest.ready', { release: m.release, A: m.groups.A.resourceCount, B: m.groups.B.resourceCount });
            return m;
        })().then(value => { finish({ status: 'ok' }); return value; }, error => { finish({ status: 'error' }); throw error; })
            .finally(() => { if (refreshing === job) refreshing = null; });
        refreshing = job; return job;
    }
    function beginLogin(data = {}) {
        for (const fail of entryWaiters) fail(cancelled());
        perf.session({ version: data.version, environment, cachedRelease: current && current.release });
        epoch++; holds.clear(); wake(); prefetching.clear(); lastPrefetch = null; allDemand = false; collecting = null; maintainedManifest = null; refreshing = null; refreshed = false; started = now(); allReadyRelease = null; protectAll = false; playing = null;
        const key = 'policy:' + String(data.version || 'unknown');
        const old = readState(key) || {};
        const validMax = n => v.integer(n, 100);
        const maxLevel = validMax(data.maxLevel) ? data.maxLevel : validMax(old.maxLevel) ? old.maxLevel : options.defaultMaxLevel || 2040;
        const validB = n => v.integer(n) && n <= maxLevel;
        const bLevelCount = validB(data.bLevelCount) ? data.bLevelCount : validB(old.bLevelCount) ? old.bLevelCount : 0;
        // Group assignment is never inferred from the retired new1_50 experiment or from N alone.
        mainGroup = data.levelGroup === 'B' && bLevelCount > 0 ? 'B' : 'A';
        limits = { maxLevel, bLevelCount, levelGroup: mainGroup };
        perf.emit('policy', limits);
        save(key, { maxLevel, bLevelCount });
        background('manifest', refresh);
        return Object.assign({}, limits);
    }
    function groupFor(id, group = mainGroup) { return group === 'B' && limits && id <= limits.bLevelCount ? 'B' : 'A'; }
    function parse(bytes, entry) {
        v.entry(entry);
        v.check(bytes && bytes.byteLength === entry.size && perf.measure('json.sha256', () => sha256(new Uint8Array(bytes)), bytes.byteLength) === entry.hash, '关卡文件校验失败');
        const text = perf.measure('json.decode', () => io.decode(bytes), bytes.byteLength);
        return perf.measure('json.parseValidate', () => v.level(JSON.parse(text)), bytes.byteLength);
    }
    async function read(g, id, e) {
        if (!e) return null;
        try {
            const local = builtin.groups[g][id];
            if (local && local.hash === e.hash) {
                try {
                    const bytes = await perf.measureAsync('file.readBuiltin', () => io.readLocal(local.file), e.size);
                    const data = parse(bytes, e); perf.metric('source.builtin', 0);
                    return { data, group: g, id, hash: e.hash };
                } catch (_) { perf.metric('source.builtinInvalid', 0); }
            }
            if (io.hasCache && io.hasCache(g, id, e.hash) === false) { perf.metric('source.absentSkipped', 0); return null; }
            const bytes = await perf.measureAsync('file.readCache', () => io.readCache(g, id, e.hash), e.size);
            const data = parse(bytes, e); perf.metric('source.cache', 0);
            return { data, group: g, id, hash: e.hash };
        } catch (_) { perf.metric('source.missingOrInvalid', 0); return null; }
    }
    async function available(g, id, m = current, skipHash = null) {
        const target = m && m.groups[g].levels[id];
        const old = index[g + '/' + id];
        const seen = new Set(skipHash ? [skipHash] : []);
        for (const e of [target, old && old.entry, builtin.groups[g][id]]) {
            if (!e || seen.has(e.hash)) continue;
            seen.add(e.hash);
            const data = await read(g, id, e);
            if (data) {
                if (old && e === old.entry) old.used = now();
                if (target && data.hash !== target.hash) perf.metric('source.oldFallback', 0);
                return data;
            }
        }
        return null;
    }
    function remember(g, id, e) {
        const key = g + '/' + id, old = index[key];
        index[key] = { entry: e, used: now() };
        const changed = !old || !old.entry || old.entry.hash !== e.hash;
        if (changed) cacheRevision++;
        return changed;
    }
    function single(m, g, id, foreground = true, demanded = () => false) {
        const e = m.groups[g].levels[id];
        if (!e) return Promise.reject(Error('当前资源清单缺少关卡 ' + g + '/' + id));
        const token = epoch, key = token + ':' + g + '/' + id + '/' + e.hash;
        if (downloads.has(key)) {
            const existing = downloads.get(key);
            const previousDemand = existing.demanded;
            existing.demanded = () => previousDemand() || demanded();
            if (foreground) { existing.foreground = true; wake(); }
            else if (demanded()) wake();
            return existing.promise;
        }
        const job = { foreground, demanded, promise: null }, isBackground = () => !job.foreground && !job.demanded();
        const task = (async () => {
            await checkpoint(token, isBackground);
            if (await read(g, id, e)) { guard(token); if (remember(g, id, e)) save('index', index); return; }
            await checkpoint(token, isBackground);
            const bytes = await io.fetchFile(Object.assign({ file: v.levelFile(g, id, e) }, e));
            parse(bytes, e); guard(token);
            await checkpoint(token, isBackground);
            await io.writeCache(g, id, e.hash, bytes); guard(token);
            remember(g, id, e); save('index', index);
        })().finally(() => downloads.delete(key));
        job.promise = task; downloads.set(key, job); return task;
    }
    function repair(m, g, id) { if (m && m.groups[g].levels[id]) background('level:' + g + '/' + id + '/' + m.groups[g].levels[id].hash, () => single(m, g, id, false)); }
    async function load(id, group = mainGroup) {
        v.check(limits && v.integer(id, 1) && id <= limits.maxLevel, '关卡超出登录开放范围');
        const token = epoch, g = groupFor(id, group), pin = g + '/' + id; pins.set(pin, (pins.get(pin) || 0) + 1);
        const finish = perf.begin('level.load', { id, group: g, epoch: token });
        let status = 'error', source = 'download';
        try {
            let data = await available(g, id);
            guard(token);
            if (data) {
                playing = pin;
                const target = current && current.groups[g].levels[id];
                if (target && data.hash !== target.hash) repair(current, g, id);
                status = 'ok'; source = 'local'; return data;
            }
            data = await waitForEntry(async () => {
                const m = current || await refresh();
                await single(m, g, id); guard(token);
                return read(g, id, m.groups[g].levels[id]);
            });
            guard(token); v.check(data, '关卡缓存不可用'); playing = pin; status = 'ok'; return data;
        } finally { finish({ status, source }); const count = pins.get(pin) - 1; if (count) pins.set(pin, count); else pins.delete(pin); }
    }
    function indexed(g, id, entry) {
        if (!entry) return false;
        const local = builtin.groups[g][id];
        // The runtime inventory comes from committed package catalogs / standalone filenames.
        // Never treat the logical usage index alone as proof that a file is installed.
        return !!((local && local.hash === entry.hash) || (io.hasCache && io.hasCache(g, id, entry.hash)));
    }
    async function ensurePack(m, g, name, allowOld = true) {
        const p = m.groups[g].packs[name];
        if (!p) throw Error('关卡包尚未发布：' + g + '/' + name);
        const token = epoch, key = token + ':' + g + '/' + name + '/' + p.hash + '/' + allowOld;
        if (packs.has(key)) return packs.get(key);
        const finish = perf.begin('pack.ensure', { group: g, pack: name, count: p.end - p.start + 1 });
        const isBackground = () => !(name === 'all' && allDemand);
        const task = (async () => {
            const scanStarted = now();
            const missing = [];
            for (let id = p.start; id <= p.end; id++) {
                await checkpoint(token, isBackground);
                const e = m.groups[g].levels[id];
                if (!indexed(g, id, e)) {
                    const cached = index[g + '/' + id];
                    const old = allowOld && (indexed(g, id, cached && cached.entry) || indexed(g, id, builtin.groups[g][id]));
                    if (old) repair(m, g, id); else missing.push(id);
                }
                if (id % 16 === 0) await sleep(0);
            }
            guard(token);
            perf.emit('pack.scan', { group: g, pack: name, mode: 'metadata', ms: now() - scanStarted, scanned: p.end - p.start + 1, missing: missing.length });
            if (!missing.length) return;
            const bytesMissing = missing.reduce((sum, id) => sum + m.groups[g].levels[id].size, 0);
            perf.emit('pack.strategy', { group: g, pack: name, strategy: missing.length > 4 && bytesMissing >= p.size ? 'zip' : 'single', bytesMissing, zipBytes: p.size });
            if (missing.length > 4 && bytesMissing >= p.size) {
                await checkpoint(token, isBackground);
                const archive = await io.fetchPack(m, g, Object.assign({ file: v.packFile(g, name, p) }, p), () => checkpoint(token, isBackground));
                const installed = perf.begin('zip.install', { group: g, pack: name, missing: missing.length });
                let count = 0, status = 'error';
                try {
                    await checkpoint(token, isBackground);
                    await archive.install(); guard(token);
                    for (const id of missing) {
                        // Per-level hashes come from the manifest belonging to the verified ZIP.
                        remember(g, id, m.groups[g].levels[id]); count++;
                    }
                    status = 'ok';
                } finally {
                    // The directory and its lookup metadata commit together before the logical index.
                    try { if (token === epoch && count) save('index', index); }
                    finally { try { await archive.dispose(); } finally { installed({ status, installed: count }); } }
                }
            } else {
                for (let i = 0; i < missing.length; i += 3) {
                    await checkpoint(token, isBackground);
                    await Promise.all(missing.slice(i, i + 3).map(id => single(m, g, id, false, () => !isBackground())));
                }
            }
        })().then(value => { finish({ status: 'ok' }); return value; }, error => { finish({ status: 'error' }); throw error; }).finally(() => packs.delete(key));
        packs.set(key, task); return task;
    }
    function ensureAll(foreground = false) {
        protectAll = true;
        if (allReady()) return Promise.resolve(true);
        if (foreground) { allDemand = true; wake(); }
        return retry('all', async () => {
            const token = epoch;
            const m = refreshed ? current : await refresh().catch(error => { if (current) return current; throw error; });
            await maintain(); guard(token);
            await ensurePack(m, 'A', 'all'); guard(token);
            // A later successful login manifest supersedes an offline snapshot while this task was running.
            if (m !== current) throw Error('资源清单已更新，继续准备完整关卡池');
            allReadyRelease = m.release;
            await maintain(true); allDemand = false; return true;
        });
    }
    function allReady() { return !!(current && allReadyRelease === current.release); }
    function cacheIdentity(file) {
        const match = /^([AB])\/([1-9][0-9]*)\.([a-f0-9]{64})\.json$/.exec(file);
        return match && { group: match[1], id: Number(match[2]), hash: match[3], key: match[1] + '/' + match[2] };
    }
    function keepFile(file) {
        const f = cacheIdentity(file); if (!f) return false;
        const target = current && current.groups[f.group].levels[f.id], old = index[f.key];
        return !!((target && target.hash === f.hash) || (old && old.entry && old.entry.hash === f.hash));
    }
    function protectFile(file) {
        const f = cacheIdentity(file); if (!f) return false;
        return (protectAll && f.group === 'A' && keepFile(file)) || playing === f.key || pins.has(f.key)
            || (f.id >= nextId && f.id <= nextId + 12 && f.group === groupFor(f.id));
    }
    function maintain(force = false) {
        if (!io.collect || !current) return Promise.resolve();
        if (collecting) return collecting;
        if (!force && maintainedManifest === current && maintainedRevision === cacheRevision && now() - maintainedAt < 10000) {
            perf.metric('cache.maintenanceSkipped', 0); return Promise.resolve();
        }
        const token = epoch;
        const task = (async () => {
            await checkpoint(token, () => !allDemand);
            const finish = perf.begin('cache.maintain', { protectAll }), m = current, revision = cacheRevision;
            try {
                const buildStarted = now();
                const files = io.listCache ? io.listCache() : Object.keys(index).filter(key => index[key] && index[key].entry)
                    .map(key => key + '.' + index[key].entry.hash + '.json');
                const keep = new Set(), protect = new Set();
                for (const file of files) { if (keepFile(file)) keep.add(file); if (protectFile(file)) protect.add(file); }
                perf.emit('cache.plan', { files: files.length, ms: now() - buildStarted });
                const collected = await io.collect(keep, protect, options.cacheBudgetBytes || 32 * 1024 * 1024,
                    { checkpoint: () => checkpoint(token, () => !allDemand), keep: keepFile, protect: protectFile,
                        size: file => {
                            const f = cacheIdentity(file); if (!f) return null;
                            const entries = [current.groups[f.group].levels[f.id], index[f.key] && index[f.key].entry, builtin.groups[f.group][f.id]];
                            const entry = entries.find(e => e && e.hash === f.hash);
                            return entry ? entry.size : null;
                        } });
                if (collected === false) return;
                guard(token); maintainedManifest = m; maintainedRevision = revision; maintainedAt = now();
            } finally { finish(); }
        })().finally(() => { if (collecting === task) collecting = null; });
        collecting = task; return task;
    }
    function prefetch(id, group = mainGroup) {
        const key = epoch + ':' + group + '/' + id;
        if (prefetching.has(key)) { perf.metric('prefetch.joined', 0); return prefetching.get(key); }
        if (refreshed && lastPrefetch && lastPrefetch.key === key && lastPrefetch.manifest === current && lastPrefetch.revision === cacheRevision) {
            perf.metric('prefetch.unchangedSkipped', 0); return Promise.resolve();
        }
        const token = epoch;
        const task = prefetchOnce(id, group).then(snapshot => {
            guard(token); lastPrefetch = Object.assign({ key }, snapshot);
        }).finally(() => { if (prefetching.get(key) === task) prefetching.delete(key); });
        prefetching.set(key, task); return task;
    }
    async function prefetchOnce(id, group) {
        const finish = perf.begin('mainline.prefetch', { id, group });
        try {
        nextId = id;
        const token = epoch, m = refreshed ? current : await refresh(); guard(token);
        await checkpoint(token, () => true);
        const snapshot = { manifest: m, revision: cacheRevision };
        if (id > limits.maxLevel) { ensureAll().catch(warn); return snapshot; }
        // Repair only locally owned unpassed mainline resources. Past levels are checked on real use.
        const owned = new Set(Object.keys(index));
        const scanStarted = now(); let checked = 0, repairs = 0;
        for (const g of ['A', 'B']) for (const localId of Object.keys(builtin.groups[g])) owned.add(g + '/' + localId);
        for (const key of owned) {
            await checkpoint(token, () => true);
            const [g, text] = key.split('/'), n = Number(text);
            if (n >= id && n <= limits.maxLevel && g === groupFor(n, group) && m.groups[g].levels[n]) {
                checked++;
                // Repair discovery uses metadata, not a read/hash/parse of every owned JSON.
                // Actual use (load/single) still verifies bytes and recovers missing/corrupt files.
                const target = m.groups[g].levels[n], cached = index[key] && index[key].entry, local = builtin.groups[g][n];
                if ((!cached || cached.hash !== target.hash) && (!local || local.hash !== target.hash)) {
                    repairs++; repair(m, g, n);
                }
            }
        }
        guard(token);
        perf.emit('prefetch.scan', { id, owned: owned.size, checked, repairs, mode: 'metadata', ms: now() - scanStarted });
        const g = groupFor(id, group), localCount = Object.keys(builtin.groups[g]).length;
        if (id > localCount || id >= localCount - 10) {
            const key = String(Math.floor((id - 1) / 100) * 100 + 1);
            if (m.groups[g].packs[key]) background('pack:' + g + '/' + key, () => ensurePack(m, g, key));
        }
        // Resolve every look-ahead ID through N, including an A/B boundary or a partial built-in range.
        for (let n = id; n <= Math.min(id + 11, limits.maxLevel); n++) {
            const targetGroup = groupFor(n, group), start = Math.floor((n - 1) / 100) * 100 + 1;
            if (m.groups[targetGroup].packs[start] && !builtin.groups[targetGroup][n])
                background('pack:' + targetGroup + '/' + start, () => ensurePack(m, targetGroup, String(start)));
        }
        if (id >= limits.maxLevel - 10) ensureAll().catch(warn);
        await maintain();
        return snapshot;
        } finally { finish(); }
    }
    async function prepareLogin(id, group = mainGroup) {
        const finish = perf.begin('login.levelGate', { id, group, elapsedSinceLoginMs: now() - started });
        let status = 'error', urgentReady = false;
        try {
        v.check(limits, '尚未收到登录关卡配置'); nextId = id;
        const token = epoch, endless = id > limits.maxLevel;
        const urgent = (async () => {
            const m = await refresh(); guard(token);
            if (endless) return ensureAll();
            await Promise.all([id, id + 1, id + 2].filter(n => n <= limits.maxLevel).map(n => single(m, groupFor(n, group), n)));
        })();
        urgent.then(() => { urgentReady = true; }, warn);
        background('mainline-prefetch', () => prefetch(id, group));
        if (endless) ensureAll().catch(warn);
        const remaining = Math.max(0, (options.loginBudgetMs === undefined ? 8000 : options.loginBudgetMs) - (now() - started));
        await Promise.race([urgent.catch(() => sleep(remaining)), sleep(remaining)]); guard(token);
        if (endless) { status = allReady() ? 'allReady' : 'homeReleasedPreparingAll'; return; }
        const ready = await available(groupFor(id, group), id);
        guard(token); v.check(ready, '当前关卡尚未准备好，请重试');
        status = urgentReady ? 'urgentReady' : 'localFallback';
        } finally { finish({ status, urgentReady }); perf.flush(); }
    }
    return { beginLogin, prepareLogin, load, prefetch, ensureAll, allReady, refresh, maintain, holdBackground,
        limits: () => limits, groupFor,
        setActive(value) { active = !!value; wake(); }, setOnline(value) {
            online = !!value;
            if (!online) for (const fail of entryWaiters) fail(entryError('LEVEL_OFFLINE'));
            wake();
        },
        dispose() { epoch++; holds.clear(); for (const fail of entryWaiters) fail(cancelled()); wake(); active = true; online = true; }
    };
}
module.exports = { create };