// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System;
using System.Collections.Generic;
using Xunit;
 
#pragma warning disable MEAI001 // Type is for evaluation purposes only and is subject to change or removal in future updates.
 
namespace Microsoft.Extensions.AI;
 
public class RealtimeClientMessageTests
{
    [Fact]
    public void RealtimeClientMessage_DefaultProperties()
    {
        var message = new RealtimeClientMessage();
 
        Assert.Null(message.MessageId);
        Assert.Null(message.RawRepresentation);
    }
 
    [Fact]
    public void RealtimeClientMessage_Properties_Roundtrip()
    {
        var rawObj = new object();
        var message = new RealtimeClientMessage
        {
            MessageId = "evt_001",
            RawRepresentation = rawObj,
        };
 
        Assert.Equal("evt_001", message.MessageId);
        Assert.Same(rawObj, message.RawRepresentation);
    }
 
    [Fact]
    public void ConversationItemCreateMessage_Constructor_SetsProperties()
    {
        var contents = new List<AIContent> { new TextContent("Hello") };
        var item = new RealtimeConversationItem(contents, "item_1", ChatRole.User);
 
        var message = new CreateConversationItemRealtimeClientMessage(item);
 
        Assert.Same(item, message.Item);
    }
 
    [Fact]
    public void ConversationItemCreateMessage_Properties_Roundtrip()
    {
        var item = new RealtimeConversationItem([new TextContent("Hello")]);
        var message = new CreateConversationItemRealtimeClientMessage(item);
 
        var newItem = new RealtimeConversationItem([new TextContent("World")]);
        message.Item = newItem;
 
        Assert.Same(newItem, message.Item);
    }
 
    [Fact]
    public void ConversationItemCreateMessage_InheritsClientMessage()
    {
        var item = new RealtimeConversationItem([new TextContent("Hello")]);
        var message = new CreateConversationItemRealtimeClientMessage(item)
        {
            MessageId = "evt_create_1",
        };
 
        Assert.Equal("evt_create_1", message.MessageId);
        Assert.IsAssignableFrom<RealtimeClientMessage>(message);
    }
 
    [Fact]
    public void InputAudioBufferAppendMessage_Constructor_SetsContent()
    {
        var audioContent = new DataContent(new byte[] { 1, 2, 3 }, "audio/pcm");
        var message = new InputAudioBufferAppendRealtimeClientMessage(audioContent);
 
        Assert.Same(audioContent, message.Content);
    }
 
    [Fact]
    public void InputAudioBufferAppendMessage_Properties_Roundtrip()
    {
        var audioContent = new DataContent(new byte[] { 1, 2, 3 }, "audio/pcm");
        var message = new InputAudioBufferAppendRealtimeClientMessage(audioContent);
 
        var newContent = new DataContent(new byte[] { 4, 5, 6 }, "audio/wav");
        message.Content = newContent;
 
        Assert.Same(newContent, message.Content);
    }
 
    [Fact]
    public void InputAudioBufferAppendMessage_InheritsClientMessage()
    {
        var audioContent = new DataContent(new byte[] { 1, 2, 3 }, "audio/pcm");
        var message = new InputAudioBufferAppendRealtimeClientMessage(audioContent)
        {
            MessageId = "evt_append_1",
        };
 
        Assert.Equal("evt_append_1", message.MessageId);
        Assert.IsAssignableFrom<RealtimeClientMessage>(message);
    }
 
    [Fact]
    public void InputAudioBufferCommitMessage_Constructor()
    {
        var message = new InputAudioBufferCommitRealtimeClientMessage();
 
        Assert.IsAssignableFrom<RealtimeClientMessage>(message);
        Assert.Null(message.MessageId);
    }
 
    [Fact]
    public void ResponseCreateMessage_DefaultProperties()
    {
        var message = new CreateResponseRealtimeClientMessage();
 
        Assert.Null(message.Items);
        Assert.Null(message.OutputAudioOptions);
        Assert.Null(message.OutputVoice);
        Assert.Null(message.ExcludeFromConversation);
        Assert.Null(message.Instructions);
        Assert.Null(message.MaxOutputTokens);
        Assert.Null(message.AdditionalProperties);
        Assert.Null(message.OutputModalities);
        Assert.Null(message.ToolMode);
        Assert.Null(message.Tools);
    }
 
    [Fact]
    public void ResponseCreateMessage_Properties_Roundtrip()
    {
        var message = new CreateResponseRealtimeClientMessage();
 
        var items = new List<RealtimeConversationItem>
        {
            new RealtimeConversationItem([new TextContent("Hello")], "item_1", ChatRole.User),
        };
        var audioFormat = new RealtimeAudioFormat("audio/pcm", 16000);
        var modalities = new List<string> { "text", "audio" };
        var tools = new List<AITool> { AIFunctionFactory.Create(() => 42) };
        var metadata = new AdditionalPropertiesDictionary { ["key"] = "value" };
 
        message.Items = items;
        message.OutputAudioOptions = audioFormat;
        message.OutputVoice = "alloy";
        message.ExcludeFromConversation = true;
        message.Instructions = "Be brief";
        message.MaxOutputTokens = 100;
        message.AdditionalProperties = metadata;
        message.OutputModalities = modalities;
        message.ToolMode = ChatToolMode.Auto;
        message.Tools = tools;
 
        Assert.Same(items, message.Items);
        Assert.Same(audioFormat, message.OutputAudioOptions);
        Assert.Equal("alloy", message.OutputVoice);
        Assert.True(message.ExcludeFromConversation);
        Assert.Equal("Be brief", message.Instructions);
        Assert.Equal(100, message.MaxOutputTokens);
        Assert.Same(metadata, message.AdditionalProperties);
        Assert.Same(modalities, message.OutputModalities);
        Assert.Equal(ChatToolMode.Auto, message.ToolMode);
        Assert.Same(tools, message.Tools);
    }
 
    [Fact]
    public void ResponseCreateMessage_InheritsClientMessage()
    {
        var message = new CreateResponseRealtimeClientMessage
        {
            MessageId = "evt_resp_1",
            RawRepresentation = "raw",
        };
 
        Assert.Equal("evt_resp_1", message.MessageId);
        Assert.Equal("raw", message.RawRepresentation);
        Assert.IsAssignableFrom<RealtimeClientMessage>(message);
    }
}