using Dpz.Core.Entity.Base;
using Markdig;
using Markdig.Syntax;

namespace Dpz.Core.Service.Network.Models;

/// <summary>
/// Chat Completion API 响应
/// </summary>
[Obsolete("use IOpenAiService")]
public class ChatCompletionResponse
{
    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    [JsonPropertyName("object")]
    public string Object { get; set; } = string.Empty;

    [JsonPropertyName("created")]
    public long Created { get; set; }

    [JsonPropertyName("model")]
    public string Model { get; set; } = string.Empty;

    [JsonPropertyName("provider")]
    public string? Provider { get; set; }

    [JsonPropertyName("choices")]
    public List<CompletionChoice> Choices { get; set; } = [];

    [JsonPropertyName("usage")]
    public Usage? Usage { get; set; }

    public ResponseResult<T?> Analyze<T>()
        where T : new()
    {
        var result = new ResponseResult<T?>();
        T? t;

        var content = Choices.Count > 0 ? Choices[0].Message.Content : "";
        try
        {
            var pipeline = new MarkdownPipelineBuilder()
                .UseAutoLinks()
                .UsePipeTables()
                .UseTaskLists()
                .UseEmphasisExtras()
                .UseAutoIdentifiers()
                .Build();
            var document = Markdown.Parse(content, pipeline);
            var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };

            var codeBlocks = document.Descendants<CodeBlock>().ToList();
            var jsonText = ExtractJsonFromCodeBlocks(codeBlocks);
            jsonText ??= ExtractFirstJsonPayload(content);
            jsonText ??= content;

            t = JsonSerializer.Deserialize<T>(jsonText, options);
        }
        catch (Exception e)
        {
            result.Arguments = [content];
            return result.WithFail(e.Message);
        }
        return result.WithOk(t);
    }

    private static string? ExtractJsonFromCodeBlocks(IEnumerable<CodeBlock> codeBlocks)
    {
        var blocks = codeBlocks.ToList();
        if (blocks.Count == 0)
        {
            return null;
        }

        foreach (var codeBlock in blocks)
        {
            var fenced = codeBlock as FencedCodeBlock;
            var info = fenced?.Info ?? string.Empty;
            if (info.Trim().Equals("json", StringComparison.OrdinalIgnoreCase))
            {
                var text = codeBlock.Lines.ToString();
                if (!string.IsNullOrWhiteSpace(text))
                {
                    return text;
                }
            }
        }

        foreach (var codeBlock in blocks)
        {
            var text = codeBlock.Lines.ToString();
            if (!string.IsNullOrWhiteSpace(text))
            {
                return text;
            }
        }

        return null;
    }

    private static string? ExtractFirstJsonPayload(string content)
    {
        if (string.IsNullOrWhiteSpace(content))
        {
            return null;
        }

        var trimmed = content.Trim();
        var objectIndex = trimmed.IndexOf('{');
        var arrayIndex = trimmed.IndexOf('[');

        var startIndex = -1;
        if (objectIndex >= 0 && arrayIndex >= 0)
        {
            startIndex = Math.Min(objectIndex, arrayIndex);
        }
        else if (objectIndex >= 0)
        {
            startIndex = objectIndex;
        }
        else if (arrayIndex >= 0)
        {
            startIndex = arrayIndex;
        }

        if (startIndex < 0)
        {
            return null;
        }

        var candidate = trimmed[startIndex..];
        for (var length = candidate.Length; length > 0; length--)
        {
            var slice = candidate[..length];
            try
            {
                JsonDocument.Parse(slice);
                return slice;
            }
            catch (JsonException)
            {
                // ignore
            }
        }

        return null;
    }
}