using Microsoft.Extensions.Hosting;
using ModelContextProtocol;

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddMcpServer(options =>
{
    options.ServerInfo = new ServerInfo
    {
        Name = "demo-mcp-server",
        Version = "1.0.0"
    };
});

var host = builder.Build();
await host.RunAsync();

[McpTool("get_weather", "Récupère la météo pour une ville donnée")]
public class WeatherTool : IMcpTool
{
    public async Task<ToolResult> ExecuteAsync(ToolCallRequest request)
    {
        var city = request.Parameters["city"].ToString();
        
        // Appel API météo (exemple simplifié)
        var response = await httpClient.GetAsync($"https://api.openweathermap.org/data/2.5/weather?q={city}");
        var weather = await response.Content.ReadAsStringAsync();
        
        return new ToolResult { Content = weather };
    }
}

[McpTool("search_news", "Recherche des actualités")]
public class NewsSearchTool : IMcpTool
{
    private readonly IHttpClientFactory _httpClientFactory;
    
    public async Task<ToolResult> ExecuteAsync(ToolCallRequest request)
    {
        var query = request.Parameters["query"].ToString();
        var client = _httpClientFactory.CreateClient();
        
        var response = await client.GetAsync(
            $"https://newsapi.org/v2/everything?q={query}&apiKey={apiKey}"
        );
        
        return new ToolResult 
        { 
            Content = await response.Content.ReadAsStringAsync() 
        };
    }
}

[McpResource("config://settings", "Configuration de l'application")]
public class ConfigResource : IMcpResource
{
    public async Task<ResourceContent> ReadAsync()
    {
        var json = await File.ReadAllTextAsync("appsettings.json");
        return new ResourceContent 
        { 
            MimeType = "application/json",
            Text = json 
        };
    }
}

builder.Services.AddLogging(logging =>
{
    logging.AddConsole();
    logging.AddDebug();
    logging.SetMinimumLevel(LogLevel.Debug);
});

[Function("McpEndpoint")]
public async Task<HttpResponseData> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
{
    // Gérer les requêtes MCP via HTTP
    var mcpRequest = await req.ReadFromJsonAsync<McpRequest>();
    var result = await _mcpServer.HandleRequestAsync(mcpRequest);
    
    var response = req.CreateResponse(HttpStatusCode.OK);
    await response.WriteAsJsonAsync(result);
    return response;
}

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Azure.AI.OpenAI;
using Azure.Identity;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "gpt-4";

// Créer un agent MCP avec outils
AIAgent mcpAgent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .CreateAIAgent(
        instructions: "Tu es un assistant utilisant des outils MCP.",
        name: "McpDurableAgent"
    );

// Ajouter les tools MCP
mcpAgent.Tools.Add(new WeatherTool());
mcpAgent.Tools.Add(new ConfigResourceTool());

// Configurer l'application avec Durable Task Extension
using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options =>
        options.AddAIAgent(mcpAgent)
    )
    .Build();

app.Run();

public async Task<ToolResult> ExecuteAsync(ToolCallRequest request)
{
    if (!request.Parameters.ContainsKey("city"))
        throw new ArgumentException("Le paramètre 'city' est requis");
        
    var city = request.Parameters["city"].ToString();
    if (string.IsNullOrWhiteSpace(city) || city.Length > 100)
        throw new ArgumentException("Nom de ville invalide");
    
    // ... suite du code
}

try
{
    var result = await externalApi.CallAsync();
    return new ToolResult { Content = result };
}
catch (HttpRequestException ex)
{
    return new ToolResult 
    { 
        IsError = true, 
        Content = $"Erreur API : {ex.Message}" 
    };
}

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("api", opt =>
    {
        opt.PermitLimit = 100;
        opt.Window = TimeSpan.FromMinutes(1);
    });
});

builder.Services.AddApplicationInsightsTelemetry();

// Dans votre tool
_telemetryClient.TrackEvent("ToolExecuted", new Dictionary<string, string>
{
    { "ToolName", "get_weather" },
    { "City", city }
});

var client = new AzureOpenAIClient(endpoint, credential);
var agent = await client.CreateAgentAsync(new AgentCreateOptions
{
    Model = "gpt-4",
    Name = "Assistant Météo",
    Tools = new[]
    {
        new McpToolReference 
        { 
            ServerUrl = "https://mcp-server.azurecontainerapps.io",
            ToolName = "get_weather"
        }
    }
});

builder.Services.AddHealthChecks()
    .AddCheck("mcp_server", () => HealthCheckResult.Healthy())
    .AddUrlGroup(new Uri("https://api.external.com/health"), "external_api");

app.MapHealthChecks("/health");