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

namespace PostFundManagement.Application.Services.Projects;

public sealed class ProjectCacheService(ProjectService service, IDistributedCache cache,
    IFeatureManager featureManager) : ServiceCacheBase, IProjectService
{
    public async ValueTask<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.CreateActivityAsync(request, userId, cancellationToken);

    public async ValueTask<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.CreateProgrammeAsync(request, userId, cancellationToken);

    public async ValueTask<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.CreateProjectAsync(request, userId, cancellationToken);

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

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

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

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetActivitiesAsync(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.Activity[]>());
        }));

    public async ValueTask<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetActivityAsync(activityIdHash, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getactivity-{activityIdHash}").Value;

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

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetActivityAsync(activityIdHash, 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.Activity>());
        }));

    public async ValueTask<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Milestone>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetMilestoneAsync(milestoneIdHash, cancellationToken);

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

    public async ValueTask<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Programme>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetProgrammeAsync(programmeIdHash, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getprogramme-{programmeIdHash}").Value;

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

    public async ValueTask<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetProgrammeProjectsAsync(programmeIdHash, cancellationToken);

            var cacheKey = HashService.ToMd5Hash($"getprogrammeprojects-{programmeIdHash}").Value;

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

    public async ValueTask<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Project>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetProjectAsync(projectIdHash, cancellationToken);

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

    public async ValueTask<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetProjectIndicatorsAsync(projectIdHash, cancellationToken);

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

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

            if (string.IsNullOrWhiteSpace(cached))
            {
                var result = await service.GetProjectIndicatorsAsync(projectIdHash, 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 ValueTask<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetProjectMilestonesAsync(projectIdHash, cancellationToken);

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

    public async ValueTask<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
        {
            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                return await service.GetProjectRisksAsync(projectIdHash, cancellationToken);

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

    public async ValueTask<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.UpdateMilestoneAsync(request, userId, cancellationToken);

    public async ValueTask<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.UpdateProgrammeAsync(request, userId, cancellationToken);

    public async ValueTask<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.UpdateProjectAsync(request, userId, cancellationToken);

    public async ValueTask<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.UpdateProjectStatusAsync(request, userId, cancellationToken);
}