using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Polly;
using Volo.Abp;
using Volo.Abp.AspNetCore.Authentication.JwtBearer;
using Volo.Abp.Autofac;
using Volo.Abp.AutoMapper;
using Volo.Abp.BackgroundJobs;
using Volo.Abp.BackgroundWorkers;
using Volo.Abp.Domain;
using Volo.Abp.EntityFrameworkCore;
using Volo.Abp.Http.Client;
using Volo.Abp.Identity;
using Volo.Abp.Modularity;
using Win_in.Sfs.Basedata.Application.Contracts;
using Win_in.Sfs.Shared.Host;
using Win_in.Sfs.Wms.DataExchange.Authenticaitons;

//using Win_in.Sfs.Wms.OutMesData.EntityFrameworkCore;
using Win_in.Sfs.Wms.Store.Application.Contracts;

namespace Win_in.Sfs.Wms.DataExchange.MesAgent;

[DependsOn(typeof(AbpAutofacModule),
    typeof(AbpAutoMapperModule),
    typeof(AbpBackgroundJobsModule),
    typeof(AbpBackgroundWorkersModule),
    typeof(AbpAspNetCoreAuthenticationJwtBearerModule),
    //typeof(AbpAccountWebIdentityServerModule),
    //typeof(AbpAspNetCoreSerilogModule),
    typeof(AbpIdentityApplicationContractsModule),
    typeof(AbpHttpClientModule)
 )]
[DependsOn(
  typeof(BasedataApplicationContractsModule),
 typeof(StoreApplicationContractsModule),
 //typeof(DataExchangeApplicationModule),
 typeof(DataExchangeApplicationContractsModule)
//typeof(DataExchangeEntityFrameworkCoreModule),
//typeof(OutMesDataExchangeEntityFrameworkCoreModule)
)]
public class AgentModule : AbpModule
{
    public override void PreConfigureServices(ServiceConfigurationContext context)
    {
        context.Services.AddAutoMapperObjectMapper<AbpDddDomainModule>();
        Configure<AbpAutoMapperOptions>(options => { options.AddMaps<AgentModule>(validate: true); });

        PreConfigure<AbpHttpClientBuilderOptions>(options =>
        {
            //Polly 重试3次
            options.ProxyClientBuildActions.Add((remoteServiceName, clientBuilder) =>
            {
                clientBuilder.AddTransientHttpErrorPolicy(policyBuilder =>
                    policyBuilder.WaitAndRetryAsync(
                        3,
                        i => TimeSpan.FromSeconds(Math.Pow(2, i))
                    )
                );
            });

            //默认添加Authorization Header: Bearer Token
            options.ProxyClientActions.Add((a, s, h) =>
            {
                var httpAuthorizationHandler = s.GetService<HttpAuthorizationHandler>();
                if (httpAuthorizationHandler != null && httpAuthorizationHandler.IsLoggedIn())
                {
                    h.DefaultRequestHeaders.Authorization =
                        new AuthenticationHeaderValue("Bearer", httpAuthorizationHandler.GetCurrentBearer());
                }
            });
        });
    }

    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        //context.Services.AddAlwaysAllowAuthorization();

        var configuration = context.Services.GetConfiguration();
        var env = context.Services.GetSingletonInstance<IHostEnvironment>();

        context.SetConsoleTitleOfConsoleApp("MesAgent", env.EnvironmentName);

        Configure<AuthenticationOptions>(configuration.GetSection("Authentication"));

        ////?? LYF 新加
        //Configure<AbpAntiForgeryOptions>(options =>
        //{
        //    options.AutoValidate = false;

        //});

        //AuthenticationOptions

        Configure<AbpDbContextOptions>(options =>
        {
            options.UseSqlServer();
        });

        Configure<DataExchangeOptions>(configuration.GetSection("DataExchangeOptions"));

        context.Services.AddHostedService<AgentHostedService>();
        ConfigureHttpClientProxies(context);

        context.Services.AddAutoMapperObjectMapper<AgentModule>();

        Configure<AbpAutoMapperOptions>(options =>
        {
            options.AddMaps<AgentModule>(validate: false);
        });

        //绕过授权服务,用于测试
        //context.Services.AddAlwaysAllowAuthorization();
        ConfigureAuthentication(context, configuration);
    }

    private static void ConfigureAuthentication(ServiceConfigurationContext context, IConfiguration configuration)
    {
        var isAlwaysAllowAuthorization = configuration.GetValue<bool>("AuthServer:AlwaysAllowAuthorization");
        if (isAlwaysAllowAuthorization)
        {
            //绕过授权服务,用于测试
            context.Services.AddAlwaysAllowAuthorization();
        }
        else
        {
            context.Services.AddAuthentication()
            .AddJwtBearer(options =>
            {
                options.Authority = configuration["AuthServer:Authority"];
                options.RequireHttpsMetadata = Convert.ToBoolean(configuration["AuthServer:RequireHttpsMetadata"]);
                options.Audience = "DataExchange";
                options.BackchannelHttpHandler = new HttpClientHandler
                {
                    ServerCertificateCustomValidationCallback =
                        HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
                };
            });
        }
    }

    private static void ConfigureHttpClientProxies(ServiceConfigurationContext context)
    {
        context.Services.AddHttpClientProxies(
            typeof(BasedataApplicationContractsModule).Assembly,
            "BaseData"
        );
        context.Services.AddHttpClientProxies(
            typeof(DataExchangeApplicationContractsModule).Assembly,
            "DataExchange"
        );
        context.Services.AddHttpClientProxies(
            typeof(StoreApplicationContractsModule).Assembly,
            "Store"
        );

        //context.Services.AddHttpClientProxies(
        //    typeof(OutMesDataExchangeEntityFrameworkCoreModule).Assembly,
        //    "OutMes"
        //);
    }

    public override async Task OnApplicationInitializationAsync(
        ApplicationInitializationContext context)
    {
        await context.AddBackgroundWorkerAsync<JisFileReadingWorker>().ConfigureAwait(false);
        await context.AddBackgroundWorkerAsync<JisInfoIncomingDataWorker>().ConfigureAwait(false);
    }
}