/*
 * Step 1: Initialize a new ASP.NET Core Web API project.
 * Command: dotnet new webapi -o ApiVersioningProject
 * Navigate into the project directory: cd ApiVersioningProject
 */

// Step 2: Install the API Versioning NuGet package
// Command: dotnet add package Microsoft.AspNetCore.Mvc.Versioning

// Step 3: Configure basic API versioning in Startup.cs (or Program.cs for .NET 6+)
// In Program.cs (for .NET 6 and later):

// Add services for API versioning
builder.Services.AddApiVersioning(options =>
{
    options.DefaultApiVersion = new ApiVersion(1, 0); // Set a default API version
    options.AssumeDefaultVersionWhenUnspecified = true; // Use default if client doesn't specify
    options.ReportApiVersions = true; // Report supported API versions in headers
});

// Example of a simple controller without explicit versioning (initially)
// Located in Controllers/WeatherForecastController.cs (or similar)

using Microsoft.AspNetCore.Mvc;

namespace ApiVersioningProject.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        [HttpGet]
        public IEnumerable<WeatherForecast> Get()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
        public string? Summary { get; set; }
    }
}

/*
 * Step 1: Ensure Microsoft.AspNetCore.Mvc.Versioning is installed.
 * If not: dotnet add package Microsoft.AspNetCore.Mvc.Versioning
 */

// Step 2: Configure API Versioning in Program.cs (or Startup.cs)
// This goes within the ConfigureServices method for older .NET versions or directly in Program.cs for .NET 6+

builder.Services.AddApiVersioning(options =>
{
    options.DefaultApiVersion = new ApiVersion(1, 0);
    options.AssumeDefaultVersionWhenUnspecified = true;
    options.ReportApiVersions = true;
});

// Configure the URL segment versioning scheme
builder.Services.AddVersionedApiExplorer(options =>
{
    // Add the versioned API explorer, which also adds IApiVersionDescriptionProvider service
    // Note: The format string below is used to create a URL path segment. 
    // 'v' for version, 'VV' for major.minor version.
    options.GroupNameFormat = "'v'VVV";

    // Enable to substitute the API version parameter in HTTP route templates
    options.SubstituteApiVersionInUrl = true;
});

// Step 3: Modify a controller to support multiple API versions (e.g., WeatherForecastController)
// This demonstrates URL path versioning.

using Microsoft.AspNetCore.Mvc;

namespace ApiVersioningProject.Controllers
{
    [ApiController]
    // Use the Route attribute with a version placeholder to enable URL path versioning.
    // [controller] will be replaced by WeatherForecast, and {version:apiVersion} by v1, v2, etc.
    [Route("api/v{version:apiVersion}/[controller]")] 
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] SummariesV1 = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private static readonly string[] SummariesV2 = new[]
        {
            "Snowy", "Rainy", "Cloudy", "Sunny", "Windy", "Stormy"
        };

        // Mark this action as belonging to API Version 1.0
        [HttpGet]
        [MapToApiVersion("1.0")]
        public IEnumerable<WeatherForecast> GetV1()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = SummariesV1[Random.Shared.Next(SummariesV1.Length)]
            })
            .ToArray();
        }

        // Mark this action as belonging to API Version 2.0
        // Assume WeatherForecast model also changed for V2, e.g., added a "Humidity" field.
        // For simplicity, we just change the summary source here.
        [HttpGet]
        [MapToApiVersion("2.0")]
        public IEnumerable<WeatherForecastV2> GetV2()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecastV2
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-10, 60),
                Summary = SummariesV2[Random.Shared.Next(SummariesV2.Length)],
                Humidity = Random.Shared.Next(30, 95) // New field for V2
            })
            .ToArray();
        }
    }

    // Define a separate model for V2 to demonstrate breaking changes or new fields
    public class WeatherForecastV2 : WeatherForecast
    {
        public int Humidity { get; set; }
    }
}

/*
 * Step 1: Extend API Versioning configuration to include deprecation.
 * In Program.cs (or Startup.cs):
 */

builder.Services.AddApiVersioning(options =>
{
    options.DefaultApiVersion = new ApiVersion(1, 0);
    options.AssumeDefaultVersionWhenUnspecified = true;
    options.ReportApiVersions = true;
    // options.ApiVersionReader = new UrlSegmentApiVersionReader(); // Optional: explicitly set reader
});

// Step 2: Implement a deprecated API version in a controller.
// This example marks API version 1.0 as deprecated.

using Microsoft.AspNetCore.Mvc;

namespace ApiVersioningProject.Controllers
{
    [ApiController]
    [Route("api/v{version:apiVersion}/[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] SummariesV1 = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private static readonly string[] SummariesV2 = new[]
        {
            "Snowy", "Rainy", "Cloudy", "Sunny", "Windy", "Stormy"
        };

        // API Version 1.0 - Marked as deprecated
        [HttpGet]
        [MapToApiVersion("1.0")]
        [Obsolete("This API version is deprecated. Use API v2.0 instead.")] // Standard .NET deprecation attribute
        public IEnumerable<WeatherForecast> GetV1()
        {
            // Log that a deprecated API was accessed
            Console.WriteLine("Deprecated API v1.0 accessed.");
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = SummariesV1[Random.Shared.Next(SummariesV1.Length)]
            })
            .ToArray();
        }

        // API Version 2.0 - Current active version
        [HttpGet]
        [MapToApiVersion("2.0")]
        public IEnumerable<WeatherForecastV2> GetV2()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecastV2
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-10, 60),
                Summary = SummariesV2[Random.Shared.Next(SummariesV2.Length)],
                Humidity = Random.Shared.Next(30, 95)
            })
            .ToArray();
        }

        // A new API Version 3.0 that is not yet fully implemented but could be in development.
        // Not mapped to controller action yet, but could be a future step.
        // [ApiVersion("3.0")] // Can be placed on the controller to indicate future versions.
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
        public string? Summary { get; set; }
    }

    public class WeatherForecastV2 : WeatherForecast
    {
        public int Humidity { get; set; }
    }
}

/*
 * Step 1: Ensure Swagger/OpenAPI integration is set up.
 * If not: dotnet add package Swashbuckle.AspNetCore
 */

// Step 2: Configure Swagger/OpenAPI to document API versions.
// In Program.cs (or Startup.cs):

using Microsoft.AspNetCore.Mvc.ApiExplorer;
using Microsoft.Extensions.Options;
using Swashbuckle.AspNetCore.SwaggerGen;

// Add services for Swagger documentation
builder.Services.AddTransient<IConfigureOptions<SwaggerGenOptions>, ConfigureSwaggerOptions>();
builder.Services.AddSwaggerGen(options =>
{
    // Note: This configures Swagger options via the IConfigureOptions pattern
    // The ConfigureSwaggerOptions class will define the actual Swagger documents for each API version
});

// Create a class to configure Swagger for each API version.
// Add this class to your project (e.g., in a "Swagger" folder or directly in Program.cs/Startup.cs).

public class ConfigureSwaggerOptions : IConfigureOptions<SwaggerGenOptions>
{
    private readonly IApiVersionDescriptionProvider _provider;

    public ConfigureSwaggerOptions(IApiVersionDescriptionProvider provider) => _provider = provider;

    public void Configure(SwaggerGenOptions options)
    {
        // Add a swagger document for each discovered API version.
        // NOTE: You might want to customize info (title, description) based on the version.
        foreach (var description in _provider.ApiVersionDescriptions)
        {
            options.SwaggerDoc(description.GroupName, CreateVersionInfo(description));
        }
    }

    private OpenApiInfo CreateVersionInfo(ApiVersionDescription description)
    {
        var info = new OpenApiInfo()
        {
            Title = "Versioned Weather Forecast API",
            Version = description.ApiVersion.ToString(),
            Description = "An example API for versioning weather forecasts."
        };

        if (description.IsDeprecated)
        {
            info.Description += " <strong>THIS API VERSION HAS BEEN DEPRECATED.</strong>";
        }

        return info;
    }
}

// Step 3: Enable Swagger UI in the request pipeline.

app.UseSwagger();
app.UseSwaggerUI(options =>
{
    // Build a swagger endpoint for each discovered API version
    foreach (var description in app.Services.GetRequiredService<IApiVersionDescriptionProvider>().ApiVersionDescriptions)
    {
        options.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant());
    }
});

// Step 4: Ensure your controller is still set up for versioning as in the previous step.
// Example endpoint for V1 and V2 as before.
// Run the application and navigate to /swagger to see multiple documents for V1 and V2.