using System.Text.Json;
using Dpz.Core.Infrastructure;
using Dpz.Core.Service.Network.Models;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using OpenAI.Chat;
using Xunit.Abstractions;

namespace Dpz.Core.Service.Network.Test;

public class OpenAiServiceTest(ITestOutputHelper testOutputHelper)
    : NetworkServiceTestBasic(testOutputHelper)
{
    private readonly ITestOutputHelper _testOutputHelper = testOutputHelper;

    [Fact]
    public void OpenAiServiceCanBeResolved()
    {
        var service = GetService<IOpenAiService>();

        Assert.NotNull(service);
    }

    [Fact]
    public async Task SendMessageAsyncReturnsDeltasAndFinalContent()
    {
        var service = GetService<IOpenAiService>();
        var deltas = new List<string>();

        var result = await service.SendMessageAsync(
            [new UserChatMessage("请用中文简短回答：2+2等于几？")],
            (delta, _) =>
            {
                deltas.Add(delta);
                return Task.CompletedTask;
            }
        );

        Assert.True(result.Success, result.Message);
        Assert.NotNull(result.Data);
        Assert.NotEmpty(deltas);
        Assert.False(string.IsNullOrWhiteSpace(result.Data!.Content));

        _testOutputHelper.WriteLine($"OpenAI SDK stream response: {result.Data.Content}");
    }

    [Fact]
    public async Task SendMessageAsyncWithEmptyMessagesReturnsFail()
    {
        var service = GetService<IOpenAiService>();

        var result = await service.SendMessageAsync([]);

        Assert.False(result.Success);
        Assert.Contains("empty", result.Message, StringComparison.OrdinalIgnoreCase);
    }

    [Fact]
    public async Task SendMessageAsyncWithJsonSchemaCanDeserializeResponse()
    {
        var service = GetService<IOpenAiService>();

        var result = await service.SendMessageAsync(
            [
                new UserChatMessage("请只返回 JSON：2+2 的结果。"),
                new SystemChatMessage("格式：{answer: 0}"),
            ],
            options: null
        );

        Assert.True(result.Success, result.Message);
        Assert.NotNull(result.Data);

        if (
            result.Data.TryDeserialize<StructuredAnswer>(
                out var value,
                out var msg,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
            )
        )
        {
            Assert.NotNull(value);
            Assert.True(string.IsNullOrWhiteSpace(msg));
        }

        var response = result.Data!.Deserialize<StructuredAnswer>(
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
        );

        Assert.NotNull(response);
        Assert.Equal(4, response.Answer);
        return;

        // 支持约束的模型很少
        // void Options(OpenAiChatRequestOptions x)
        // {
        //     x.ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
        //         jsonSchemaFormatName: "math_answer",
        //         jsonSchema: BinaryData.FromBytes(
        //             """
        //                 {
        //                  "type": "object",
        //                  "properties": {
        //                    "answer": {
        //                      "type": "integer"
        //                    }
        //                  },
        //                  "required": ["answer"],
        //                  "additionalProperties": false
        //                 }
        //                 """u8.ToArray()
        //         ),
        //         jsonSchemaIsStrict: true
        //     );
        // }
    }

    [Fact]
    public async Task GetModelsAsyncReturnsAvailableModelsWhenProviderSupportsEndpoint()
    {
        var service = GetService<IOpenAiService>();

        var result = await service.GetModelsAsync();

        if (!result.Success)
        {
            Assert.Contains("404", result.Message);
            _testOutputHelper.WriteLine(
                "当前兼容服务商未暴露 OpenAI /models 端点，模型列表能力返回 404。"
            );
            return;
        }

        Assert.NotNull(result.Data);
        Assert.NotEmpty(result.Data!);

        foreach (var item in result.Data)
        {
            _testOutputHelper.WriteLine(
                $"Id:{item.Id},OwnedBy:{item.OwnedBy},OwnedBy:{item.OwnedBy}"
            );
        }
    }

    [Theory]
    [InlineData("OpenAI:Endpoint", "OpenAI:Endpoint configuration is missing")]
    [InlineData("OpenAI:ApiKey", "OpenAI:ApiKey configuration is missing")]
    [InlineData("OpenAI:Model", "OpenAI:Model configuration is missing")]
    public void MissingRequiredConfigurationThrows(string missingKey, string expectedMessage)
    {
        var configuration = BuildConfiguration((missingKey, string.Empty));

        var exception = Assert.Throws<InvalidConfigurationException>(() =>
            CreateService(configuration)
        );

        Assert.Contains(expectedMessage, exception.Message);
    }

    [Fact]
    public void DeserializeWithCodeFenceWrappedContentSucceeds()
    {
        var result = new OpenAiChatStreamResult
        {
            Model = "test-model",
            Content = "```json\n{ \"answer\": 42 }\n```",
        };

        var value = result.Deserialize<StructuredAnswer>(
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
        );

        Assert.NotNull(value);
        Assert.Equal(42, value.Answer);
    }

    [Fact]
    public void TryDeserializeWithCodeFenceWrappedContentSucceeds()
    {
        var result = new OpenAiChatStreamResult
        {
            Model = "test-model",
            Content = "```\n{\"answer\": 7}\n```",
        };

        var success = result.TryDeserialize<StructuredAnswer>(
            out var value,
            out var errorMessage,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
        );

        Assert.True(success);
        Assert.NotNull(value);
        Assert.Equal(7, value.Answer);
        Assert.Null(errorMessage);
    }

    private static IConfiguration BuildConfiguration(params (string Key, string? Value)[] overrides)
    {
        var values = new Dictionary<string, string?>
        {
            ["OpenAI:Endpoint"] = "https://api.example.com",
            ["OpenAI:ApiKey"] = "test-key",
            ["OpenAI:Model"] = "gpt-5-mini",
            ["OpenAI:AuthenticationScheme"] = "Bearer",
        };

        foreach (var (key, value) in overrides)
        {
            values[key] = value;
        }

        return new ConfigurationBuilder().AddInMemoryCollection(values).Build();
    }

    private static OpenAiService CreateService(IConfiguration configuration)
    {
        var services = new ServiceCollection();
        services.AddSingleton(configuration);
        services.AddLogging();

        var provider = services.BuildServiceProvider();
        return new OpenAiService(
            configuration,
            provider.GetRequiredService<ILogger<OpenAiService>>()
        );
    }

    private sealed class StructuredAnswer
    {
        public int Answer { get; set; }
    }
}