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.Grants;

public sealed class GrantsCacheService(GrantsService service, IDistributedCache cache,
    IFeatureManager featureManager) : ServiceCacheBase, IGrantsService
{
    public async Task<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
        await service.CreateAwardAsync(request, userId, cancellationToken);

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

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

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

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

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

            var cacheKey = HashService.ToMd5Hash($"getaward-{awardIdHash}").Value;

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

            var cacheKey = HashService.ToMd5Hash($"getbudget-{budgetIdHash}").Value;

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

            var cacheKey = HashService.ToMd5Hash($"getctract-{contractIdHash}").Value;

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

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

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

            var cacheKey = HashService.ToMd5Hash($"getcontracturl-{contractIdHash}").Value;

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

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

                if (result.IsFailed) return result;

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

                return result.Value;
            }

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

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

    public async Task<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
        await service.UpdateContractAsync(request, cancellationToken);

    public async Task<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
        await service.UploadContractAsync(contractIdHash, userId, file, cancellationToken);
}