using PostFundManagement.Domain;
using PostFundManagement.Domain.Abstractions;
using PostFundManagement.Domain.Extensions;
using PostFundManagement.Domain.Models;
using PostFundManagement.Infrastructure.Database;

namespace PostFundManagement.Application.Communications;

public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext> contextFactory) : IService
{
    public async ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, ClaimsPrincipal principal, CancellationToken cancellationToken = default)
    {
        try
        {
            var sidClaim = principal.FindFirst("sid")?.Value ?? principal.FindFirst(ClaimTypes.Sid)?.Value;

            if (!Guid.TryParse(sidClaim, out var currentUserId))
                return Result.Fail("Missing or invalid 'sid' claim.");

            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var invite = new Domain.Entities.Invite
            {
                OrganisationId = request.OrganisationId,
                InvitedOrganisationId = request.InvitedOrganisationId,
                AwardId = request.AwardId,
                ContractId = request.ContractId,
                Recipient = request.Recipient,
                CreatedBy = currentUserId,
                CreatedAt = DateTime.UtcNow
            };

            context.Invites.Add(invite);

            context.Notifications.Add(new Domain.Entities.Notification
            {
                OrganisationId = request.OrganisationId,
                Recipient = request.Recipient,
                Platform = request.Platform,
                Status = NotificationStatus.Pending,
                Subject = "Invitation to Onboard",
                Message = request.Message,
                CreatedAt = DateTime.UtcNow
            });

            return await context.SaveChangesAsync(cancellationToken) > 0
                ? Result.Ok(invite.Map())
                : Result.Fail("Failed to complete the insite distribution");
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }

    public async ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default)
    {
        try
        {
            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var envites = await context.Invites.AsNoTracking()
                .OrderByDescending(i => i.CreatedAt)
                .Skip((pagination.Page - 1) * pagination.PageSize)
                .Take(pagination.PageSize)
                .ToListAsync(cancellationToken);

            return Result.Ok(envites.Select(i => i.Map()).ToArray());
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }
}