public class TodoItem
{
    public long Id { get; set; }
    public string? Name { get; set; }
    public DateTimeOffset? CompletedAt { get; set; }
}

public class ApiDbContext: DbContext
{
    public ApiDbContext(DbContextOptions<ApiDbContext> options) : base(options) { }

    public DbSet<TodoItem> Todos { get; set; }
}

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowAll", policy =>
    {
        policy.AllowAnyHeader()
            .AllowAnyOrigin()
            .AllowAnyMethod();
    });
});
builder.Services.AddOpenApi();
builder.Services.AddFastEndpoints();
builder.Services.AddDbContext<ApiDbContext>(options =>
    options.UseInMemoryDatabase("TodoApiDB"));

var app = builder.Build();
if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
}
app.UseCors("AllowAll");
app.MapFastEndpoints();
app.Run();

public class ListTodosEndpoint(ApiDbContext db)
    : EndpointWithoutRequest<List<TodoItem>>
{
    public override void Configure()
    {
        Get("/api/todos");
        Description(b => b
            .WithTags("Todos")
            .Produces<List<TodoItem>>(200)
            .WithSummary("Lists all Todo items")
            .WithDescription("Lists all Todo items")
        );
        AllowAnonymous();
    }

    public override async Task HandleAsync(CancellationToken ct)
    {
        var todos = await db.Todos.ToListAsync(ct);
        await Send.OkAsync(todos, cancellation: ct);
    }
}

public class CreateTodoEndpoint(ApiDbContext db) : Endpoint<TodoItem>
{
    public override void Configure()
    {
        Post("/api/todos");
        Description(b => b
            .WithTags("Todos")
            .Produces<TodoItem>(201)
            .Produces(400)
            .WithSummary("Creates a new Todo item")
            .WithDescription("Creates a new Todo item")
        );
        AllowAnonymous();
    }

    public override async Task HandleAsync(TodoItem request, CancellationToken ct)
    {
        db.Todos.Add(request);
        await db.SaveChangesAsync(ct);
        await Send.CreatedAtAsync($"/api/todos/{request.Id}", request, cancellation: ct);
    }
}

public class UpdateTodoEndpoint(ApiDbContext db) : Endpoint<TodoItem>
{
    public override void Configure()
    {
        Put("/api/todos");
        Description(b => b
            .WithTags("Todos")
            .Produces(204)
            .Produces(400)
            .Produces(404)
            .WithSummary("Updates a Todo item by ID")
            .WithDescription("Updates a Todo item by ID")
        );
        AllowAnonymous();
    }

    public override async Task HandleAsync(TodoItem request, CancellationToken ct)
    {
        var existingTodo = await db.Todos.FirstOrDefaultAsync(t => t.Id == request.Id, ct);
        if (existingTodo == null)
        {
            await Send.NotFoundAsync(cancellation: ct);
            return;
        }

        existingTodo.Name = request.Name;
        existingTodo.CompletedAt = request.CompletedAt;

        await db.SaveChangesAsync(ct);
        await Send.NoContentAsync(cancellation: ct);
    }
}

public class DeleteTodoEndpoint(ApiDbContext db) : Endpoint<TodoItem>
{
    public override void Configure()
    {
        Delete("/api/todos");
        Description(b => b
            .WithTags("Todos")
            .Produces(204)
            .Produces(404)
            .WithSummary("Deletes a Todo item by ID")
            .WithDescription("Deletes a Todo item by ID")
        );
        AllowAnonymous();
    }

    public override async Task HandleAsync(TodoItem request, CancellationToken ct)
    {
        var existingTodo = await db.Todos.FirstOrDefaultAsync(t => t.Id == request.Id, ct);
        if (existingTodo == null)
        {
            await Send.NotFoundAsync(cancellation: ct);
            return;
        }

        db.Todos.Remove(existingTodo);
        await db.SaveChangesAsync(ct);
        await Send.NoContentAsync(cancellation: ct);
    }
}