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

const apiRequest = mock(async (_endpoint: string, _options?: RequestInit): Promise<unknown> => ({ id: 'test-case-id' }))

void mock.module('./common.ts', () => ({
    apiRequest,
    getAuthenticatedWorkspaceId: mock(() => 'workspace-id'),
}))

function sentBody(call = 0) {
    const [, options] = apiRequest.mock.calls[call]!
    return JSON.parse(String(options?.body))
}

describe('creating test cases without rich content', () => {
    beforeEach(() => {
        apiRequest.mockClear()
    })

    test('createTestCase renders variablesRichContent from variables when it is missing', async () => {
        const { createTestCase } = await import('./test-cases.ts')
        const { markdownToHtml } = await import('./canvas.ts')

        await createTestCase({
            promptId: 'prompt-id',
            messages: [],
            variables: { numero_processo: '0001234-56.2026.8.26.0100', documentos: '**Petição** inicial' },
        })

        const body = sentBody()
        expect(body.variables).toEqual({ numero_processo: '0001234-56.2026.8.26.0100', documentos: '**Petição** inicial' })
        expect(body.variablesRichContent).toEqual({
            numero_processo: markdownToHtml('0001234-56.2026.8.26.0100'),
            documentos: markdownToHtml('**Petição** inicial'),
        })
    })

    test('createTestCase keeps supplied rich content and fills only the missing keys', async () => {
        const { createTestCase } = await import('./test-cases.ts')
        const { markdownToHtml } = await import('./canvas.ts')

        await createTestCase({
            promptId: 'prompt-id',
            messages: [],
            variables: { first: 'one', second: 'two' },
            variablesRichContent: { first: '<p>custom</p>' },
        })

        expect(sentBody().variablesRichContent).toEqual({ first: '<p>custom</p>', second: markdownToHtml('two') })
    })

    test('createTestCase renders variables named like Object.prototype members', async () => {
        const { createTestCase } = await import('./test-cases.ts')
        const { markdownToHtml } = await import('./canvas.ts')

        await createTestCase({
            promptId: 'prompt-id',
            messages: [],
            variables: { constructor: 'example', toString: 'texto' },
            variablesRichContent: {},
        })

        expect(sentBody().variablesRichContent).toEqual({ constructor: markdownToHtml('example'), toString: markdownToHtml('texto') })
    })

    test('createTestCase leaves a payload without variables as it was', async () => {
        const { createTestCase } = await import('./test-cases.ts')

        await createTestCase({ promptId: 'prompt-id', messages: [], variablesRichContent: null })

        expect(sentBody().variablesRichContent).toBeNull()
    })

    test('createTestCases fills rich content for every payload', async () => {
        const { createTestCases } = await import('./test-cases.ts')
        const { markdownToHtml } = await import('./canvas.ts')

        await createTestCases([
            { promptId: 'prompt-id', messages: [], variables: { a: 'first' } },
            { promptId: 'prompt-id', messages: [], variables: { a: 'second' }, variablesRichContent: { a: '<p>kept</p>' } },
        ])

        const [first, second] = sentBody()
        expect(first.variablesRichContent).toEqual({ a: markdownToHtml('first') })
        expect(second.variablesRichContent).toEqual({ a: '<p>kept</p>' })
    })
})