// @vitest-environment node

import { describe, expect, it, vi } from 'vitest';

const mocks = vi.hoisted(() => ({
  getEnabledSkillCapabilities: vi.fn(),
}));

vi.mock('../electron/gateway/skill-capability-registry', () => ({
  getEnabledSkillCapabilities: mocks.getEnabledSkillCapabilities,
}));

const spreadsheetCapability = {
  skillKey: 'minimax-xlsx',
  slug: 'minimax-xlsx',
  name: 'MiniMax XLSX',
  description: 'Analyze spreadsheet files.',
  enabled: true,
  category: 'document',
  allowedTools: [],
  operationHints: ['read', 'analyze'],
  triggerHints: ['spreadsheet', 'excel'],
  inputExtensions: ['.xlsx', '.csv', '.tsv'],
  requiredEnvVars: [],
  requiresAuth: false,
  plannerSummary: 'document skill; operations: read, analyze; inputs: .xlsx, .csv, .tsv',
  renderHints: {
    card: 'document-analysis',
    preferredView: 'table',
    skillType: 'spreadsheet',
  },
};

const genericSearchCapability = {
  skillKey: 'minimax-search',
  slug: 'minimax-search',
  name: 'MiniMax Search',
  description: 'Search across indexed knowledge sources.',
  enabled: true,
  category: 'search',
  allowedTools: ['web.search'],
  operationHints: ['search', 'retrieve'],
  triggerHints: ['search', 'lookup'],
  inputExtensions: [],
  requiredEnvVars: ['MINIMAX_API_KEY'],
  requiresAuth: true,
  plannerSummary: 'search skill; operations: search, retrieve; inputs: text',
  renderHints: {
    card: 'search-results',
    preferredView: 'summary',
    skillType: 'search',
  },
};

describe('runtime context capabilities', () => {
  it('injects enabled skill capabilities into the system runtime context', async () => {
    mocks.getEnabledSkillCapabilities.mockReturnValue([spreadsheetCapability]);
    const { buildRuntimeContextMessages } = await import('../electron/gateway/runtime-context');

    const messages = buildRuntimeContextMessages('agent:test:main');

    expect(messages).toHaveLength(1);
    expect(messages[0]).toEqual(expect.objectContaining({
      role: 'system',
      content: expect.stringContaining('Enabled skill capabilities registered for routing/planning'),
    }));
    expect(messages[0]?.content).toContain('minimax-xlsx');
    expect(messages[0]?.content).toContain('inputs=.xlsx,.csv,.tsv');
    expect(messages[0]?.content).toContain('operations=read,analyze');
  });

  it('maps a non-spreadsheet skill into the generic registry and runtime capability context', async () => {
    mocks.getEnabledSkillCapabilities.mockReturnValue([genericSearchCapability]);

    const { mapSkillCapabilitiesToRegistryInputs } = await import('../electron/gateway/chat-tooling');
    const { buildRuntimeContextMessages } = await import('../electron/gateway/runtime-context');
    const { createToolRegistry, getRegistryEntryByName } = await import('../electron/gateway/tool-registry');

    const registry = createToolRegistry({
      capabilities: mapSkillCapabilitiesToRegistryInputs([genericSearchCapability]),
    });
    const entry = getRegistryEntryByName(registry, 'minimax-search');

    expect(entry).toEqual(expect.objectContaining({
      capabilityKey: 'minimax-search',
      toolName: 'minimax-search',
      familyKey: 'minimax-search',
      kind: 'skill',
      displayName: 'MiniMax Search',
      requiresFiles: false,
    }));
    expect(entry?.metadata).toEqual(expect.objectContaining({
      category: 'search',
      requiredEnvVars: ['MINIMAX_API_KEY'],
      requiresAuth: true,
    }));

    const messages = buildRuntimeContextMessages('agent:test:main');

    expect(messages[0]?.content).toContain('minimax-search');
    expect(messages[0]?.content).toContain('category=search');
    expect(messages[0]?.content).toContain('operations=search,retrieve');
    expect(messages[0]?.content).toContain('allowedTools=web.search');
    expect(messages[0]?.content).toContain('env=MINIMAX_API_KEY');
    expect(messages[0]?.content).toContain('auth=required');
  });
});