using PostFundManagement.Application.Abstractions;
using PostFundManagement.Application.Abstractions.Services;
using PostFundManagement.Application.Interceptors;
using PostFundManagement.Application.Services.Communications;
using PostFundManagement.Application.Services.Evidence;
using PostFundManagement.Application.Services.Execution;
using PostFundManagement.Application.Services.Governance;
using PostFundManagement.Application.Services.Grants;
using PostFundManagement.Application.Services.Projects;
using PostFundManagement.Application.Services.Shared;
using PostFundManagement.Application.Services.Users;
using PostFundManagement.Domain.Abstractions;

namespace PostFundManagement.Application.Extensions;

public static class Services
{
    public static IServiceCollection AddLoggedCachedServiceScoped<TInterface, TImplementation, TCacheDecorator>(this IServiceCollection services)
        where TInterface : class
        where TImplementation : class, TInterface
        where TCacheDecorator : class, TInterface
    {
        services.AddScoped<TImplementation>();
        services.AddScoped<TCacheDecorator>();

        services.AddScoped(sp =>
        {
            var proxyGenerator = sp.GetRequiredService<ProxyGenerator>();
            var loggingInterceptor = sp.GetRequiredService<LoggingInterceptor>();

            var actual = sp.GetRequiredService<TImplementation>();

            var cached = ActivatorUtilities.CreateInstance<TCacheDecorator>(sp, actual);

            return proxyGenerator.CreateInterfaceProxyWithTarget<TInterface>(cached,
                loggingInterceptor.ToInterceptor());
        });

        return services;
    }

    public static IServiceCollection AddLoggedAuditedCachedServiceScoped<TInterface, TImplementation, TCacheDecorator>(this IServiceCollection services)
        where TInterface : class
        where TImplementation : class, TInterface
        where TCacheDecorator : class, TInterface
    {
        services.AddScoped<TImplementation>();
        services.AddScoped<TCacheDecorator>();

        services.AddScoped(sp =>
        {
            var proxyGenerator = sp.GetRequiredService<ProxyGenerator>();
            var auditInterceptor = sp.GetRequiredService<AuditInterceptor>();
            var loggingInterceptor = sp.GetRequiredService<LoggingInterceptor>();

            var actual = sp.GetRequiredService<TImplementation>();

            var cached = ActivatorUtilities.CreateInstance<TCacheDecorator>(sp, actual);

            return proxyGenerator.CreateInterfaceProxyWithTarget<TInterface>(cached, 
                loggingInterceptor.ToInterceptor(), 
                           auditInterceptor.ToInterceptor());
        });

        return services;
    }

    public static IServiceCollection AddRegisterServicesWithCaching(this IServiceCollection services, IConfiguration configuration)
    {
        services.AddScoped<AuditInterceptor>();
        services.AddScoped<LoggingInterceptor>();
        services.AddSingleton<ProxyGenerator>();

        services.AddLoggedAuditedCachedServiceScoped<ICommunicationsService, CommunicationsService, CommunicationsCacheService>();
        services.AddLoggedAuditedCachedServiceScoped<IEvidenceService, EvidenceService, EvidenceCacheService>();
        services.AddLoggedAuditedCachedServiceScoped<IUserService, UserService, UserCacheService>();
        services.AddLoggedAuditedCachedServiceScoped<IExecutionService, ExecutionService, ExecutionCacheService>();
        services.AddLoggedAuditedCachedServiceScoped<IGovernanceService, GovernanceService, GovernanceCacheService>();
        services.AddLoggedAuditedCachedServiceScoped<IGrantsService, GrantsService, GrantsCacheService>();
        services.AddLoggedAuditedCachedServiceScoped<IProjectService, ProjectService, ProjectCacheService>();

        services.AddLoggedCachedServiceScoped<IIdentityService, IdentityService, IdentityCacheService>();

        services.AddStackExchangeRedisCache(options =>
        {
            options.Configuration = configuration.GetConnectionString("Redis");
            options.InstanceName = "PFM-API_";
        });

        services.AddHybridCache(options => options.DefaultEntryOptions = new HybridCacheEntryOptions
        {
            Expiration = TimeSpan.FromMinutes(2),
            LocalCacheExpiration = TimeSpan.FromMinutes(30)
        });

        return services;
    }

    public static IServiceCollection AddSharedServices(this IServiceCollection services)
    {
        var serviceType = typeof(IService);

        var sharedImplementations = typeof(IApplication).Assembly.GetTypes()
            .Where(t => serviceType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);

        foreach (var sharedImplementation in sharedImplementations) services.AddScoped(sharedImplementation);

        return services;
    }
}