namespace BlazorOnionDemo.Domain.Entity;

public class Author
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Book> Books { get; set; }
}

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Description { get; set; }
    public Author Author { get; set; }
}

namespace BlazorOnionDemo.Application.Contracts.Commands;

public interface IAuthorCommand
{
    Task CreateAsync(AuthorCreateCommandDto dto);
    Task AddBookToAuthorAsync(AddBookToAuthorCommandDto dto);
}

public class AddBookToAuthorCommandDto
{
    public int AuthorId { get; set; }
    public BookCreateCommandDto Book { get; set; }
}

public class AuthorCreateCommandDto
{
    public string Name { get; set; }
}

public class BookCreateCommandDto
{
    public string Title { get; set; }
    public string Description { get; set; }
}

namespace BlazorOnionDemo.Application.Contracts.Commands;

public interface IBookCommand
{
    Task CreateAsync(BookCreateCommandDto dto);
}

namespace BlazorOnionDemo.Application.Contracts.Queries;

public interface IAuthorQuery
{
    Task<AuthorDto> GetByIdAsync(int id);
    Task<List<AuthorDto>> GetAllAsync();
}

public class AuthorDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<AuthorBookDto> Books { get; set; }
}

public class AuthorBookDto
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Description { get; set; }
}

namespace BlazorOnionDemo.Application.Contracts.Queries;

public interface IBookQuery
{
    Task<BookDto> GetByIdAsync(int id);
    Task<List<BookDto>> GetAllAsync();
}

public class BookDto
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Description { get; set; }
    public BookAuthorDto Author { get; set; }
}

public class BookAuthorDto
{
    public int Id { get; set; }
    public string Name { get; set; }    
}

using BlazorOnionDemo.Domain.Entity;

namespace BlazorOnionDemo.Application.Repositories;

public interface IAuthorRepository
{
    Task<Author> LoadAsync(int id);
    Task<int> SaveAsync();
    Task AddAsync(Author author);
}

using BlazorOnionDemo.Domain.Entity;

namespace BlazorOnionDemo.Application.Repositories;

public interface IBookRepository
{
    Task<Book> LoadAsync(int id);
    Task<int> SaveAsync();
    Task AddAsync(Book author);
}

using BlazorOnionDemo.Application.Contracts.Commands;
using BlazorOnionDemo.Application.Repositories;
using BlazorOnionDemo.Domain.Entity;

namespace BlazorOnionDemo.Application.CommandHandlers;

public class AuthorCommand : IAuthorCommand
{
    private readonly IAuthorRepository _repository;

    public AuthorCommand(IAuthorRepository repository)
    {
        _repository = repository;
    }
    async Task IAuthorCommand.AddBookToAuthorAsync(AddBookToAuthorCommandDto dto)
    {
        var author = await _repository.LoadAsync(dto.AuthorId);
        if (author == null)
        {
            throw new Exception("Author not found");
        }

        var book = new Book
        {
            Title = dto.Book.Title,
            Description = dto.Book.Description
        };
        author.Books.Add(book);
        await _repository.SaveAsync();

    }

    async Task IAuthorCommand.CreateAsync(AuthorCreateCommandDto dto)
    {
        var author = new Author { Name = dto.Name };
        await _repository.AddAsync(author);
    }
}

using BlazorOnionDemo.Application.Contracts.Commands;

namespace BlazorOnionDemo.Application.CommandHandlers;

public class BookCommand : IBookCommand
{
    async Task IBookCommand.CreateAsync(BookCreateCommandDto dto)
    {
        throw new NotImplementedException();
    }
}

using BlazorOnionDemo.Application.Repositories;
using BlazorOnionDemo.Domain.Entity;
using BlazorOnionDemo.Infrastructure.Database;
using Microsoft.EntityFrameworkCore;

namespace BlazorOnionDemo.Infrastructure.Repositories;

public class AuthorRepository : IAuthorRepository
{
    private readonly OrmContext _db;

    public AuthorRepository(OrmContext db)
    {
        _db = db;
    }
    async Task IAuthorRepository.AddAsync(Author author)
    {
        _db.Authors.Add(author);
        await _db.SaveChangesAsync();
    }

    async Task<Author> IAuthorRepository.LoadAsync(int id)
    {
        return await _db.Authors.Include(a => a.Books).FirstAsync(a => a.Id == id);
    }

    async Task<int> IAuthorRepository.SaveAsync()
    {
        return await _db.SaveChangesAsync();
    }
}

using BlazorOnionDemo.Application.Repositories;
using BlazorOnionDemo.Domain.Entity;

namespace BlazorOnionDemo.Infrastructure.Repositories;

public class BookRepository : IBookRepository
{
    async Task IBookRepository.AddAsync(Book author)
    {
        throw new NotImplementedException();
    }

    async Task<Book> IBookRepository.LoadAsync(int id)
    {
        throw new NotImplementedException();
    }

    async Task<int> IBookRepository.SaveAsync()
    {
        throw new NotImplementedException();
    }
}

using BlazorOnionDemo.Application.Contracts.Queries;
using BlazorOnionDemo.Infrastructure.Database;
using Microsoft.EntityFrameworkCore;

namespace BlazorOnionDemo.Infrastructure.Queries;

public class AuthorQuery : IAuthorQuery
{
    private readonly OrmContext _db;

    public AuthorQuery(OrmContext db)
    {
        _db = db;
    }

    async Task<List<AuthorDto>> IAuthorQuery.GetAllAsync()
    {
        return await _db.Authors
            .AsNoTracking()
            .Select(a => new AuthorDto
            {
                Id = a.Id,
                Name = a.Name,
                Books = a.Books
                    .Select(b => new AuthorBookDto
                    {
                        Id = b.Id,
                        Title = b.Title,
                        Description = b.Description
                    })
                    .ToList()
            })
            .ToListAsync();
    }


    async Task<AuthorDto> IAuthorQuery.GetByIdAsync(int id)
    {
        return await _db.Authors
            .AsNoTracking()
            .Where(a => a.Id == id)
            .Select(a => new AuthorDto
            {
                Id = a.Id,
                Name = a.Name,
                Books = a.Books
                    .Select(b => new AuthorBookDto
                    {
                        Id = b.Id,
                        Title = b.Title,
                        Description = b.Description
                    })
                    .ToList()
            })
            .SingleAsync();
    }
}

using BlazorOnionDemo.Application.Contracts.Queries;

namespace BlazorOnionDemo.Infrastructure.Queries;

public class BookQuery : IBookQuery
{
    async Task<List<BookDto>> IBookQuery.GetAllAsync()
    {
        throw new NotImplementedException();
    }

    async Task<BookDto> IBookQuery.GetByIdAsync(int id)
    {
        throw new NotImplementedException();
    }
}

using BlazorOnionDemo.Domain.Entity;
using Microsoft.EntityFrameworkCore;

namespace BlazorOnionDemo.Infrastructure.Database;

public class OrmContext : DbContext
{
    public DbSet<Author> Authors { get; set; }
    public DbSet<Book> Books { get; set; }

    public OrmContext(DbContextOptions<OrmContext> options) : base(options)
    {
    }
}

using BlazorOnionDemo.Application.CommandHandlers;
using BlazorOnionDemo.Application.Contracts.Commands;
using Microsoft.Extensions.DependencyInjection;

namespace BlazorOnionDemo.Application;

public static class ApplicationServiceRegistration
{
    public static IServiceCollection AddApplicationServices(this IServiceCollection services)
    {
        services.AddScoped<IAuthorCommand, AuthorCommand>();
        services.AddScoped<IBookCommand, BookCommand>();

        return services;
    }
}

using BlazorOnionDemo.Application.Contracts.Queries;
using BlazorOnionDemo.Application.Repositories;
using BlazorOnionDemo.Infrastructure.Database;
using BlazorOnionDemo.Infrastructure.Queries;
using BlazorOnionDemo.Infrastructure.Repositories;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace BlazorOnionDemo.Infrastructure;

public static class InfrastructureServiceRegistration
{
    public static IServiceCollection AddInfrastructureServices(this IServiceCollection services,
        IConfiguration configuration)
    {
        // Register Query implementations
        services.AddScoped<IAuthorQuery, AuthorQuery>();
        services.AddScoped<IBookQuery, BookQuery>();

        // Register Repository implementations
        services.AddScoped<IAuthorRepository, AuthorRepository>();
        services.AddScoped<IBookRepository, BookRepository>();

        // Database
        // https://github.com/dotnet/SqlClient/issues/2239
        // https://learn.microsoft.com/en-us/ef/core/managing-schemas/migrations/projects?tabs=dotnet-core-cli
        // Add-Migration InitialMigration -Context OrmContext -Project BlazorOnionDemo.Infrastructure
        // Update-Database -Context OrmContext -Project BlazorOnionDemo.Infrastructure
        services.AddDbContext<OrmContext>(options =>
        {
            options.UseSqlServer(configuration.GetConnectionString("DbConnection"));
        });

        return services;
    }
}

using BlazorOnionDemo.Application;
using BlazorOnionDemo.Infrastructure;
using BlazorOnionDemo.WebUi.Components;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

// Blazor frontend til Domain Centric Backend - IoC setup
builder.Services.AddApplicationServices(); // from BlazorOnionDemo.Application
builder.Services.AddInfrastructureServices(builder.Configuration); // from BlazorOnionDemo.Infrastructure


var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error", true);
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseStatusCodePagesWithReExecute("/not-found", createScopeForStatusCodePages: true);
app.UseHttpsRedirection();

app.UseAntiforgery();

app.MapStaticAssets();
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.Run();

@page "/authors"
@using BlazorOnionDemo.Application.Contracts.Queries
@using Microsoft.AspNetCore.Components.QuickGrid

@inject IAuthorQuery AuthorQuery

<PageTitle>Index</PageTitle>

<h1>Index</h1>

<p>
    <a href="authors/create">Create New</a>
</p>

<div>
    <QuickGrid Class="table" Items="Authors" Pagination="pagination">
        <PropertyColumn Property="author => author.Id" Sortable="true"/>
        <PropertyColumn Property="author => author.Name" Sortable="true"/>
        <PropertyColumn Property="author => author.Books.Count" Title="Book count"/>

        <TemplateColumn Context="author">
            <a href="@($"authors/details?id={author.Id}")">Details</a>
        </TemplateColumn>
    </QuickGrid>
</div>

<Paginator State="pagination"/>

@code {

    private readonly PaginationState pagination = new() { ItemsPerPage = 5 };
    private IQueryable<AuthorDto> Authors; // = default!; /* => context.Movie.Where(m => m.Title!.Contains(titleFilter)); */

    protected override async Task OnInitializedAsync()
    {
        Authors = (await AuthorQuery.GetAllAsync()).AsQueryable();
    }

}

@page "/authors/create"
@using BlazorOnionDemo.Application.Contracts.Commands
@inject IAuthorCommand Command
@inject NavigationManager NavigationManager

<PageTitle>Create</PageTitle>

<h1>Create</h1>

<h2>Author</h2>
<hr/>
<div class="row">
    <div class="col-md-4">
        <EditForm method="post" Model="Author" OnValidSubmit="AddAuthor" FormName="create" Enhance>
            <DataAnnotationsValidator/>
            <ValidationSummary class="text-danger" role="alert"/>
            <div class="mb-3">
                <label for="title" class="form-label">Name:</label>
                <InputText id="title" @bind-Value="Author.Name" class="form-control"/>
                <ValidationMessage For="() => Author.Name" class="text-danger"/>
            </div>
            <button type="submit" class="btn btn-primary">Create</button>
        </EditForm>
    </div>
</div>

<div>
    <a href="/authors">Back to List</a>
</div>

@code {
    [SupplyParameterFromForm] private AuthorCreateCommandDto Author { get; set; } = new();

    private async Task AddAuthor()
    {
        await Command.CreateAsync(Author);
        NavigationManager.NavigateTo("/authors");
    }

}

@page "/authors/details"
@using BlazorOnionDemo.Application.Contracts.Queries
@using Microsoft.AspNetCore.Components.QuickGrid

@inject IAuthorQuery AuthorQuery
@inject NavigationManager NavigationManager

<PageTitle>Details</PageTitle>

<h1>Details</h1>

<div>
    <h2>Author</h2>
    <hr/>
    @if (author is null)
    {
        <p>
            <em>Loading...</em>
        </p>
    }
    else
    {
        <dl class="row">
            <dt class="col-sm-2">Id</dt>
            <dd class="col-sm-10">@author.Id</dd>
            <dt class="col-sm-2">Name</dt>
            <dd class="col-sm-10">@author.Name</dd>
        </dl>
        <div>
            <a href="@($"/authors/addBook?id={author.Id}")">Add book</a> |
            <a href="@("/authors")">Back to List</a>
        </div>
    }

    <h3>Books</h3>

    <div>
        <QuickGrid Class="table" Items="Books" Pagination="pagination">
            <PropertyColumn Property="book => book.Id" Sortable="true"/>
            <PropertyColumn Property="book => book.Title" Sortable="true"/>
            <PropertyColumn Property="book => book.Description" Title="Book count"/>
        </QuickGrid>
    </div>
</div>

<Paginator State="pagination"/>

@code {
    private AuthorDto? author;
    private readonly PaginationState pagination = new() { ItemsPerPage = 5 };
    private IQueryable<AuthorBookDto> Books => author?.Books.AsQueryable() ?? Enumerable.Empty<AuthorBookDto>().AsQueryable();

    [SupplyParameterFromQuery] private int Id { get; set; }

    protected override async Task OnInitializedAsync()
    {
        author = await AuthorQuery.GetByIdAsync(Id);

        if (author is null)
        {
            NavigationManager.NavigateTo("notfound");
        }
    }

}

@page "/authors/addBook"
@using BlazorOnionDemo.Application.Contracts.Commands
@inject IAuthorCommand Command
@inject NavigationManager NavigationManager

<PageTitle>Add book</PageTitle>

<h1>Add book</h1>

<h2>Book</h2>
<hr/>

<div class="row">
    <div class="col-md-4">
        <EditForm method="post" Model="Book" OnValidSubmit="Add" FormName="create" Enhance>
            <DataAnnotationsValidator/>
            <ValidationSummary class="text-danger" role="alert"/>
            <div class="mb-3">
                <label for="title" class="form-label">Title:</label>
                <InputText id="title" @bind-Value="Book.Title" class="form-control"/>
                <ValidationMessage For="() => Book.Title" class="text-danger"/>
            </div>
            <div class="mb-3">
                <label for="title" class="form-label">Description:</label>
                <InputText id="title" @bind-Value="Book.Description" class="form-control"/>
                <ValidationMessage For="() => Book.Description" class="text-danger"/>
            </div>
            <button type="submit" class="btn btn-primary">Create</button>
        </EditForm>
    </div>
</div>

<div>
    <a href="@($"authors/details?id={Id}")">Back to List</a>
</div>

@code {
    [SupplyParameterFromForm] private BookCreateCommandDto Book { get; set; } = new();

    [SupplyParameterFromQuery] private int Id { get; set; }

    private async Task Add()
    {
        var command = new AddBookToAuthorCommandDto { AuthorId = Id, Book = Book };
        await Command.AddBookToAuthorAsync(command);
        NavigationManager.NavigateTo($"authors/details?id={Id}");
    }

}