// --- In your Program.cs or Startup.cs ---
using A2Adotnet.Client;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices((context, services) =>
    {
        // Configure options (e.g., from appsettings.json)
        services.AddOptions<A2AClientOptions>()
            .Bind(context.Configuration.GetSection("A2AClient"));

        // Add the A2A client
        services.AddA2AClient();

        // Register your service that uses IA2AClient
        services.AddTransient<MyAgentInteractor>();
    })
    .Build();

var interactor = host.Services.GetRequiredService<MyAgentInteractor>();
await interactor.RunAsync();

// --- Your service using the client ---
using A2Adotnet.Client;
using A2Adotnet.Common.Models;

public class MyAgentInteractor
{
    private readonly IA2AClient _a2aClient;

    public MyAgentInteractor(IA2AClient a2aClient)
    {
        _a2aClient = a2aClient;
    }

    public async Task RunAsync()
    {
        try
        {
            var taskId = Guid.NewGuid().ToString();
            var message = new Message("user", new List<Part> { new TextPart("Tell me a joke") });
            var resultTask = await _a2aClient.SendTaskAsync(taskId, message);

            Console.WriteLine($"Task {resultTask.Id} completed with status: {resultTask.Status.State}");
            // Process resultTask.Artifacts...
        }
        catch (A2AClientException ex)
        {
            Console.WriteLine($"A2A Client Error: {ex.Message}");
        }
    }
}

// --- In your ASP.NET Core Program.cs ---
using A2Adotnet.Server;
using A2Adotnet.Common.Models;
using A2Adotnet.Server.Abstractions; // For IAgentLogicInvoker

var builder = WebApplication.CreateBuilder(args);

// Add A2A Server services
builder.Services.AddA2AServer(options =>
{
    // Configure AgentCard, typically binding from appsettings.json
    builder.Configuration.GetSection("AgentCard").Bind(options);
    // Example manual configuration:
    // options.Name = "My A2A Agent";
    // options.Url = "https://my-agent.example.com/a2a";
    // options.Version = "1.0";
    // options.Capabilities = new AgentCapabilities { Streaming = true };
    // options.Skills = new List<AgentSkill> { /* ... */ };
});

// Register your agent logic implementation
builder.Services.AddScoped<IAgentLogicInvoker, MyAgentLogic>();
// AddA2AServer registers default ITaskManager, ISseConnectionManager etc.
// Use builder extensions like .AddTaskManager<MyDbTaskManager>() to override defaults.

var app = builder.Build();

app.UseRouting();
// Add Auth middleware if needed: app.UseAuthentication(); app.UseAuthorization();

// Map A2A endpoints
app.MapA2AWellKnown(); // Serves /.well-known/agent.json
app.MapA2AEndpoint();  // Serves /a2a (or configured path)

app.Run();

// --- Your Agent Logic Implementation ---
public class MyAgentLogic : IAgentLogicInvoker
{
    private readonly ITaskManager _taskManager;
    // Inject other services like ISseConnectionManager if needed

    public MyAgentLogic(ITaskManager taskManager)
    {
        _taskManager = taskManager;
    }

    public async Task ProcessTaskAsync(Common.Models.Task task, Message triggeringMessage, CancellationToken cancellationToken)
    {
        // 1. Update status to working
        await _taskManager.UpdateTaskStatusAsync(task.Id, TaskState.Working, null, cancellationToken);

        // 2. Perform agent work based on triggeringMessage
        var resultText = "Processed: " + triggeringMessage.Parts.OfType<TextPart>().FirstOrDefault()?.Text;
        var resultArtifact = new Artifact(Parts: new List<Part> { new TextPart(resultText) });

        // 3. Add artifacts and set final status
        await _taskManager.AddArtifactAsync(task.Id, resultArtifact, cancellationToken);
        await _taskManager.UpdateTaskStatusAsync(task.Id, TaskState.Completed, null, cancellationToken);
    }
}