// 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 System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Text.Json.Serialization;

namespace Microsoft.Extensions.AI;

/// <summary>
/// Represents the result of code execution in a chat.
/// </summary>
/// <remarks>
/// This content type represents the core output from executing code in various AI provider environments,
/// focusing on the essential properties: stdout, stderr, and generated content.
/// It provides a minimal unified format that accommodates the common execution result patterns
/// from providers such as Anthropic Claude, Azure AI Foundry, OpenAI Code Interpreter, and Google Vertex AI.
/// Generated files are represented using existing AIContent types like DataContent, UriContent, or HostedFileContent.
/// </remarks>
[DebuggerDisplay("{DebuggerDisplay,nq}")]
public sealed class CodeExecutionResultContent : AIContent
{
    /// <summary>The standard output from code execution.</summary>
    private string? _stdout;

    /// <summary>The standard error output from code execution.</summary>
    private string? _stderr;

    /// <summary>
    /// Initializes a new instance of the <see cref="CodeExecutionResultContent"/> class.
    /// </summary>
    /// <param name="stdout">The standard output from execution.</param>
    /// <param name="stderr">The standard error output from execution.</param>
    /// <param name="generatedContents">Collection of content generated during execution (images, files, etc.).</param>
    public CodeExecutionResultContent(string? stdout = null, string? stderr = null, IList<AIContent>? generatedContents = null)
    {
        _stdout = stdout;
        _stderr = stderr;
        GeneratedContents = generatedContents;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="CodeExecutionResultContent"/> class for JSON deserialization.
    /// </summary>
    /// <param name="stdout">The standard output from execution.</param>
    /// <param name="stderr">The standard error output from execution.</param>
    /// <param name="generatedContents">Collection of content generated during execution.</param>
    [JsonConstructor]
    public CodeExecutionResultContent(
        string? stdout = null,
        string? stderr = null,
        IList<AIContent>? generatedContents = null)
    {
        _stdout = stdout;
        _stderr = stderr;
        GeneratedContents = generatedContents;
    }

    /// <summary>
    /// Gets or sets the standard output from code execution.
    /// </summary>
    /// <remarks>
    /// This contains the text output that would normally be written to stdout during code execution,
    /// such as print statements, successful computation results, etc.
    /// </remarks>
    [AllowNull]
    public string Stdout
    {
        get => _stdout ?? string.Empty;
        set => _stdout = value;
    }

    /// <summary>
    /// Gets or sets the standard error output from code execution.
    /// </summary>
    /// <remarks>
    /// This contains error messages, warnings, and other diagnostic information that would
    /// normally be written to stderr during code execution.
    /// </remarks>
    [AllowNull]
    public string Stderr
    {
        get => _stderr ?? string.Empty;
        set => _stderr = value;
    }

    /// <summary>
    /// Gets or sets the collection of content generated during code execution.
    /// </summary>
    /// <remarks>
    /// This includes images, charts, data files, and other artifacts created by the executed code.
    /// Generated content is represented using existing AIContent types such as DataContent for inline data,
    /// UriContent for downloadable files, or HostedFileContent for provider-hosted files.
    /// This property is supported by multiple providers including Google Vertex AI (inline images),
    /// Azure AI Foundry (file path annotations), and OpenAI Code Interpreter (file references).
    /// </remarks>
    public IList<AIContent>? GeneratedContents { get; set; }

    /// <summary>
    /// Gets the combined text from code execution, including both stdout and stderr.
    /// </summary>
    /// <remarks>
    /// This property combines the standard output and standard error streams into a single string.
    /// If both stdout and stderr have content, stderr is appended after stdout.
    /// If only one stream has content, only that content is returned.
    /// </remarks>
    [JsonIgnore]
    public string Text
    {
        get
        {
            var hasStdout = !string.IsNullOrEmpty(Stdout);
            var hasStderr = !string.IsNullOrEmpty(Stderr);

            if (hasStdout && hasStderr)
            {
                return $"{Stdout}\n{Stderr}";
            }

            if (hasStdout)
            {
                return Stdout;
            }

            if (hasStderr)
            {
                return Stderr;
            }
            
            return string.Empty;
        }
    }

    /// <summary>
    /// Gets a value indicating whether the code execution was successful.
    /// </summary>
    /// <remarks>
    /// This is determined by checking if there are no errors in stderr.
    /// </remarks>
    [JsonIgnore]
    public bool IsSuccess => string.IsNullOrEmpty(Stderr);

    /// <inheritdoc/>
    public override string ToString() => Text;

    /// <summary>Gets a string representing this instance to display in the debugger.</summary>
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string DebuggerDisplay
    {
        get
        {
            var status = IsSuccess ? "Success" : "Failed";
            var output = !string.IsNullOrEmpty(Text) ? $", Text: \"{Text.Substring(0, Math.Min(50, Text.Length))}\"" : string.Empty;
            var generated = GeneratedContents?.Count > 0 ? $", Generated: {GeneratedContents.Count}" : string.Empty;

            return $"CodeExecution = {status}{output}{generated}";
        }
    }
}

/// <summary>Represents content used by AI services.</summary>
[JsonPolymorphic(TypeDiscriminatorPropertyName = "$type")]
[JsonDerivedType(typeof(CodeExecutionResultContent), typeDiscriminator: "codeExecutionResult")]
[JsonDerivedType(typeof(DataContent), typeDiscriminator: "data")]
[JsonDerivedType(typeof(ErrorContent), typeDiscriminator: "error")]
// ... other existing types
public class AIContent
{
    // ... existing implementation
}

using Microsoft.Extensions.AI;

IChatClient client = // ... initialize your provider client

// Request code execution
var response = await client.GetResponseAsync([
    new ChatMessage(ChatRole.User, "Calculate the mean of [1, 2, 3, 4, 5] and create a chart")
]);

// Process the response
foreach (var content in response.Message.Contents)
{
    switch (content)
    {
        case TextContent textContent:
            Console.WriteLine($"AI Response: {textContent.Text}");
            break;

        case CodeExecutionResultContent codeResult:
            Console.WriteLine($"Code Execution Output: {codeResult.Text}");
            Console.WriteLine($"Success: {codeResult.IsSuccess}");

            // Handle generated files
            if (codeResult.GeneratedContents != null)
            {
                foreach (var generated in codeResult.GeneratedContents)
                {
                    switch (generated)
                    {
                        case DataContent dataContent:
                            Console.WriteLine($"Generated inline file: {dataContent.MediaType}");
                            // Save dataContent.Data to file
                            break;

                        case HostedFileContent hostedFile:
                            Console.WriteLine($"Generated hosted file: {hostedFile.FileId}");
                            // Download file using provider's file API
                            break;

                        case UriContent uriContent:
                            Console.WriteLine($"Generated file available at: {uriContent.Uri}");
                            // Download from URI
                            break;
                    }
                }
            }
            break;
    }
}

using Microsoft.Extensions.AI;

IChatClient client = // ... initialize your provider client

// Request streaming code execution
await foreach (var update in client.GetStreamingResponseAsync([
    new ChatMessage(ChatRole.User, "Run a data analysis and generate visualizations")
]))
{
    foreach (var content in update.Contents)
    {
        switch (content)
        {
            case TextContent textContent:
                Console.Write(textContent.Text); // Stream text as it arrives
                break;

            case CodeExecutionResultContent codeResult:
                // Handle incremental execution output
                if (!string.IsNullOrEmpty(codeResult.Stdout))
                {
                    Console.Write($"[STDOUT] {codeResult.Stdout}");
                }

                if (!string.IsNullOrEmpty(codeResult.Stderr))
                {
                    Console.Write($"[STDERR] {codeResult.Stderr}");
                }

                // Handle generated content as it becomes available
                if (codeResult.GeneratedContents?.Count > 0)
                {
                    Console.WriteLine($"\n[FILES] Generated {codeResult.GeneratedContents.Count} files");
                    foreach (var generated in codeResult.GeneratedContents)
                    {
                        Console.WriteLine($"  - {generated.GetType().Name}");
                    }
                }
                break;
        }
    }
}

// Example 1: Successful execution with output
var successResult = new CodeExecutionResultContent(
    stdout: "Calculation complete!\nMean: 3.0\nStandard deviation: 1.58",
    stderr: ""
);
Console.WriteLine(successResult.Text); // Prints the stdout
Console.WriteLine(successResult.IsSuccess); // True

// Example 2: Failed execution with error
var errorResult = new CodeExecutionResultContent(
    stdout: "Starting calculation...",
    stderr: "NameError: name 'undefined_variable' is not defined"
);
Console.WriteLine(errorResult.Text); // Prints: "Starting calculation...\nNameError: name 'undefined_variable' is not defined"
Console.WriteLine(errorResult.IsSuccess); // False

// Example 3: Execution with generated files
var resultWithFiles = new CodeExecutionResultContent(
    stdout: "Chart generated successfully",
    generatedContents: [
        new DataContent(chartImageBytes, "image/png"),
        new DataContent(csvData, "text/csv")
    ]
);

// Provider implementation for incremental streaming
public async IAsyncEnumerable<ChatResponseUpdate> StreamCodeExecution(string code)
{
    // Stream 1: Execution start
    yield return new ChatResponseUpdate(ChatRole.Assistant, [
        new CodeExecutionResultContent(stdout: "Starting execution...\n")
    ]);

    // Stream 2: Incremental output
    yield return new ChatResponseUpdate(ChatRole.Assistant, [
        new CodeExecutionResultContent(stdout: "Processing data...\n")
    ]);

    // Stream 3: More output
    yield return new ChatResponseUpdate(ChatRole.Assistant, [
        new CodeExecutionResultContent(stdout: "Generating visualization...\n")
    ]);

    // Stream 4: Final result with generated content
    yield return new ChatResponseUpdate(ChatRole.Assistant, [
        new CodeExecutionResultContent(
            stdout: "Execution complete!\nResults saved.\n",
            generatedContents: [
                new DataContent(chartImageBytes, "image/png"),
                new DataContent(csvData, "text/csv")
            ]
        )
    ]);
}

// Provider implementation for complete result streaming
public async IAsyncEnumerable<ChatResponseUpdate> StreamCodeExecution(string code)
{
    // Execute code completely, then stream result
    var executionResult = await ExecuteCodeAsync(code);

    yield return new ChatResponseUpdate(ChatRole.Assistant, [
        new CodeExecutionResultContent(
            stdout: executionResult.CompleteOutput,
            stderr: executionResult.ErrorOutput,
            generatedContents: executionResult.GeneratedFiles?.Select(f =>
                new HostedFileContent(f.FileId)).ToList()
        )
    ]);
}

// Provider implementation for mixed content streaming
public async IAsyncEnumerable<ChatResponseUpdate> StreamCodeExecution(string code)
{
    // Stream 1: AI explanation
    yield return new ChatResponseUpdate(ChatRole.Assistant, [
        new TextContent("I'll run this code to analyze your data:")
    ]);

    // Stream 2: Code execution result
    yield return new ChatResponseUpdate(ChatRole.Assistant, [
        new CodeExecutionResultContent(
            stdout: "Data analysis complete\nMean: 42.5, Std: 12.3",
            generatedContents: [
                new DataContent(chartBytes, "image/png")
            ]
        )
    ]);

    // Stream 3: Follow-up explanation
    yield return new ChatResponseUpdate(ChatRole.Assistant, [
        new TextContent("The results show a normal distribution with...")
    ]);
}

var allExecutionResults = new List<CodeExecutionResultContent>();
var allText = new StringBuilder();

await foreach (var update in client.GetStreamingResponseAsync(messages))
{
    foreach (var content in update.Contents)
    {
        switch (content)
        {
            case CodeExecutionResultContent codeResult:
                allExecutionResults.Add(codeResult);

                // Handle incremental output
                if (!string.IsNullOrEmpty(codeResult.Text))
                {
                    Console.Write(codeResult.Text);
                    allText.Append(codeResult.Text);
                }

                // Handle generated content
                if (codeResult.GeneratedContents?.Count > 0)
                {
                    ProcessGeneratedContent(codeResult.GeneratedContents);
                }
                break;

            case TextContent textContent:
                Console.Write(textContent.Text);
                break;
        }
    }
}

// Final combined result
var combinedResult = new CodeExecutionResultContent(
    stdout: allText.ToString(),
    generatedContents: allExecutionResults
        .SelectMany(r => r.GeneratedContents ?? [])
        .ToList()
);

public sealed class CodeExecutionResultContent : AIContent
{
    public IList<AIContent>? GeneratedContents { get; set; }

    [JsonIgnore]
    public string Text { get; }
}