using PostFundManagement.Application.Abstractions.Services;
using PostFundManagement.Application.Extensions;
using PostFundManagement.Application.Services.Shared;
using PostFundManagement.Domain;
using PostFundManagement.Domain.Models;

namespace PostFundManagement.Application.Services.Evidence;

public sealed class EvidenceCacheService(EvidenceService service, IDistributedCache cache,
    IFeatureManager featureManager) : ServiceCacheBase, IEvidenceService
{
    public async Task<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
        await service.CreateEvidenceAsync(userId, form, file, cancellationToken);

    public async Task<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.CreateIndicatorAsync(request, userId, cancellationToken);

    public async Task<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.CreateMilestoneAsync(request, userId, cancellationToken);

    public async Task<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Domain.Models.Evidence>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetEvidenceAsync(evidenceId, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getevidence-{evidenceId}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetEvidenceAsync(evidenceId, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            return Result.Ok(cached.FromJson<Domain.Models.Evidence>());
        }));

    public async Task<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetEvidenceFilesAsync(pagination, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getevidencefiles-{pagination.Page}-{pagination.PageSize}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetEvidenceFilesAsync(pagination, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
        }));

    public async Task<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<string>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetEvidenceUrlAsync(evidenceIdHash, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getevidenceurl-{evidenceIdHash}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetEvidenceUrlAsync(evidenceIdHash, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value, cancellationToken);

                return result.Value;
            }

            return Result.Ok(cached);
        }));

    public async Task<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Indicator>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetIndicatorAsync(indicatorId, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getindicator-{indicatorId}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetIndicatorAsync(indicatorId, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            return Result.Ok(cached.FromJson<Indicator>());
        }));

    public async Task<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetIndicatorsAsync(pagination, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getindicators-{pagination.Page}-{pagination.PageSize}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetIndicatorsAsync(pagination, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            return Result.Ok(cached.FromJson<Indicator[]>());
        }));

    public async Task<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetMilestoneEvidencesAsync(milestoneIdHash, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getmilestoneevidences-{milestoneIdHash}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetMilestoneEvidencesAsync(milestoneIdHash, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
        }));

    public async Task<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetProjectEvidencesAsync(projectIdHash, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getprojectevidences-{projectIdHash}").Value;

            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetProjectEvidencesAsync(projectIdHash, cancellationToken);

                if (result.IsFailed) return result;

                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);

                return result.Value;
            }

            return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
        }));

    public async Task<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
        await service.RecordIndicatorActualAmountAsync(indicatorIdHash, amount, userId, cancellationToken);

    public async Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.UpdateEvidenceAsync(request, userId, cancellationToken);
}