// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using Aspire.Dashboard.Model.GenAI;
using Microsoft.OpenApi;
using Xunit;
 
namespace Aspire.Dashboard.Tests.Model;
 
public sealed class GenAISchemaHelpersTests
{
    [Fact]
    public void ConvertTypeToNames_HandlesVariousTypeCombinations()
    {
        // Test single types
        var stringSchema = new OpenApiSchema { Type = JsonSchemaType.String };
        var typeNames = GenAISchemaHelpers.ConvertTypeToNames(stringSchema);
        Assert.Single(typeNames);
        Assert.Equal("string", typeNames[0]);
 
        // Test multiple types (nullable string) - null should be excluded from display
        var nullableStringSchema = new OpenApiSchema { Type = JsonSchemaType.String | JsonSchemaType.Null };
        typeNames = GenAISchemaHelpers.ConvertTypeToNames(nullableStringSchema);
        Assert.Single(typeNames);
        Assert.Equal("string", typeNames[0]);
 
        // Test array with items
        var arraySchema = new OpenApiSchema 
        { 
            Type = JsonSchemaType.Array,
            Items = new OpenApiSchema { Type = JsonSchemaType.String }
        };
        typeNames = GenAISchemaHelpers.ConvertTypeToNames(arraySchema);
        Assert.Single(typeNames);
        Assert.Equal("array<string>", typeNames[0]);
 
        // Test nullable array with items - null should be excluded
        var nullableArraySchema = new OpenApiSchema 
        { 
            Type = JsonSchemaType.Array | JsonSchemaType.Null,
            Items = new OpenApiSchema { Type = JsonSchemaType.Number }
        };
        typeNames = GenAISchemaHelpers.ConvertTypeToNames(nullableArraySchema);
        Assert.Single(typeNames);
        Assert.Equal("array<number>", typeNames[0]);
 
        // Test array without items
        var arrayNoItemsSchema = new OpenApiSchema { Type = JsonSchemaType.Array };
        typeNames = GenAISchemaHelpers.ConvertTypeToNames(arrayNoItemsSchema);
        Assert.Single(typeNames);
        Assert.Equal("array", typeNames[0]);
 
        // Test null schema - should return empty list
        typeNames = GenAISchemaHelpers.ConvertTypeToNames(null);
        Assert.Empty(typeNames);
 
        // Test schema with no type - should return empty list
        var noTypeSchema = new OpenApiSchema();
        typeNames = GenAISchemaHelpers.ConvertTypeToNames(noTypeSchema);
        Assert.Empty(typeNames);
 
        // Test schema with only null type - should return "null" since type is only null
        var onlyNullSchema = new OpenApiSchema { Type = JsonSchemaType.Null };
        typeNames = GenAISchemaHelpers.ConvertTypeToNames(onlyNullSchema);
        Assert.Single(typeNames);
        Assert.Equal("null", typeNames[0]);
 
        // Test multiple types without null
        var multiTypeSchema = new OpenApiSchema { Type = JsonSchemaType.String | JsonSchemaType.Number };
        typeNames = GenAISchemaHelpers.ConvertTypeToNames(multiTypeSchema);
        Assert.Equal(2, typeNames.Count);
        Assert.Contains("number", typeNames);
        Assert.Contains("string", typeNames);
    }
 
    [Fact]
    public void TryConvertToJsonSchemaType_ValidTypes_ReturnsTrue()
    {
        Assert.True(GenAISchemaHelpers.TryConvertToJsonSchemaType("null", out var nullType));
        Assert.Equal(JsonSchemaType.Null, nullType);
 
        Assert.True(GenAISchemaHelpers.TryConvertToJsonSchemaType("boolean", out var boolType));
        Assert.Equal(JsonSchemaType.Boolean, boolType);
 
        Assert.True(GenAISchemaHelpers.TryConvertToJsonSchemaType("integer", out var intType));
        Assert.Equal(JsonSchemaType.Integer, intType);
 
        Assert.True(GenAISchemaHelpers.TryConvertToJsonSchemaType("number", out var numberType));
        Assert.Equal(JsonSchemaType.Number, numberType);
 
        Assert.True(GenAISchemaHelpers.TryConvertToJsonSchemaType("string", out var stringType));
        Assert.Equal(JsonSchemaType.String, stringType);
 
        Assert.True(GenAISchemaHelpers.TryConvertToJsonSchemaType("object", out var objectType));
        Assert.Equal(JsonSchemaType.Object, objectType);
 
        Assert.True(GenAISchemaHelpers.TryConvertToJsonSchemaType("array", out var arrayType));
        Assert.Equal(JsonSchemaType.Array, arrayType);
    }
 
    [Fact]
    public void TryConvertToJsonSchemaType_InvalidType_ReturnsFalse()
    {
        Assert.False(GenAISchemaHelpers.TryConvertToJsonSchemaType("invalid", out _));
        Assert.False(GenAISchemaHelpers.TryConvertToJsonSchemaType(null, out _));
        Assert.False(GenAISchemaHelpers.TryConvertToJsonSchemaType("", out _));
    }
}