app.MapGet("/api/todos/{id}", async (int id, TodoDbContext db) =>
{
    var todo = await db.Todos.FindAsync(id);
    return todo is not null ? Results.Ok(todo) : Results.NotFound();
});

[ApiController]
[Route("api/[controller]")]
public class TodosController : ControllerBase
{
    private readonly TodoDbContext _db;

    public TodosController(TodoDbContext db)
    {
        _db = db;
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<Todo>> GetById(int id)
    {
        var todo = await _db.Todos.FindAsync(id);
        return todo is not null ? Ok(todo) : NotFound();
    }
}

// БЕЗ [ApiController] — ручна перевірка
[HttpPost]
public async Task<IActionResult> Create(CreateTodoDto dto)
{
    if (!ModelState.IsValid) // Ручна перевірка
    {
        return BadRequest(ModelState); // Ручне повернення помилки
    }
    
    // Логіка створення...
}

// З [ApiController] — автоматична валідація
[ApiController]
[Route("api/[controller]")]
public class TodosController : ControllerBase
{
    [HttpPost]
    public async Task<IActionResult> Create(CreateTodoDto dto)
    {
        // ModelState вже перевірено! Якщо ми тут — модель валідна
        // Логіка створення...
    }
}

{
  "type": "https://tools.ietf.org/html/rfc9457#section-3.1",
  "title": "One or more validation errors occurred.",
  "status": 400,
  "errors": {
    "Title": ["The Title field is required."],
    "DueDate": ["The field DueDate must be between 01/01/2024 and 12/31/2030."]
  }
}

// БЕЗ [ApiController]
[HttpPost]
public IActionResult Create([FromBody] CreateTodoDto dto) // Явний [FromBody]
{
    // ...
}

// З [ApiController] — автоматичний inference
[HttpPost]
public IActionResult Create(CreateTodoDto dto) // [FromBody] додається автоматично
{
    // dto автоматично десеріалізується з JSON-тіла запиту
}

[HttpGet("{id}")]
public IActionResult GetById(int id) // [FromRoute] додається автоматично
{
    // id автоматично береться з URL
}

[HttpGet]
public IActionResult Search(string query) // [FromQuery] додається автоматично
{
    // query береться з ?query=...
}

[HttpGet]
public IActionResult Filter([FromQuery] TodoFilterDto filter) // Явне перевизначення
{
    // filter десеріалізується з query string: ?status=completed&priority=high
}

[ApiController] // Помилка компіляції, якщо немає [Route]!
public class TodosController : ControllerBase
{
    // ...
}

[ApiController]
[Route("api/[controller]")] // Обов'язковий атрибут
public class TodosController : ControllerBase
{
    // ...
}

[HttpGet("{id}")]
public ActionResult<Todo> GetById(int id)
{
    var todo = _db.Todos.Find(id);
    if (todo is null)
        return NotFound(); // Автоматично перетворюється на ProblemDetails
    
    return Ok(todo);
}

{
  "type": "https://tools.ietf.org/html/rfc9457#section-3.1",
  "title": "Not Found",
  "status": 404,
  "traceId": "00-a1b2c3d4e5f6-7890abcdef-00"
}

// ============= MINIMAL API ENDPOINTS =============

var todosGroup = app.MapGroup("/api/todos")
    .WithTags("Todos (Minimal API)")
    .WithOpenApi();

// GET /api/todos - Отримати всі завдання
todosGroup.MapGet("/", async (TodoDbContext db) =>
{
    var todos = await db.Todos
        .OrderByDescending(t => t.CreatedAt)
        .ToListAsync();
    
    return Results.Ok(todos.Select(t => new TodoResponseDto
    {
        Id = t.Id,
        Title = t.Title,
        Description = t.Description,
        IsCompleted = t.IsCompleted,
        CreatedAt = t.CreatedAt,
        CompletedAt = t.CompletedAt
    }));
})
.Produces<IEnumerable<TodoResponseDto>>(StatusCodes.Status200OK);

// GET /api/todos/{id} - Отримати завдання за ID
todosGroup.MapGet("/{id:int}", async (int id, TodoDbContext db) =>
{
    var todo = await db.Todos.FindAsync(id);
    
    if (todo is null)
        return Results.NotFound(new { message = $"Todo with ID {id} not found" });
    
    var response = new TodoResponseDto
    {
        Id = todo.Id,
        Title = todo.Title,
        Description = todo.Description,
        IsCompleted = todo.IsCompleted,
        CreatedAt = todo.CreatedAt,
        CompletedAt = todo.CompletedAt
    };
    
    return Results.Ok(response);
})
.Produces<TodoResponseDto>(StatusCodes.Status200OK)
.Produces(StatusCodes.Status404NotFound);

// POST /api/todos - Створити нове завдання
todosGroup.MapPost("/", async (CreateTodoDto dto, TodoDbContext db) =>
{
    // Ручна валідація (у Minimal API немає автоматичної)
    var validationResults = new List<ValidationResult>();
    var validationContext = new ValidationContext(dto);
    
    if (!Validator.TryValidateObject(dto, validationContext, validationResults, true))
    {
        var errors = validationResults
            .GroupBy(r => r.MemberNames.FirstOrDefault() ?? "")
            .ToDictionary(
                g => g.Key,
                g => g.Select(r => r.ErrorMessage ?? "").ToArray()
            );
        
        return Results.ValidationProblem(errors);
    }
    
    var todo = new Todo
    {
        Title = dto.Title,
        Description = dto.Description,
        IsCompleted = false,
        CreatedAt = DateTime.UtcNow
    };
    
    db.Todos.Add(todo);
    await db.SaveChangesAsync();
    
    var response = new TodoResponseDto
    {
        Id = todo.Id,
        Title = todo.Title,
        Description = todo.Description,
        IsCompleted = todo.IsCompleted,
        CreatedAt = todo.CreatedAt,
        CompletedAt = todo.CompletedAt
    };
    
    return Results.Created($"/api/todos/{todo.Id}", response);
})
.Produces<TodoResponseDto>(StatusCodes.Status201Created)
.Produces(StatusCodes.Status400BadRequest);

// PUT /api/todos/{id} - Оновити завдання
todosGroup.MapPut("/{id:int}", async (int id, UpdateTodoDto dto, TodoDbContext db) =>
{
    var todo = await db.Todos.FindAsync(id);
    
    if (todo is null)
        return Results.NotFound(new { message = $"Todo with ID {id} not found" });
    
    // Оновлюємо тільки ті поля, що передані
    if (dto.Title is not null)
        todo.Title = dto.Title;
    
    if (dto.Description is not null)
        todo.Description = dto.Description;
    
    if (dto.IsCompleted.HasValue)
    {
        todo.IsCompleted = dto.IsCompleted.Value;
        todo.CompletedAt = dto.IsCompleted.Value ? DateTime.UtcNow : null;
    }
    
    await db.SaveChangesAsync();
    
    var response = new TodoResponseDto
    {
        Id = todo.Id,
        Title = todo.Title,
        Description = todo.Description,
        IsCompleted = todo.IsCompleted,
        CreatedAt = todo.CreatedAt,
        CompletedAt = todo.CompletedAt
    };
    
    return Results.Ok(response);
})
.Produces<TodoResponseDto>(StatusCodes.Status200OK)
.Produces(StatusCodes.Status404NotFound);

// DELETE /api/todos/{id} - Видалити завдання
todosGroup.MapDelete("/{id:int}", async (int id, TodoDbContext db) =>
{
    var todo = await db.Todos.FindAsync(id);
    
    if (todo is null)
        return Results.NotFound(new { message = $"Todo with ID {id} not found" });
    
    db.Todos.Remove(todo);
    await db.SaveChangesAsync();
    
    return Results.NoContent();
})
.Produces(StatusCodes.Status204NoContent)
.Produces(StatusCodes.Status404NotFound);

// У Program.cs, після AddDbContext
builder.Services.AddControllers(); // Розкоментуйте цей рядок

// Перед app.Run()
app.MapControllers(); // Додайте цей рядок

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using TodoApi.Data;
using TodoApi.DTOs;
using TodoApi.Models;

namespace TodoApi.Controllers;

[ApiController]
[Route("api/[controller]")]
[Produces("application/json")]
public class TodosController : ControllerBase
{
    private readonly TodoDbContext _db;
    private readonly ILogger<TodosController> _logger;

    public TodosController(TodoDbContext db, ILogger<TodosController> logger)
    {
        _db = db;
        _logger = logger;
    }

    /// <summary>
    /// Отримати всі завдання
    /// </summary>
    /// <returns>Список всіх завдань</returns>
    [HttpGet]
    [ProducesResponseType(typeof(IEnumerable<TodoResponseDto>), StatusCodes.Status200OK)]
    public async Task<ActionResult<IEnumerable<TodoResponseDto>>> GetAll()
    {
        _logger.LogInformation("Fetching all todos");
        
        var todos = await _db.Todos
            .OrderByDescending(t => t.CreatedAt)
            .ToListAsync();
        
        var response = todos.Select(MapToDto);
        
        return Ok(response);
    }

    /// <summary>
    /// Отримати завдання за ID
    /// </summary>
    /// <param name="id">Ідентифікатор завдання</param>
    /// <returns>Завдання або 404</returns>
    [HttpGet("{id:int}")]
    [ProducesResponseType(typeof(TodoResponseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<TodoResponseDto>> GetById(int id)
    {
        _logger.LogInformation("Fetching todo with ID {TodoId}", id);
        
        var todo = await _db.Todos.FindAsync(id);
        
        if (todo is null)
        {
            _logger.LogWarning("Todo with ID {TodoId} not found", id);
            return NotFound(new { message = $"Todo with ID {id} not found" });
        }
        
        return Ok(MapToDto(todo));
    }

    /// <summary>
    /// Створити нове завдання
    /// </summary>
    /// <param name="dto">Дані для створення</param>
    /// <returns>Створене завдання</returns>
    [HttpPost]
    [ProducesResponseType(typeof(TodoResponseDto), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<TodoResponseDto>> Create(CreateTodoDto dto)
    {
        // Валідація відбувається автоматично завдяки [ApiController]!
        
        _logger.LogInformation("Creating new todo: {Title}", dto.Title);
        
        var todo = new Todo
        {
            Title = dto.Title,
            Description = dto.Description,
            IsCompleted = false,
            CreatedAt = DateTime.UtcNow
        };
        
        _db.Todos.Add(todo);
        await _db.SaveChangesAsync();
        
        var response = MapToDto(todo);
        
        return CreatedAtAction(
            nameof(GetById), 
            new { id = todo.Id }, 
            response
        );
    }


    /// <summary>
    /// Оновити існуюче завдання
    /// </summary>
    /// <param name="id">Ідентифікатор завдання</param>
    /// <param name="dto">Дані для оновлення</param>
    /// <returns>Оновлене завдання або 404</returns>
    [HttpPut("{id:int}")]
    [ProducesResponseType(typeof(TodoResponseDto), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<TodoResponseDto>> Update(int id, UpdateTodoDto dto)
    {
        _logger.LogInformation("Updating todo with ID {TodoId}", id);
        
        var todo = await _db.Todos.FindAsync(id);
        
        if (todo is null)
        {
            _logger.LogWarning("Todo with ID {TodoId} not found", id);
            return NotFound(new { message = $"Todo with ID {id} not found" });
        }
        
        // Оновлюємо тільки передані поля
        if (dto.Title is not null)
            todo.Title = dto.Title;
        
        if (dto.Description is not null)
            todo.Description = dto.Description;
        
        if (dto.IsCompleted.HasValue)
        {
            todo.IsCompleted = dto.IsCompleted.Value;
            todo.CompletedAt = dto.IsCompleted.Value ? DateTime.UtcNow : null;
        }
        
        await _db.SaveChangesAsync();
        
        return Ok(MapToDto(todo));
    }

    /// <summary>
    /// Видалити завдання
    /// </summary>
    /// <param name="id">Ідентифікатор завдання</param>
    /// <returns>204 No Content або 404</returns>
    [HttpDelete("{id:int}")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> Delete(int id)
    {
        _logger.LogInformation("Deleting todo with ID {TodoId}", id);
        
        var todo = await _db.Todos.FindAsync(id);
        
        if (todo is null)
        {
            _logger.LogWarning("Todo with ID {TodoId} not found", id);
            return NotFound(new { message = $"Todo with ID {id} not found" });
        }
        
        _db.Todos.Remove(todo);
        await _db.SaveChangesAsync();
        
        return NoContent();
    }

    // Приватний допоміжний метод для маппінгу
    private static TodoResponseDto MapToDto(Todo todo) => new()
    {
        Id = todo.Id,
        Title = todo.Title,
        Description = todo.Description,
        IsCompleted = todo.IsCompleted,
        CreatedAt = todo.CreatedAt,
        CompletedAt = todo.CompletedAt
    };
}

// Потрібен WebApplicationFactory для інтеграційних тестів
public class TodosMinimalApiTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;
    
    public TodosMinimalApiTests(WebApplicationFactory<Program> factory)
    {
        _client = factory.CreateClient();
    }
    
    [Fact]
    public async Task GetAll_ReturnsOkResult()
    {
        var response = await _client.GetAsync("/api/todos");
        response.EnsureSuccessStatusCode();
        // ...
    }
}

// Можна писати прості unit-тести методів
public class TodosControllerTests
{
    [Fact]
    public async Task GetAll_ReturnsOkResult()
    {
        // Arrange
        var mockDb = CreateMockDbContext();
        var controller = new TodosController(mockDb, Mock.Of<ILogger<TodosController>>());
        
        // Act
        var result = await controller.GetAll();
        
        // Assert
        var okResult = Assert.IsType<OkObjectResult>(result.Result);
        var todos = Assert.IsAssignableFrom<IEnumerable<TodoResponseDto>>(okResult.Value);
        Assert.NotEmpty(todos);
    }
}

app.MapPost("/api/todos", async (CreateTodoDto dto, TodoDbContext db) =>
{
    var validationResults = new List<ValidationResult>();
    var validationContext = new ValidationContext(dto);
    
    if (!Validator.TryValidateObject(dto, validationContext, validationResults, true))
    {
        return Results.ValidationProblem(/* ... */);
    }
    
    var todo = new Todo { Title = dto.Title, /* ... */ };
    db.Todos.Add(todo);
    await db.SaveChangesAsync();
    
    return Results.Created($"/api/todos/{todo.Id}", MapToDto(todo));
});

[HttpPost]
public async Task<ActionResult<TodoResponseDto>> Create(CreateTodoDto dto)
{
    // Валідація автоматична!
    var todo = new Todo { Title = dto.Title, /* ... */ };
    _db.Todos.Add(todo);
    await _db.SaveChangesAsync();
    
    return CreatedAtAction(nameof(GetById), new { id = todo.Id }, MapToDto(todo));
}