UI.test.ts

import { panelDefinitions } from '@ui/panelRegistry.js';
import { panelRouter } from '@ui/PanelRouter.js';
import { vi } from 'vitest';

// Mock Config
vi.mock('../configManager.js', () => ({
    getConfig: vi.fn().mockReturnValue({
        // Minimal config
        bounties: { enabled: true },
        tpa: { enabled: true },
        economy: { enabled: true }
    }),
    updateConfig: vi.fn(),
    updateMultipleConfig: vi.fn(),
    resetConfigSection: vi.fn(),
    onConfigUpdated: vi.fn(),
    initializeConfigManager: vi.fn(),
    reloadConfig: vi.fn()
}));

// Mock feature managers if needed by panels
vi.mock('../bountyManager.js', () => ({
    bountyManager: { getBounties: () => [] }
}));

// Import panels (trigger registration)
const { initialize } = await import('@ui/panels/index.js');
initialize();

// Also initialize feature panels that were modularized
const { initialize: initEconomy } = await import('@features/economy/index.js');
const { initialize: initEssentials } = await import('@features/essentials/index.js');
const { initialize: initKit } = await import('@features/kit/index.js');
const { initialize: initModeration } = await import('@features/moderation/index.js');
const { initialize: initShop } = await import('@features/shop/index.js');
const { initialize: initSocial } = await import('@features/social/index.js');
const { initialize: initTeam } = await import('@features/team/index.js');
const { initialize: initTeleport } = await import('@features/teleport/index.js');
const { initialize: initGames } = await import('@features/games/index.js');

// Initialize with wait for async modules (some config loaders are async)
await initEconomy(false);
await initGames(false);
await initEssentials(false);
initKit();
initModeration();
await initShop(false);
await initSocial(false);
await initTeam(false);
initTeleport();

describe('UI Integrity Check', () => {
    it('should have a registered handler for every panel in registry', () => {
        const missingHandlers: string[] = [];

        for (const panelId of Object.keys(panelDefinitions)) {
            // Some panels might be dynamic config panels handled by a generic handler
            // But they should still be claimed by *some* handler.
            const handler = panelRouter.getHandler(panelId);
            if (!handler) {
                missingHandlers.push(panelId);
            }
        }

        expect(missingHandlers).toEqual([]);
    });

    it('should validate button actions point to valid targets', () => {
        const brokenLinks: string[] = [];

        for (const [panelId, def] of Object.entries(panelDefinitions)) {
            for (const item of def.items) {
                if (item.actionType === 'openPanel') {
                    // Target panel must exist in registry OR be a known dynamic pattern
                    const targetId = item.actionValue;
                    const isKnown = panelDefinitions[targetId] || targetId.startsWith('config_') || panelRouter.getHandler(targetId); // Some dynamic panels might not be in static registry but have handlers

                    if (!isKnown) {
                        brokenLinks.push(`${panelId} -> ${targetId}`);
                    }
                }
            }
        }

        expect(brokenLinks).toEqual([]);
    });
});