// Run with TypeScript 4.9+ available through NODE_PATH (or TYPESCRIPT_PATH).
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 configPath = 'assets/Script/module/Config/StarterPack.ts';
const giftPath = 'assets/action_bundle/script/NewbieGift.ts';
const homePath = 'assets/Script/JiaZai.ts';
const utilsPath = 'assets/Script/module/Pay/Utils.ts';
const source = file => ts.createSourceFile(file, fs.readFileSync(path.join(root, file), 'utf8'), ts.ScriptTarget.Latest, true);
function compile(code, globals) {
    return vm.runInNewContext(ts.transpileModule(code, { compilerOptions: {
        target: ts.ScriptTarget.ES2017, module: ts.ModuleKind.CommonJS, experimentalDecorators: true,
    } }).outputText, globals);
}
function moduleFrom(file, globals, imports = {}) {
    const exports = {};
    compile(fs.readFileSync(path.join(root, file), 'utf8'), { ...globals, exports, require(name) {
        if (!(name in imports)) throw new Error('Unmocked import: ' + name);
        return imports[name];
    } });
    return exports;
}
function methods(file, names, globals) {
    const ast = source(file), cls = ast.statements.find(ts.isClassDeclaration);
    const parts = names.map(name => {
        const member = cls.members.find(m => m.name?.getText(ast) === name);
        assert.ok(member, name); return member.getText(ast);
    });
    return compile(`class ${cls.name.text} { ${parts.join('\n')} }\n${cls.name.text};`, globals);
}
function fixture() {
    let now = 1800000000000;
    const timers = [], storage = new Map(), events = [], calls = [];
    const info = { uid: 'u1', level: 15, canIos: true, iosCanPay: true, starter_packTime: (now + 172800000) / 1000,
        starterPackPurchased: false, starterPackServerOffset: 0, iosStarterOrder: '' };
    class TestDate extends Date { constructor(...args) { super(...(args.length ? args : [now])); } static now() { return now; } }
    const cc = {
        Node: class {}, Label: 'Label', Button: 'Button', Prefab: 'Prefab',
        Component: class { schedule() {} unschedule() {} },
        _decorator: { ccclass: x => x, property: () => () => {} },
        isValid: value => !!value && !value.destroyed,
        fx: { GameConfig: { GM_INFO: info, isGameplayEntryPreparing: () => false },
            StorageMessage: { getStorage: k => storage.get(k), setStorage: (k,v) => storage.set(k,v) },
            GameTool: { shushu_Track() {}, getWechatGameVersion: () => '体验版' } },
        find: (name, node) => node ? name.split('/').reduce((n, part) => n?.children.find(c => c.name === part), node) : null,
        error() {}, sys: { platform: 'web' },
    };
    const globals = { cc, console: { log() {}, warn() {}, error() {} }, Date: TestDate,
        setTimeout: fn => { timers.push(fn); return timers.length; }, clearTimeout() {} };
    const rules = moduleFrom(configPath, globals);
    Object.assign(globals, rules);
    const SDK = { API: { showToast: text => events.push(text), yinli_Pay() {}, shushu_SetSuperProperties() {} } };
    const api = { getStarter_pack: done => done({ code: 1, data: { starter_pack: info.starter_packTime * 1000,
        starter_packState: info.starterPackPurchased ? 1 : 0, serverTime: now } }) };
    globals.Utils = api; globals.MiniGameSdk = SDK;
    // Instantiate the actual authored prefab hierarchy and component bindings.
    const prefab = JSON.parse(fs.readFileSync(path.join(root, 'assets/action_bundle/prefab/newbieGift.prefab')));
    function makeNode(id) {
        const raw = prefab[id];
        const node = { name: raw._name, active: raw._active, opacity: raw._opacity, children: [], components: {},
            getChildByName(name) { return this.children.find(c => c.name === name); },
            getComponent(type) { return this.components[type]; } };
        for (const ref of raw._components || []) {
            const comp = prefab[ref.__id__];
            if (comp.__type__ === 'cc.Label') node.components.Label = { string: comp._string };
            if (comp.__type__ === 'cc.Button') node.components.Button = { interactable: true, clickEvents: comp.clickEvents.map(e => prefab[e.__id__]) };
        }
        node.children = (raw._children || []).map(c => makeNode(c.__id__));
        return node;
    }
    const Gift = moduleFrom(giftPath, globals, {
        '../../Script/JiaZai': { default: class {} },
        '../../Script/LoadingCatAnimation': { default: { play() {}, stop() {} } },
        '../../Script/module/Pay/Utils': { default: api },
        '../../Script/Sdk/MiniGameSdk': { MiniGameSdk: SDK },
        '../../Script/module/Config/StarterPack': rules,
    }).default;
    const gift = new Gift(); gift.node = makeNode(1);
    return { cc, info, globals, rules, gift, api, storage, timers, events, calls, setNow: value => { now = value; }, getNow: () => now };
}

test('authored prefab wiring initializes without old Spine or root-level time nodes', () => {
    const f = fixture(); f.gift.init(true);
    const time = f.cc.find('timeContainer/time', f.gift.node).getComponent('Label');
    assert.equal(time.string, '48:00:00');
    const button = f.cc.find('btnContainer/btn', f.gift.node).getComponent('Button');
    assert.equal(button.clickEvents[0].handler, 'buyProduct');
    assert.equal(button.clickEvents[0].customEventData, 'starter_pack');
    assert.notEqual(f.gift.node.getChildByName('gold_1')?.active, true);
    assert.notEqual(f.gift.node.getChildByName('propBg1')?.active, true);
    f.gift.closeStarter_pack(); assert.equal(f.gift.node.active, false);
    f.gift.node.active = true; f.gift.init(false); assert.equal(button.interactable, true);
});
test('countdown remains HH:MM:SS below one hour and ends at zero without a new order', () => {
    const f = fixture(); f.setNow(f.info.starter_packTime * 1000 - 3599000); f.gift.refreshCountdown();
    assert.equal(f.cc.find('timeContainer/time', f.gift.node).components.Label.string, '00:59:59');
    f.setNow(f.info.starter_packTime * 1000); f.gift.refreshCountdown();
    assert.equal(f.cc.find('timeContainer/time', f.gift.node).components.Label.string, '已结束');
    assert.equal(f.cc.find('btnContainer/btn', f.gift.node).components.Button.interactable, false);
    f.api.buyProp = () => assert.fail('expired order created'); f.gift.buyProduct();
});
test('server clock correction and confirmed purchase win over stale local status', () => {
    const f = fixture();
    f.rules.applyStarterPackStatus({ starter_pack: f.getNow() + 10000, serverTime: f.getNow() + 5000, starter_packState: 0 });
    assert.equal(f.rules.starterPackRemaining(), 5);
    f.info.starterPackPurchased = true;
    f.rules.applyStarterPackStatus({ starter_pack: f.getNow() + 10000, starter_packState: 0 });
    assert.equal(f.rules.starterPackRemaining(), 0);
});
function homeFixture() {
    const f = fixture();
    const Home = methods(homePath, ['checkStarter_pack', 'openStarter_pack', 'startStarter_pack', 'stopStarter_pack'], f.globals);
    const h = new Home(); h.node = { addChild() {} }; h.newbieGift = false;
    h.isHomeRuntimeAlive = () => true; h.deferHomePopupWhileTransfer = () => false;
    h.vibrateButtonClick = () => {}; h.schedule = () => {}; h.unschedule = () => {};
    const button = { getChildByName: () => ({ getComponent: () => ({}) }) };
    h.getStarterPackHomeButton = () => button;
    h.setStarterPackHomeButtonVisible = v => { h.visible = v; };
    let opens = 0;
    f.cc.instantiate = () => ({ active: false, getComponent: () => ({ init() { opens++; }, refreshCountdown() {} }) });
    Home.cachedActionPrefab = {};
    return { ...f, Home, h, opens: () => opens };
}
test('first activation counts today; same-day reentry does not popup; next day does', () => {
    const f = homeFixture();
    f.api.getStarter_pack = done => done({ code: 1, data: { starter_pack: 0, starter_packState: 0 } });
    f.api.setStarter_pack = done => done({ code: 1, data: { starter_pack: f.info.starter_packTime * 1000, starter_packState: 0 } });
    f.h.checkStarter_pack(); assert.equal(f.opens(), 1);
    assert.equal(f.storage.get(f.rules.starterPackPopupKey()), f.rules.starterPackDay());
    f.api.getStarter_pack = f.api.setStarter_pack;
    f.h.actionpNode.active = false; f.h.checkStarter_pack(); assert.equal(f.opens(), 1);
    assert.equal(f.h.visible, true);
    f.setNow(f.getNow() + 86400000); f.h.checkStarter_pack(); assert.equal(f.opens(), 2);
});
test('failed prefab load does not consume daily reminder; account keys differ', () => {
    const f = homeFixture(); f.Home.cachedActionPrefab = null;
    f.h.loadHomeBundleWithDependencies = (name, priority, done) => done(new Error('offline'));
    f.h.checkStarter_pack(); assert.equal(f.storage.size, 0);
    const key = f.rules.starterPackPopupKey(); f.info.uid = 'other'; assert.notEqual(f.rules.starterPackPopupKey(), key);
});
test('eligible level, paid flag and expiry gate automatic popup and homepage entry', () => {
    for (const patch of [{ level: 14 }, { canIos: false }, { starterPackPurchased: true }, { starter_packTime: 0.1 }]) {
        const f = homeFixture(); Object.assign(f.info, patch);
        f.h.checkStarter_pack(); assert.equal(f.opens(), 0);
    }
});
test('one successful payment carries its original order id through polling and claim', () => {
    const f = fixture(); const requests = [];
    f.api.buyProp = (id, count, price, platform, name, done) => { requests.push([id,count,price]); done({ outTradeNo: 'new-order' }); };
    f.api.getPayInfo = (done, order) => { assert.equal(order, 'new-order'); done({ code: 1, data: { pay_state: 2 } }); };
    f.api.setPayInfo = (done, order) => { assert.equal(order, 'new-order'); done({ code: 1, data: 'ok' }); };
    f.cc.fx.GameTool.shopBuy = (id, compensate, data) => requests.push(data.outTradeNo);
    f.gift.buyProduct();
    assert.deepEqual(requests, [['starter_pack',1,300],'new-order']); assert.equal(f.info.starterPackPurchased,true);
});
test('pending order still completes after expiry while a fresh order is forbidden', () => {
    const f = fixture(); f.gift.pendingOrder = 'late'; f.info.starter_packTime = f.getNow()/1000 - 1;
    f.api.buyProp = () => assert.fail('created new order');
    f.api.getPayInfo = (done, order) => { assert.equal(order, 'late'); done({ code: 1, data: { pay_state: 2 } }); };
    f.api.setPayInfo = (done, order) => done({ code: 1, data: 'ok' });
    let grantedOrder; f.cc.fx.GameTool.shopBuy = (id, comp, data) => { grantedOrder = data.outTradeNo; };
    f.gift.onShow(); assert.equal(grantedOrder, 'late'); assert.equal(f.gift.node.active, false);
});
test('client grants 8000/8 for purchases and compensation, ignoring old snapshots and deduplicating order ids', () => {
    const f = fixture();
    const ast = source('assets/Script/module/Tool/GameTool.ts');
    const obj = ast.statements.find(n => ts.isVariableStatement(n) && n.declarationList.declarations.some(d => d.name.getText(ast) === 'GameTool'));
    const method = obj.declarationList.declarations.find(d => d.name.getText(ast) === 'GameTool').initializer.properties.find(m => m.name?.getText(ast) === 'shopBuy');
    const tool = compile(`const tool = { ${method.getText(ast)} }; tool;`, { ...f.globals, MapConroler: { _instance: null } });
    const coins = [], props = [];
    f.cc.fx.GameTool.changeCoin = n => coins.push(n); tool.getShopProp = data => props.push(data);
    tool.shopBuy('starter_pack', false, { outTradeNo: 'old', starterPackVersion: 1, starterPackRewards: { coin: 3000, hammer: 5, freeze: 5, magic_wand: 5 } });
    tool.shopBuy('starter_pack', true, { outTradeNo: 'new', starterPackVersion: 2 });
    tool.shopBuy('starter_pack', false, { outTradeNo: 'new', starterPackVersion: 2 });
    assert.deepEqual(coins, [8000,8000]);
    assert.deepEqual(props.map(p => [p.hammer,p.freeze,p.magic_wand]), [[8,8,8],[8,8,8]]);
});
test('HTTP timeout or empty response terminates once, allowing payment UI to recover', () => {
    const f = fixture(), xhr = { open() {}, setRequestHeader() {}, send() {} };
    f.cc.loader = { getXMLHttpRequest: () => xhr };
    f.cc.fx.GameTool.getWechatGameVersion = () => '开发版';
    const Utils = methods(utilsPath, ['POST'], f.globals); Utils.testHttpip = 'https://test.invalid/';
    const responses = [];
    Utils.POST('limitedTimeEvent', {}, res => responses.push(res));
    xhr.ontimeout(); xhr.onerror(); xhr.readyState=4; xhr.status=0; xhr.responseText=''; xhr.onreadystatechange();
    assert.equal(responses.length,1); assert.equal(responses[0].code,0);
});
test('visible gift still suppresses monthly popup after its daily reminder is recorded', () => {
    const f = fixture(), Home = methods(homePath, ['update'], f.globals);
    const h = new Home(); h.newbieGift = false;
    h.actionpNode = { active: true }; h.monthlyCardNode = { active: true };
    h.update(0); assert.equal(h.monthlyCardNode.active, false);
});
test('time-only activity response can create a 3 yuan order without reward version', () => {
    const f = fixture();
    f.api.getStarter_pack = done => done({ code: 1, data: { starter_pack: f.info.starter_packTime * 1000, starter_packState: 0 } });
    let requested = false;
    f.api.buyProp = (id, count, price, platform, name, done) => {
        requested = true; assert.equal(price, 300); assert.equal(count, 1);
        done({ err: true, errMsg: 'cancelled' });
    };
    f.gift.buyProduct(); assert.equal(requested, true); assert.equal(f.gift.paying, false);
    assert.equal(f.events.includes('礼包正在更新，请稍后重试'), false);
});
test('failed customer-service launch clears the unusable pending order for retry', () => {
    const f = fixture();
    f.api.GoKEFu = (info, done) => { f.info.iosStarterOrder = 'never-created'; done('fail'); };
    f.gift.iosOldPay(); assert.equal(f.info.iosStarterOrder, '');
    assert.equal(f.gift.paying, false);
});
test('foreground events during reward confirmation do not start a second claim', () => {
    const f = fixture(); f.gift.pendingOrder = 'one-order';
    let confirmations = 0, finish;
    f.api.getPayInfo = done => done({ code: 1, data: { pay_state: 2 } });
    f.api.setPayInfo = done => { confirmations++; finish = done; };
    f.cc.fx.GameTool.shopBuy = () => {};
    f.gift.onShow(); f.gift.onShow(); assert.equal(confirmations, 1);
    finish({ code: 1, data: 'ok' });
});

test('legacy iOS success after expiry grants immediately without another acknowledgement', () => {
    const f = fixture(); f.info.iosStarterOrder = 'ios-order'; f.info.starter_packTime = 0.1;
    f.api.getIosPayInfo = (order, done) => {
        assert.equal(order, 'ios-order');
        done({ code: 1, data: { goodsPrice: 300, payment_name: 'starter_pack' } });
    };
    f.api.setPayInfo = () => assert.fail('iOS order already completed by payment query');
    let granted;
    f.cc.fx.GameTool.shopBuy = (id, compensate, context) => { granted = context.outTradeNo; };
    f.gift.onShow();
    assert.equal(granted, 'ios-order'); assert.equal(f.info.iosStarterOrder, '');
    assert.equal(f.gift.node.active, false);
});

test('completed legacy orders clear pending UI without granting again', () => {
    for (const direct of [true, false]) {
        const f = fixture();
        if (direct) f.gift.pendingOrder = 'completed'; else f.info.iosStarterOrder = 'completed';
        f.api.getPayInfo = done => done({ code: 1, data: { pay_state: 1 }, msg: '已领取奖励' });
        f.api.getIosPayInfo = (order, done) => done({ code: 0, data: null, msg: '已经获取到奖励' });
        f.api.setPayInfo = () => assert.fail('completed order acknowledged again');
        f.cc.fx.GameTool.shopBuy = () => assert.fail('completed order granted again');
        f.gift.onShow();
        assert.equal(f.gift.pendingOrder, ''); assert.equal(f.info.iosStarterOrder, '');
        assert.equal(f.gift.polling, false); assert.equal(f.info.starterPackPurchased, true);
    }
});

test('acknowledgement retry retains confirmed order even if the server has completed it', () => {
    const f = fixture(); f.gift.pendingOrder = 'retry-order';
    let polls = 0, confirms = 0, grants = 0;
    f.api.getPayInfo = done => { polls++; done({ code: 1, data: { pay_state: 2 } }); };
    f.api.setPayInfo = (done, order) => {
        assert.equal(order, 'retry-order'); confirms++;
        done(confirms === 1 ? { code: 0 } : { code: 1, data: 'ok' });
    };
    f.cc.fx.GameTool.shopBuy = () => { grants++; };
    f.gift.onShow(); assert.equal(grants, 0);
    f.gift.againGet();
    assert.equal(polls, 1); assert.equal(confirms, 2); assert.equal(grants, 1);
});

test('deadline passing during preflight prevents the client from requesting an order', () => {
    const f = fixture();
    f.api.getStarter_pack = done => done({ code: 1, data: { starter_pack: f.getNow(), starter_packState: 0 } });
    f.api.buyProp = () => assert.fail('client created expired order');
    f.gift.buyProduct(); assert.equal(f.gift.paying, false);
    assert.equal(f.cc.find('btnContainer/btn', f.gift.node).components.Button.interactable, false);
});

test('login compensation accepts legacy ok response and keeps original order id without changing health', () => {
    const f = fixture(); f.globals.wx = {};
    f.info.allOutTradeNo = [{ itemid: 'starter_pack', outTradeNo: 'old-login-order', goodsPrice: 300 }];
    Object.assign(f.info, { hp: 7, hp_Max: 7, doubleCoin: 2 });
    f.api.getShopDouble = done => done({ code: 1, data: { shopDouble: {} } });
    f.api.setPayInfo = (done, order) => {
        assert.equal(order, 'old-login-order'); done({ code: 1, data: 'ok' });
    };
    let context;
    f.cc.fx.GameTool.shopBuy = (id, compensate, data) => {
        assert.equal(compensate, true); context = data;
    };
    const Home = methods(homePath, ['getOrder'], f.globals), h = new Home();
    h.deferHomePopupWhileTransfer = () => false; h.isHomeRuntimeAlive = () => false;
    h.getOrder();
    assert.deepEqual(JSON.parse(JSON.stringify(context)), { outTradeNo: 'old-login-order' });
    assert.equal(f.info.allOutTradeNo.length, 0);
    assert.deepEqual([f.info.hp, f.info.hp_Max, f.info.doubleCoin], [7,7,2]);
});

function pollingFixture() {
    const f = fixture(), timers = new Map(); let nextId = 0;
    const globals = { ...f.globals,
        setTimeout(fn, delay) { const id = ++nextId; timers.set(id, { fn, at: f.getNow() + delay }); return id; },
        clearTimeout(id) { timers.delete(id); },
    };
    const Payment = methods(utilsPath, ['getPayInfo'], globals); Payment.uid = f.info.uid;
    f.api.getPayInfo = Payment.getPayInfo.bind(Payment);
    const advance = ms => {
        const end = f.getNow() + ms;
        while (timers.size) {
            const [id, timer] = [...timers].sort((a,b) => a[1].at - b[1].at)[0];
            if (timer.at > end) break;
            timers.delete(id); f.setNow(timer.at); timer.fn();
        }
        f.setNow(end);
    };
    return { ...f, Payment, advance, timers };
}

test('WeChat success with backend still unpaid times out in 30 seconds, preserves order and later grants once', () => {
    const f = pollingFixture(); let paid = false, polls = 0, grants = 0, claims = 0, created = 0;
    f.api.buyProp = (id, count, price, platform, name, done) => {
        created++; done({ errMsg: 'requestPayment:ok', outTradeNo: 'paid-on-phone' });
    };
    f.Payment.POST = (url, body, done) => {
        polls++; assert.equal(body.outTradeNo, 'paid-on-phone');
        done(paid ? { code: 1, data: { pay_state: 2 } } : { code: 0, data: { pay_state: 1 }, msg: '充值未成功' });
    };
    f.api.setPayInfo = done => { claims++; done({ code: 1, data: 'ok' }); };
    f.cc.fx.GameTool.shopBuy = () => { grants++; };
    f.gift.buyProduct(); f.gift.onShow(); assert.equal(polls, 1);
    f.advance(30000);
    assert.equal(grants, 0); assert.equal(claims, 0);
    assert.equal(f.gift.paying, false); assert.equal(f.gift.polling, false);
    assert.equal(f.gift.pendingOrder, 'paid-on-phone');
    assert.equal(f.gift.node.getChildByName('ConfirmBox').active, true);
    const stoppedPolls = polls; f.advance(60000); assert.equal(polls, stoppedPolls);
    paid = true; f.gift.againGet(); f.gift.onShow();
    assert.equal(created, 1); assert.equal(claims, 1); assert.equal(grants, 1);
    assert.equal(f.gift.pendingOrder, ''); assert.equal(f.timers.size, 0);
});

test('payment poll deadline completes once and ignores a late successful response', () => {
    const f = pollingFixture(), results = []; let respond;
    f.Payment.POST = (url, body, done) => { respond = done; };
    f.Payment.getPayInfo(res => results.push(res), 'slow-order', { timeoutMs: 30000 });
    f.advance(30000); assert.equal(results.length, 1); assert.equal(results[0].code, 0);
    respond({ code: 1, data: { pay_state: 2 } }); f.advance(60000);
    assert.equal(results.length, 1); assert.equal(f.timers.size, 0);
});

test('malformed poll response does not throw or leave the payment UI locked forever', () => {
    const f = pollingFixture(); f.gift.pendingOrder = 'bad-response';
    f.Payment.POST = (url, body, done) => done({ code: 1, data: null });
    f.cc.fx.GameTool.shopBuy = () => assert.fail('malformed response granted rewards');
    assert.doesNotThrow(() => f.gift.onShow()); f.advance(30000);
    assert.equal(f.gift.paying, false); assert.equal(f.gift.polling, false);
    assert.equal(f.gift.pendingOrder, 'bad-response');
});

test('payment callback without an order id releases the loading state instead of silently stopping', () => {
    const f = fixture(); f.api.buyProp = (id, count, price, platform, name, done) => done({ errMsg: 'requestPayment:ok' });
    f.cc.fx.GameTool.shopBuy = () => assert.fail('missing order id granted rewards');
    f.gift.buyProduct(); assert.equal(f.gift.paying, false);
    assert.ok(f.events.includes('支付订单号缺失，请重进游戏检查补单'));
});

for (const version of ['开发版','体验版','正式版']) {
    test(version + ' requires real payment confirmation and ignores old local test grant records', () => {
        const f = fixture(); let paid = false, created = 0, grants = 0, claims = 0;
        f.cc.fx.GameTool.getWechatGameVersion = () => version;
        f.storage.set('StarterPackGranted_' + f.info.uid + '_starter_test_' + f.info.starter_packTime, true);
        f.api.buyProp = (id, count, price, platform, name, done) => {
            created++; assert.equal(price,300); done({outTradeNo:'real-order'});
        };
        f.api.getPayInfo = done => done(paid ? {code:1,data:{pay_state:2}} : {code:0});
        f.api.setPayInfo = (done,order) => {claims++; assert.equal(order,'real-order'); done({code:1,data:'ok'});};
        f.cc.fx.GameTool.shopBuy = (id,compensate,context) => {grants++; assert.equal(context.outTradeNo,'real-order');};
        f.gift.buyProduct();
        assert.equal(created,1); assert.equal(grants,0); assert.equal(claims,0);
        assert.equal(f.info.starterPackPurchased,false); assert.equal(f.gift.pendingOrder,'real-order');
        paid=true; f.gift.againGet();
        assert.equal(created,1); assert.equal(claims,1); assert.equal(grants,1);
        assert.equal(f.info.starterPackPurchased,true); assert.ok(f.events.includes('充值成功'));
    });
}