using System.IO.Compression;
using System.Reflection;
using FluentValidation;
using FluentValidation.AspNetCore;
using Hotline.Api.Realtimes;
using Hotline.Application;
using Hotline.Application.Contracts;
using Hotline.NewRock;
using Hotline.Permissions;
using Hotline.Repository.SqlSugar.Extensions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Serilog;
using Mapster;
using Tr.Sdk;
using XF.Domain.Dependency;
using XF.Domain.Filters;
using XF.Domain.Options;
using XF.EasyCaching;
using XF.Utility.MQ;
using Hotline.Ai.Jths;
using Hotline.Api.Sdk;
using Hotline.CallCenter.Configs;
using Hotline.Wex;
using Hotline.Application.CallCenter.Calls;
using Hotline.Application.CallCenter;
using Hotline.Authentications;
using Hotline.CallCenter.Calls;
using Swashbuckle.AspNetCore.SwaggerUI;
using Hotline.Configurations;
using Hotline.DI;
using Hotline.Share.Tools;
using Hotline.Settings.TimeLimitDomain.ExpireTimeSupplier;
using Hotline.Api.Middleware;
using XF.Domain.Authentications;
using Hotline.XingTang;
using Hotline.Logger;
using HotPot.Mvc.Filters;
using Microsoft.AspNetCore.ResponseCompression;
using Senparc.Weixin.RegisterServices;
using Senparc.Weixin.AspNet;
using Hotline.WeChat;


namespace Hotline.Api;

internal static class StartupExtensions
{
    const string CorsOrigins = "CorsOrigins";
    internal static WebApplication ConfigureServices(this WebApplicationBuilder builder)
    {
        var services = builder.Services;
        var configuration = builder.Configuration;

        services.AddHttpContextAccessor();

#if DEBUG
        builder.WebHost.UseUrls("http://*:50100");
#endif
        
        services.Configure<IdentityConfiguration>(d => configuration.GetSection(nameof(IdentityConfiguration)).Bind(d));

        var appConfigurationSection = configuration.GetRequiredSection(nameof(AppConfiguration));
        var appConfiguration = appConfigurationSection.Get<AppConfiguration>();
        if (appConfiguration is null) throw new ArgumentNullException(nameof(appConfiguration));
        services.Configure<AppConfiguration>(d => appConfigurationSection.Bind(d));

        var callCenterConfigurationSection = configuration.GetRequiredSection(nameof(CallCenterConfiguration));
        var callCenterConfiguration = callCenterConfigurationSection.Get<CallCenterConfiguration>();
        services.Configure<CallCenterConfiguration>(d => callCenterConfigurationSection.Bind(d));

        services.Configure<CityBaseConfiguration>(d => configuration.GetSection(nameof(CityBaseConfiguration)).Bind(d));
		//services.Configure<SendSmsConfiguration>(d => configuration.GetSection("SendSms").Bind(d));

		// Add services to the container.
		services
            .BatchInjectServices(d =>
            {
                var attr = d.GetCustomAttribute(typeof(InjectionAttribute)) as InjectionAttribute;
                if (attr is null) return true;
                return attr.IsEnable(appConfiguration.AppScope,
                    appConfiguration.GetDefaultAppScopeConfiguration().CallCenterType);
            })
            .RegisterRepository()
            .AddApplication()
            .AddScoped(typeof(IPasswordHasher<>), typeof(PasswordHasher<>))
            .AddHttpClient()
            ;
        
        services.AddKeyedScoped<ISessionContext, ProvinceSessionContext>(ProvinceSessionContext.Key)
            .AddKeyedScoped<ISessionContext, Police110SessionContext>(Police110SessionContext.Key)
            ;
        
        //cache
        services.AddCache(d =>
        {
            var cacheConfig = configuration.GetSection("Cache").Get<CacheOptions>();
            cacheConfig.Adapt(d);
            d.Prefix = "Hotline";
            d.TopicName = "hotline-topic";
        });

        //Authentication
        services.RegisterAuthentication(configuration);

        services.AddControllers(options =>
            {
                options.Filters.Add<UnifyResponseFilter>();
                options.Filters.Add<UserFriendlyExceptionFilter>();
                options.Filters.Add<ErrorHandlingFilter>();
            })
            ;

        // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
        services.AddEndpointsApiExplorer();

        //swagger
        services.RegisterSwagger();

        //signalR
        services.RegisterSignalR(configuration);

        /* CORS */
        services.RegisterCors(configuration, CorsOrigins);

        //mapster
        services.RegisterMapper();

        //mediatr
        services.RegisterMediatR(appConfiguration);

        //app scope
        switch (appConfiguration.AppScope)
        {
            case AppDefaults.AppScope.YiBin:
                //jths 
                services.AddAiJths(appConfiguration.YiBin.AiQuality.Url);
                services.AddAiVisitService(
                    appConfiguration.YiBin.AiVisit.Url,
                    appConfiguration.YiBin.AiVisit.Appkey,
                    appConfiguration.YiBin.AiVisit.ServiceVersion);

                //宜宾企业服务
                services.AddYbEnterpriseSdk(appConfiguration.YiBin.Enterprise.AddressUrl)
                    .AddKeyedScoped<ISessionContext, YbEnterpriseSessionContext>(YbEnterpriseSessionContext.Key)
                    .AddKeyedScoped<ISessionContext, ZzptSessionContext>(ZzptSessionContext.Key);
                break;
            case AppDefaults.AppScope.ZiGong:
                break;
            case AppDefaults.AppScope.LuZhou:
                break;
        }

        //callcenter
        var callcenterType = appConfiguration.GetDefaultAppScopeConfiguration().CallCenterType;
        switch (callcenterType)
        {
            case AppDefaults.CallCenterType.XunShi:
                services.AddNewRock(callCenterConfiguration.NewRock);
                break;
            case AppDefaults.CallCenterType.WeiErXin:
                services
                    .AddWex(callCenterConfiguration.Wex)
                    .AddWexDb(configuration);
                break;
            case AppDefaults.CallCenterType.TianRun:
                services
                    .AddScoped<ICallApplication, TianRunCallApplication>()
                    .AddScoped<ITrApplication, TrApplication>()
                    .AddHostedService<CurrentWaitNumService>()
                    .AddHostedService<TelsStatusRefreshService>()
                    .AddTrSdk(callCenterConfiguration.TianRun.Address,
                        callCenterConfiguration.TianRun.Username,
                        callCenterConfiguration.TianRun.Password);
                break;
            case AppDefaults.CallCenterType.XingTang:
                services.AddXingTangDb(callCenterConfiguration.XingTang)
                    .AddXingTangSDK()
                    .AddScoped<ICallApplication, XingTangCallApplication>()
                    .AddScoped<CallIdManager>()
                    ;
                break;
            default:
                break;
        }


        //sqlsugar
        services.AddSqlSugar(configuration);

        //validator
        services.AddFluentValidationAutoValidation(config =>
        {
            config.DisableDataAnnotationsValidation = true;
        })
            .AddValidatorsFromAssembly(typeof(AppContractsStartupExtensions).Assembly);

        //mq
        services.AddMq(configuration);

        //job
        services.RegisterJob(appConfiguration);
        
        //compression
        services.RejisterCompression();

        services.AddSingleton<IAuthorizationPolicyProvider, AuthorizationPolicyProvider>();
        services.AddSingleton<IAuthorizationHandler, PermissionHandler>();
        services.AddScoped<ExpireTimeFactory>();
        services.AddScoped<IExpireTimeSupplier, DaySupplier>();
        services.AddScoped<IExpireTimeSupplier, WorkDaySupplier>();
        services.AddScoped<IExpireTimeSupplier, HourSupplier>();

        services.AddScoped<Users.IThirdIdentiyService, WeChatService>();

        services.AddSenparcWeixin(configuration);

        //services.AddScoped<LogFilterAttribute>();
        //ServiceLocator.Instance = services.BuildServiceProvider();
        return builder.Build();
    }

    internal static WebApplication ConfigurePipelines(this WebApplication app)
    {
        app.UseSerilogRequestLogging();

        // Configure the HTTP request pipeline.
        var swaggerEnable = app.Configuration.GetSection("Swagger").Get<bool>();
        if (swaggerEnable)
        {
            app.UseSwagger();
            app.UseSwaggerUI();
            //app.UseSwaggerUI(c =>
            //{
            //    //c.DocExpansion(DocExpansion.None);
            //    //c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
            //});
        }

        app.UseCors(CorsOrigins);

        app.UseAuthentication();
        app.UseAuthorization();
        //app.MapHub<CallCenterHub>("/hubs/callcenter");
        app.MapHub<HotlineHub>("/hubs/hotline");

        app.MapControllers()
            .RequireAuthorization();
        //app.MapSubscribeHandler();

        var registerService = app.UseSenparcWeixin(app.Environment, null, null,
            register => { },
            (register, weixinSetting) => { }
            );
        // 记录交互日志
        //app.UseRequestResponseLogging(app.Configuration);
        
        app.UseResponseCompression();
        
        return app;
    }
}