// Кошмар клієнтського коду
try {
  const response = await api.getProduct(id);
} catch (error) {
  // Що тут? Рядок? Об'єкт? Масив?
  if (typeof error === 'string') {
    showError(error);
  } else if (error.message) {
    showError(error.message);
  } else if (error.errors) {
    showValidationErrors(error.errors);
  } else if (error.error_description) {
    showError(error.error_description);
  } else {
    showError('Unknown error');
  }
}

{
  "type": "https://api.bank.com/errors/account-not-found",
  "title": "Account Not Found",
  "status": 404,
  "detail": "Account with ID 12345 does not exist",
  "instance": "/api/accounts/12345",
  "traceId": "00-a1b2c3d4e5f6-7890abcdef-00"
}

{
  "type": "https://tools.ietf.org/html/rfc9457#section-3.1",
  "title": "One or more validation errors occurred",
  "status": 400,
  "errors": {
    "amount": ["Amount must be greater than 0"],
    "accountNumber": ["Invalid account number format"]
  },
  "traceId": "00-xyz123-456-00"
}

{
  "type": "https://api.bank.com/errors/insufficient-funds",
  "title": "Insufficient Funds",
  "status": 409,
  "detail": "Account balance (100.00 USD) is insufficient for transaction (150.00 USD)",
  "balance": 100.00,
  "requiredAmount": 150.00,
  "traceId": "00-abc789-def-00"
}

{
  "type": "https://example.com/errors/out-of-credit",
  "title": "You do not have enough credit",
  "status": 403,
  "detail": "Your current balance is 30, but that costs 50",
  "instance": "/account/12345/transactions/abc"
}

{
  "type": "https://api.bank.com/errors/insufficient-funds",
  "title": "Insufficient Funds",
  "status": 409,
  "detail": "Account balance is insufficient",
  "balance": 100.00,           // Кастомне поле
  "requiredAmount": 150.00,    // Кастомне поле
  "currency": "USD",           // Кастомне поле
  "traceId": "00-abc123-def"   // Кастомне поле
}

public class ProblemDetails
{
    public string? Type { get; set; }
    public string? Title { get; set; }
    public int? Status { get; set; }
    public string? Detail { get; set; }
    public string? Instance { get; set; }
    public IDictionary<string, object?> Extensions { get; set; }
}

public class ValidationProblemDetails : ProblemDetails
{
    public IDictionary<string, string[]> Errors { get; set; }
}

{
  "type": "https://tools.ietf.org/html/rfc9457#section-3.1",
  "title": "One or more validation errors occurred",
  "status": 400,
  "errors": {
    "email": ["Email is required", "Email format is invalid"],
    "age": ["Age must be between 18 and 120"]
  }
}

using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Mvc;
using BankingApi.Exceptions;
using System.Diagnostics;

namespace BankingApi.Handlers;

public class GlobalExceptionHandler : IExceptionHandler
{
    private readonly ILogger<GlobalExceptionHandler> _logger;
    private readonly IHostEnvironment _environment;

    public GlobalExceptionHandler(
        ILogger<GlobalExceptionHandler> logger,
        IHostEnvironment environment)
    {
        _logger = logger;
        _environment = environment;
    }

    public async ValueTask<bool> TryHandleAsync(
        HttpContext httpContext,
        Exception exception,
        CancellationToken cancellationToken)
    {
        var traceId = Activity.Current?.Id ?? httpContext.TraceIdentifier;

        _logger.LogError(
            exception,
            "Exception occurred: {Message}. TraceId: {TraceId}",
            exception.Message,
            traceId);

        var problemDetails = exception switch
        {
            // Бізнес-винятки
            BusinessException businessEx => CreateBusinessProblemDetails(
                businessEx, 
                httpContext, 
                traceId),

            // Валідаційні помилки (не повинні потрапляти сюди через [ApiController])
            ValidationException validationEx => CreateValidationProblemDetails(
                validationEx, 
                httpContext, 
                traceId),

            // Необроблені винятки
            _ => CreateGenericProblemDetails(
                exception, 
                httpContext, 
                traceId)
        };

        httpContext.Response.StatusCode = problemDetails.Status ?? 500;
        httpContext.Response.ContentType = "application/problem+json";

        await httpContext.Response.WriteAsJsonAsync(problemDetails, cancellationToken);

        return true; // Exception handled
    }

    private ProblemDetails CreateBusinessProblemDetails(
        BusinessException exception,
        HttpContext context,
        string traceId)
    {
        var problemDetails = new ProblemDetails
        {
            Type = $"https://api.bank.com/errors/{exception.ErrorType}",
            Title = exception.GetType().Name.Replace("Exception", ""),
            Status = exception.StatusCode,
            Detail = exception.Message,
            Instance = context.Request.Path
        };

        // Додаємо traceId для debugging
        problemDetails.Extensions["traceId"] = traceId;

        // Додаємо кастомні властивості залежно від типу винятку
        switch (exception)
        {
            case InsufficientFundsException insufficientFunds:
                problemDetails.Extensions["balance"] = insufficientFunds.Balance;
                problemDetails.Extensions["requiredAmount"] = insufficientFunds.RequiredAmount;
                problemDetails.Extensions["currency"] = insufficientFunds.Currency;
                break;

            case AccountLockedException accountLocked:
                problemDetails.Extensions["reason"] = accountLocked.Reason;
                if (accountLocked.UnlockedAt.HasValue)
                {
                    problemDetails.Extensions["unlockedAt"] = accountLocked.UnlockedAt.Value;
                }
                break;

            case AccountNotFoundException accountNotFound:
                problemDetails.Extensions["accountId"] = accountNotFound.AccountId;
                break;
        }

        return problemDetails;
    }

    private ValidationProblemDetails CreateValidationProblemDetails(
        ValidationException exception,
        HttpContext context,
        string traceId)
    {
        var problemDetails = new ValidationProblemDetails
        {
            Type = "https://tools.ietf.org/html/rfc9457#section-3.1",
            Title = "One or more validation errors occurred",
            Status = StatusCodes.Status400BadRequest,
            Detail = exception.Message,
            Instance = context.Request.Path
        };

        problemDetails.Extensions["traceId"] = traceId;

        return problemDetails;
    }

    private ProblemDetails CreateGenericProblemDetails(
        Exception exception,
        HttpContext context,
        string traceId)
    {
        var problemDetails = new ProblemDetails
        {
            Type = "https://tools.ietf.org/html/rfc9457#section-3.1",
            Title = "An error occurred while processing your request",
            Status = StatusCodes.Status500InternalServerError,
            Instance = context.Request.Path
        };

        // У development показуємо деталі помилки
        if (_environment.IsDevelopment())
        {
            problemDetails.Detail = exception.Message;
            problemDetails.Extensions["stackTrace"] = exception.StackTrace;
        }
        else
        {
            // У production приховуємо деталі
            problemDetails.Detail = "An unexpected error occurred. Please contact support.";
        }

        problemDetails.Extensions["traceId"] = traceId;

        return problemDetails;
    }
}

using Microsoft.EntityFrameworkCore;
using BankingApi.Data;
using BankingApi.Handlers;

var builder = WebApplication.CreateBuilder(args);

// Реєстрація DbContext
builder.Services.AddDbContext<BankingDbContext>(options =>
    options.UseInMemoryDatabase("BankingDb"));

// Реєстрація Global Exception Handler
builder.Services.AddExceptionHandler<GlobalExceptionHandler>();

// Налаштування ProblemDetails
builder.Services.AddProblemDetails(options =>
{
    // Кастомізація ProblemDetails для всіх помилок
    options.CustomizeProblemDetails = context =>
    {
        // Додаємо machine name для debugging у development
        if (builder.Environment.IsDevelopment())
        {
            context.ProblemDetails.Extensions["machine"] = Environment.MachineName;
        }

        // Додаємо timestamp
        context.ProblemDetails.Extensions["timestamp"] = DateTime.UtcNow;
    };
});

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Ініціалізація бази даних
using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<BankingDbContext>();
    db.Database.EnsureCreated();
}

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

// ВАЖЛИВО: Exception handler має бути перед іншими middleware
app.UseExceptionHandler();

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using BankingApi.Data;
using BankingApi.Models;
using BankingApi.Exceptions;

namespace BankingApi.Controllers;

[ApiController]
[Route("api/[controller]")]
public class AccountsController : ControllerBase
{
    private readonly BankingDbContext _db;
    private readonly ILogger<AccountsController> _logger;

    public AccountsController(BankingDbContext db, ILogger<AccountsController> logger)
    {
        _db = db;
        _logger = logger;
    }

    /// <summary>
    /// Отримати рахунок за номером
    /// </summary>
    [HttpGet("{accountNumber}")]
    [ProducesResponseType(typeof(Account), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    public async Task<ActionResult<Account>> GetByAccountNumber(string accountNumber)
    {
        var account = await _db.Accounts
            .FirstOrDefaultAsync(a => a.AccountNumber == accountNumber);

        if (account is null)
        {
            // Кидаємо кастомний виняток - GlobalExceptionHandler обробить
            throw new AccountNotFoundException(accountNumber);
        }

        return account;
    }

    /// <summary>
    /// Переказ коштів між рахунками
    /// </summary>
    [HttpPost("transfer")]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status409Conflict)]
    public async Task<IActionResult> Transfer(TransferRequest request)
    {
        _logger.LogInformation(
            "Transfer request: {From} -> {To}, Amount: {Amount}",
            request.FromAccountNumber,
            request.ToAccountNumber,
            request.Amount);

        // Валідація: не можна переказувати на той самий рахунок
        if (request.FromAccountNumber == request.ToAccountNumber)
        {
            throw new InvalidTransactionException(
                "Cannot transfer to the same account");
        }

        // Знаходимо рахунки
        var fromAccount = await _db.Accounts
            .FirstOrDefaultAsync(a => a.AccountNumber == request.FromAccountNumber);

        if (fromAccount is null)
        {
            throw new AccountNotFoundException(request.FromAccountNumber);
        }

        var toAccount = await _db.Accounts
            .FirstOrDefaultAsync(a => a.AccountNumber == request.ToAccountNumber);

        if (toAccount is null)
        {
            throw new AccountNotFoundException(request.ToAccountNumber);
        }

        // Перевірка: чи не заблокований рахунок
        if (fromAccount.IsLocked)
        {
            throw new AccountLockedException(
                fromAccount.LockReason ?? "Account is locked");
        }

        // Перевірка: чи достатньо коштів
        if (fromAccount.Balance < request.Amount)
        {
            throw new InsufficientFundsException(
                fromAccount.Balance,
                request.Amount,
                fromAccount.Currency);
        }

        // Виконуємо переказ
        fromAccount.Balance -= request.Amount;
        toAccount.Balance += request.Amount;

        await _db.SaveChangesAsync();

        _logger.LogInformation(
            "Transfer completed: {From} -> {To}, Amount: {Amount}",
            request.FromAccountNumber,
            request.ToAccountNumber,
            request.Amount);

        return Ok(new
        {
            message = "Transfer completed successfully",
            fromBalance = fromAccount.Balance,
            toBalance = toAccount.Balance
        });
    }

    /// <summary>
    /// Заблокувати рахунок
    /// </summary>
    [HttpPost("{accountNumber}/lock")]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
    public async Task<IActionResult> LockAccount(
        string accountNumber,
        [FromBody] string reason)
    {
        var account = await _db.Accounts
            .FirstOrDefaultAsync(a => a.AccountNumber == accountNumber);

        if (account is null)
        {
            throw new AccountNotFoundException(accountNumber);
        }

        account.IsLocked = true;
        account.LockReason = reason;

        await _db.SaveChangesAsync();

        return Ok(new { message = "Account locked successfully" });
    }
}

public class GlobalExceptionFilter : IExceptionFilter
{
    private readonly ILogger<GlobalExceptionFilter> _logger;

    public GlobalExceptionFilter(ILogger<GlobalExceptionFilter> logger)
    {
        _logger = logger;
    }

    public void OnException(ExceptionContext context)
    {
        _logger.LogError(context.Exception, "Unhandled exception occurred");

        var problemDetails = context.Exception switch
        {
            BusinessException businessEx => new ProblemDetails
            {
                Status = businessEx.StatusCode,
                Title = businessEx.GetType().Name,
                Detail = businessEx.Message
            },
            _ => new ProblemDetails
            {
                Status = 500,
                Title = "Internal Server Error",
                Detail = "An unexpected error occurred"
            }
        };

        context.Result = new ObjectResult(problemDetails)
        {
            StatusCode = problemDetails.Status
        };

        context.ExceptionHandled = true;
    }
}

// Реєстрація
builder.Services.AddControllers(options =>
{
    options.Filters.Add<GlobalExceptionFilter>();
});

app.UseExceptionHandler(exceptionHandlerApp =>
{
    exceptionHandlerApp.Run(async context =>
    {
        var exceptionHandlerFeature = context.Features
            .Get<IExceptionHandlerFeature>();

        var exception = exceptionHandlerFeature?.Error;

        var problemDetails = new ProblemDetails
        {
            Status = StatusCodes.Status500InternalServerError,
            Title = "An error occurred",
            Detail = exception?.Message
        };

        context.Response.StatusCode = 500;
        context.Response.ContentType = "application/problem+json";

        await context.Response.WriteAsJsonAsync(problemDetails);
    });
});

public record Result<T>
{
    public bool IsSuccess { get; init; }
    public T? Value { get; init; }
    public string? Error { get; init; }
    public int StatusCode { get; init; }

    public static Result<T> Success(T value) => new()
    {
        IsSuccess = true,
        Value = value,
        StatusCode = 200
    };

    public static Result<T> Failure(string error, int statusCode) => new()
    {
        IsSuccess = false,
        Error = error,
        StatusCode = statusCode
    };
}

// Використання
[HttpGet("{id}")]
public async Task<IActionResult> GetAccount(string id)
{
    var result = await _accountService.GetByIdAsync(id);

    if (!result.IsSuccess)
    {
        return StatusCode(result.StatusCode, new ProblemDetails
        {
            Status = result.StatusCode,
            Detail = result.Error
        });
    }

    return Ok(result.Value);
}

// Middleware для додавання Correlation ID
public class CorrelationIdMiddleware
{
    private readonly RequestDelegate _next;
    private const string CorrelationIdHeader = "X-Correlation-ID";

    public CorrelationIdMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Отримуємо або генеруємо Correlation ID
        var correlationId = context.Request.Headers[CorrelationIdHeader]
            .FirstOrDefault() ?? Guid.NewGuid().ToString();

        // Додаємо до response headers
        context.Response.Headers.Append(CorrelationIdHeader, correlationId);

        // Додаємо до Activity для distributed tracing
        Activity.Current?.SetTag("correlation.id", correlationId);

        // Додаємо до HttpContext для доступу в контролерах
        context.Items["CorrelationId"] = correlationId;

        await _next(context);
    }
}

// Використання в GlobalExceptionHandler
var correlationId = httpContext.Items["CorrelationId"]?.ToString() 
    ?? Activity.Current?.Id 
    ?? httpContext.TraceIdentifier;

problemDetails.Extensions["correlationId"] = correlationId;

public class LocalizedExceptionHandler : IExceptionHandler
{
    private readonly IStringLocalizer<SharedResources> _localizer;

    public LocalizedExceptionHandler(IStringLocalizer<SharedResources> localizer)
    {
        _localizer = localizer;
    }

    public async ValueTask<bool> TryHandleAsync(
        HttpContext httpContext,
        Exception exception,
        CancellationToken cancellationToken)
    {
        var problemDetails = exception switch
        {
            AccountNotFoundException ex => new ProblemDetails
            {
                Title = _localizer["AccountNotFound"],
                Detail = _localizer["AccountNotFoundDetail", ex.AccountId],
                Status = 404
            },
            _ => new ProblemDetails
            {
                Title = _localizer["InternalError"],
                Status = 500
            }
        };

        await httpContext.Response.WriteAsJsonAsync(problemDetails, cancellationToken);
        return true;
    }
}

// Resources/SharedResources.uk.resx
// AccountNotFound = "Рахунок не знайдено"
// AccountNotFoundDetail = "Рахунок з ID '{0}' не існує"

public abstract class BusinessException : Exception
{
    public string ErrorCode { get; }
    
    protected BusinessException(string message, string errorCode) 
        : base(message)
    {
        ErrorCode = errorCode;
    }
}

public class InsufficientFundsException : BusinessException
{
    public InsufficientFundsException(decimal balance, decimal required)
        : base(
            $"Insufficient funds: {balance} < {required}",
            "BANK_001") // Унікальний код
    {
    }
}

// У ProblemDetails
problemDetails.Extensions["errorCode"] = exception.ErrorCode;

if (error.errorCode === 'BANK_001') {
  showInsufficientFundsDialog();
} else if (error.errorCode === 'BANK_002') {
  showAccountLockedDialog();
}