using FastEndpoints;
using Microsoft.EntityFrameworkCore;
using Socialize.Api.Data;
using Socialize.Api.Infrastructure.Security;
using Socialize.Api.Modules.Approvals.Data;
using Socialize.Api.Modules.Workspaces.Data;

namespace Socialize.Api.Modules.Workspaces.Handlers;

internal record ApprovalStepConfigurationDto(
    Guid Id,
    Guid WorkspaceId,
    string Name,
    int SortOrder,
    string TargetType,
    string TargetValue,
    int RequiredApproverCount,
    DateTimeOffset CreatedAt);

internal record WorkspaceDto(
    Guid Id,
    Guid OrganizationId,
    string Name,
    string? LogoUrl,
    string TimeZone,
    string ApprovalMode,
    bool SchedulePostsAutomaticallyOnApproval,
    bool LockContentAfterApproval,
    bool SendAutomaticApprovalReminders,
    IReadOnlyCollection<ApprovalStepConfigurationDto> ApprovalSteps,
    DateTimeOffset CreatedAt)
{
    public static WorkspaceDto FromWorkspace(
        Workspace workspace,
        IReadOnlyCollection<ApprovalStepConfigurationDto> approvalSteps)
    {
        return new WorkspaceDto(
            workspace.Id,
            workspace.OrganizationId,
            workspace.Name,
            workspace.LogoUrl,
            workspace.TimeZone,
            workspace.ApprovalMode,
            workspace.SchedulePostsAutomaticallyOnApproval,
            workspace.LockContentAfterApproval,
            workspace.SendAutomaticApprovalReminders,
            approvalSteps,
            workspace.CreatedAt);
    }
}

internal class GetWorkspacesHandler(
    AppDbContext dbContext,
    AccessScopeService accessScopeService)
    : EndpointWithoutRequest<IReadOnlyCollection<WorkspaceDto>>
{
    public override void Configure()
    {
        Get("/api/workspaces");
        Options(o => o.WithTags("Workspaces"));
    }

    public override async Task HandleAsync(CancellationToken ct)
    {
        IReadOnlyCollection<Guid> accessibleWorkspaceIds = await accessScopeService.GetAccessibleWorkspaceIdsAsync(User, ct);
        var query = dbContext.Workspaces
            .Where(workspace => accessibleWorkspaceIds.Contains(workspace.Id));

        var workspaceRows = await query
            .OrderBy(workspace => workspace.Name)
            .ToListAsync(ct);

        var workspaceIds = workspaceRows.Select(workspace => workspace.Id).ToList();
        List<WorkspaceApprovalStepConfiguration> approvalStepRows = await dbContext.WorkspaceApprovalStepConfigurations
            .Where(step => workspaceIds.Contains(step.WorkspaceId))
            .OrderBy(step => step.SortOrder)
            .ThenBy(step => step.Name)
            .ToListAsync(ct);

        var approvalStepsByWorkspaceId = approvalStepRows
            .GroupBy(step => step.WorkspaceId)
            .ToDictionary(
                group => group.Key,
                group => (IReadOnlyCollection<ApprovalStepConfigurationDto>)group
                    .Select(ToApprovalStepConfigurationDto)
                    .ToArray());

        var workspaces = workspaceRows
            .Select(workspace => WorkspaceDto.FromWorkspace(
                workspace,
                approvalStepsByWorkspaceId.GetValueOrDefault(workspace.Id) ?? Array.Empty<ApprovalStepConfigurationDto>()))
            .ToList();

        await SendOkAsync(workspaces, ct);
    }

    public static ApprovalStepConfigurationDto ToApprovalStepConfigurationDto(WorkspaceApprovalStepConfiguration step)
    {
        return new ApprovalStepConfigurationDto(
            step.Id,
            step.WorkspaceId,
            step.Name,
            step.SortOrder,
            step.TargetType,
            step.TargetValue,
            step.RequiredApproverCount,
            step.CreatedAt);
    }
}