using RestClient.Net.OpenApiGenerator;

// Load your OpenAPI specification
var openApiContent = File.ReadAllText("openapi.json");

// Generate code
var result = OpenApiCodeGenerator.Generate(
    openApiContent,
    @namespace: "MyApi.Client",
    className: "MyApiExtensions"
);

// Write generated files
File.WriteAllText("MyApiExtensions.cs", result.ExtensionMethodsCode);
File.WriteAllText("Models.cs", result.ModelsCode);

using System.Net.Http.Json;
using System.Text.Json;
using RestClient.Net;
using RestClient.Net.Utilities;
using Urls;

namespace MyApi.Client;

/// <summary>Extension methods for API operations.</summary>
public static class MyApiExtensions
{
    private static readonly AbsoluteUrl BaseUrl = "https://api.example.com".ToAbsoluteUrl();

    /// <summary>GetUsers operation.</summary>
#pragma warning disable CA2000
    public static Task<Result<List<User>, HttpError<string>>> GetUsers(
        this IHttpClientFactory httpClientFactory,
        CancellationToken ct = default
    ) =>
        httpClientFactory
            .CreateClient()
            .GetAsync(
                BaseUrl.WithRelativeUrl(new RelativeUrl("/users")),
                DeserializeJson<List<User>>,
                DeserializeError,
                ct
            );
#pragma warning restore CA2000

    /// <summary>GetUserById operation.</summary>
    public static Task<Result<User, HttpError<string>>> GetUserById(
        this IHttpClientFactory httpClientFactory,
        int id,
        CancellationToken ct
    ) =>
        httpClientFactory.CreateGet<User, string, int>(
            url: BaseUrl,
            getRelativeUrl: id => new RelativeUrl($"/users/{id}"),
            deserializeSuccess: DeserializeJson<User>,
            deserializeError: DeserializeError
        )(id, ct);

    /// <summary>CreateUser operation.</summary>
    public static Task<Result<User, HttpError<string>>> CreateUser(
        this IHttpClientFactory httpClientFactory,
        User body,
        CancellationToken ct
    ) =>
        httpClientFactory.CreatePost<User, string, User>(
            url: BaseUrl,
            getRelativeUrl: _ => new RelativeUrl("/users"),
            deserializeSuccess: DeserializeJson<User>,
            deserializeError: DeserializeError,
            deserializeRequest: CreateJsonContent
        )(body, ct);

    /// <summary>DeleteUser operation.</summary>
    public static Task<Result<Unit, HttpError<string>>> DeleteUser(
        this IHttpClientFactory httpClientFactory,
        int id,
        CancellationToken ct
    ) =>
        httpClientFactory.CreateDelete<Unit, string, int>(
            url: BaseUrl,
            getRelativeUrl: id => new RelativeUrl($"/users/{id}"),
            deserializeSuccess: static (_, _) => Task.FromResult(Unit.Value),
            deserializeError: DeserializeError
        )(id, ct);

    // Helper methods...
}

namespace MyApi.Client;

/// <summary>User.</summary>
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

using Microsoft.Extensions.DependencyInjection;
using MyApi.Client;

// Setup
var services = new ServiceCollection();
services.AddHttpClient();
var provider = services.BuildServiceProvider();
var httpClientFactory = provider.GetRequiredService<IHttpClientFactory>();

// Use the generated extension methods
var usersResult = await httpClientFactory.GetUsers();
var userResult = await httpClientFactory.GetUserById(123, CancellationToken.None);

// Result pattern handling
usersResult.Match(
    success => Console.WriteLine($"Got {success.Count} users"),
    error => Console.WriteLine($"Error: {error.ErrorContent}")
);