using PostFundManagement.Application.Abstractions.Services;
using PostFundManagement.Application.Services.Shared;
using PostFundManagement.Domain;
using PostFundManagement.Domain.Errors;
using PostFundManagement.Domain.Extensions;
using PostFundManagement.Domain.Models;
using PostFundManagement.Infrastructure.Database;
using PostFundManagement.Application.Extensions;

namespace PostFundManagement.Application.Services.Governance;

public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IGovernanceService
{
    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
        {
            var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);

            if (decodeResult.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(decodeResult.Errors));

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

            var programmes = await context.Programmes.AsNoTracking()
                .Where(p => p.PortfolioId == decodeResult.Value)
                .OrderByDescending(o => o.CreatedAt)
                .ToListAsync(cancellationToken);

            return Result.Ok(programmes.Select(p => p.Map()).ToArray());
        }));

    public async ValueTask<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Portfolio[]>>>)(async () =>
        {
            var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);

            if (decodeResult.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(decodeResult.Errors));

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

            var portfolios = await context.Portfolios.AsNoTracking()
                .Where(f => f.Id == decodeResult.Value)
                .OrderByDescending(o => o.CreatedAt)
                .ToListAsync(cancellationToken);

            return Result.Ok(portfolios.Select(p => p.Map()).ToArray());
        }));

    public async ValueTask<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Organisation[]>>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var organisations = await context.Organisations.AsNoTracking()
                .OrderBy(o => o.Name)
                .Skip((pagination.Page - 1) * pagination.PageSize)
                .Take(pagination.PageSize)
                .ToListAsync(cancellationToken);

            return Result.Ok(organisations.Select(o => o.Map()).ToArray());
        }));

    public async ValueTask<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Organisation>>>)(async () =>
        {
            var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);

            if (decodeResult.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(decodeResult.Errors));

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

            var organisation = await context.Organisations.AsNoTracking()
                .FirstOrDefaultAsync(o => o.Id == decodeResult.Value, cancellationToken);

            return Result.FailIf(organisation is null, NotFoundError.New)
                .ToResult(organisation!.Map());
        }));

    public async ValueTask<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Instrument[]>>>)(async () =>
        {
            var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);

            if (decodeResult.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(decodeResult.Errors));

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

            var instruments = await context.Instruments.AsNoTracking()
                .Where(i => i.ProgrammeId == decodeResult.Value)
                .OrderByDescending(o => o.CreatedAt)
                .ToListAsync(cancellationToken);

            return Result.Ok(instruments.Select(i => i.Map()).ToArray());
        }));

    public async ValueTask<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Dashboard>>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var totalPortfolioValue = await context.Awards.SumAsync(a => a.Amount, cancellationToken);
            var activeAwardsCount = await context.Awards.CountAsync(a => a.Status == ApprovalStatus.Approved, cancellationToken);

            var disbursedAmount = await context.Disbursements.Where(d => d.Status == ApprovalStatus.Approved)
                .SumAsync(d => d.Amount, cancellationToken);

            var totalProjects = await context.Projects.CountAsync(cancellationToken);
            var onTrackProjects = await context.Projects.CountAsync(p => p.Status == ApprovalStatus.Approved, cancellationToken);

            var onTrackPercentage = totalProjects > 0
                ? Math.Round((double)onTrackProjects / totalProjects * 100, 1)
                : 100.0;

            var atRiskCount = await context.Risks.CountAsync(r => r.Impact == RiskImpact.Critical || r.Impact == RiskImpact.Major, cancellationToken);

            var beneficiariesReached = await context.Beneficiaries.SumAsync(b => b.ReachedCount, cancellationToken);

            return Result.Ok(new Dashboard(totalPortfolioValue, activeAwardsCount,
                disbursedAmount, onTrackPercentage, atRiskCount, beneficiariesReached));
        }));

    public async ValueTask<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var registrationNo = request.RegistrationNo.Clean();

            if (await context.Organisations.AnyAsync(o => o.RegistrationNo == registrationNo, cancellationToken))
                return Result.Fail(CreateError.Create("Organisation with the same registration number already exists"));

            context.Organisations.Add(new Domain.Entities.Organisation
            {
                Name = request.Name.Humanize(LetterCasing.Title).Trim(),
                RegistrationNo = registrationNo,
                Email = request.Email.ToLower(CultureInfo.InvariantCulture).Clean(),
                Type = request.Type,
                Status = ActivityStatus.Active,
                CreatedBy = userId,
                CreatedAt = DateTime.UtcNow
            });

            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
        }));

    public async ValueTask<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Organisation>>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var changedTotal = await context.Organisations
                .Where(f => f.Id == request.OrganisationId)
                .ExecuteUpdateAsync(f => f
                    .SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
                    .SetProperty(u => u.RegistrationNo, request.RegistrationNo.Clean())
                    .SetProperty(u => u.Email, request.Email.ToLower(CultureInfo.InvariantCulture).Clean())
                    .SetProperty(u => u.Type, request.Type), cancellationToken);

            return Result.OkIf(changedTotal > 0, UpdateError.New);
        }));

    public async ValueTask<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            if (!await context.Users.AnyAsync(u => u.Id == request.OwnerId, cancellationToken))
                return Result.Fail(NotFoundError.Create("Owner user not found"));

            if (!await context.Organisations.AnyAsync(u => u.Id == request.OrganisationId, cancellationToken))
                return Result.Fail(NotFoundError.Create("Organisation not found"));

            var name = request.Name.Humanize(LetterCasing.Title).Trim();

            if (await context.Portfolios.AnyAsync(p => p.Name == name && p.OrganisationId == request.OrganisationId, cancellationToken))
                return Result.Fail(ValidationError.Create("A portfolio with the same name exists in this organisation"));

            context.Portfolios.Add(new Domain.Entities.Portfolio
            {
                CreatedAt = DateTime.UtcNow,
                CreatedBy = userId,
                OrganisationId = request.OrganisationId,
                OwnedBy = request.OwnerId,
                Name = name,
                Description = request.Description.Humanize(LetterCasing.Sentence).Trim()
            });

            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
        }));

    public async ValueTask<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result>>)(async () =>
        {
            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            if (!await context.Users.AnyAsync(u => u.Id == request.OwnerId, cancellationToken))
                return Result.Fail(NotFoundError.Create("Owner user not found"));

            var changedTotal = await context.Portfolios
                .Where(p => p.Id == request.PortfolioId)
                .ExecuteUpdateAsync(f => f
                    .SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
                    .SetProperty(u => u.OwnedBy, request.OwnerId)
                    .SetProperty(u => u.Description, request.Description.Humanize(LetterCasing.Sentence).Trim()), cancellationToken);

            return Result.OkIf(changedTotal > 0, UpdateError.Create("Nothing was saved, no change detected."));
        }));

    public async ValueTask<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
        {
            var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);

            if (decodeResult.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(decodeResult.Errors));

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

            var programmes = await context.Programmes.AsNoTracking()
                .Where(f => f.PortfolioId == decodeResult.Value)
                .OrderByDescending(o => o.CreatedAt)
                .ToListAsync(cancellationToken);

            return Result.Ok(programmes.Select(p => p.Map()).ToArray());
        }));

    public async ValueTask<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Portfolio>>>)(async () =>
        {
            var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);

            if (decodeResult.IsFailed)
                return Result.Fail(IdDecodeError.Create()
                    .CausedBy(decodeResult.Errors));

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

            var portfolio = await context.Portfolios.AsNoTracking()
                .FirstOrDefaultAsync(p => p.Id == decodeResult.Value, cancellationToken);

            return Result.FailIf(portfolio is null, NotFoundError.New)
                .ToResult(portfolio!.Map());
        }));
}