import { beforeEach, describe, expect, mock, test } from 'bun:test'

const apiRequest = mock(async (): Promise<unknown> => ({
    version: 1,
    workspaceId: 'w',
    generatedAt: '',
    llmModels: [
        { id: 'gpt-5', label: 'GPT 5', provider: 'OpenAI' },
        { id: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash', provider: 'Google' },
        { id: 'claude-opus-4-8', label: 'Claude 4.8 Opus', provider: 'Anthropic' },
    ],
    agentModels: [
        { id: 'openai/gpt-5.4', label: 'GPT-5.4', provider: 'OpenAI' },
        { id: 'xiaomi/mimo-v2-pro', label: 'MiMo-V2-Pro', provider: 'Xiaomi' },
    ],
}))

class ApiRequestError extends Error {
    constructor(public status: number, message: string) {
        super(message)
    }
}

void mock.module('./common.ts', () => ({ apiRequest, ApiRequestError }))

describe('model catalog', () => {
    beforeEach(() => apiRequest.mockClear())

    test('defaults to the canvas/workflow surface', async () => {
        const { listModels } = await import('./models.ts')

        expect((await listModels()).map(m => m.id)).toEqual(['gpt-5', 'gemini-2.5-flash', 'claude-opus-4-8'])
    })

    test('returns the agent surface on request', async () => {
        const { listModels } = await import('./models.ts')

        expect((await listModels({ surface: 'agent' })).map(m => m.id))
            .toEqual(['openai/gpt-5.4', 'xiaomi/mimo-v2-pro'])
    })

    test('the two surfaces have different providers', async () => {
        const { listProviders } = await import('./models.ts')

        const llm = (await listProviders()).map(p => p.provider)
        const agent = (await listProviders({ surface: 'agent' })).map(p => p.provider)

        expect(llm).toEqual(['Anthropic', 'Google', 'OpenAI'])
        expect(agent).toContain('Xiaomi')
        expect(llm).not.toContain('Xiaomi')
    })

    test('filters by provider', async () => {
        const { listModels } = await import('./models.ts')

        expect((await listModels({ provider: 'google' })).map(m => m.id)).toEqual(['gemini-2.5-flash'])
    })

    test('resolves a valid id on its own surface', async () => {
        const { resolveModel } = await import('./models.ts')

        expect((await resolveModel('gpt-5')).model?.label).toBe('GPT 5')
    })

    test('flags an id that exists only on the other surface', async () => {
        const { resolveModel } = await import('./models.ts')

        const result = await resolveModel('openai/gpt-5.4')

        expect(result.model).toBeNull()
        expect(result.availableOnOtherSurface).toBe(true)
    })

    test('reports an unknown id as unknown, not as cross-surface', async () => {
        const { resolveModel } = await import('./models.ts')

        const result = await resolveModel('does-not-exist')

        expect(result.model).toBeNull()
        expect(result.availableOnOtherSurface).toBe(false)
    })

    test('renders the catalog grouped by provider', async () => {
        const { formatModelCatalog, listProviders } = await import('./models.ts')

        const output = formatModelCatalog(await listProviders())

        expect(output).toContain('OpenAI:')
        expect(output).toContain('  gpt-5  (GPT 5)')
    })
})