using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Magicodes.ExporterAndImporter.Excel;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Win_in.Sfs.Basedata.EntityFrameworkCore;
using Microsoft.OpenApi.Models;
using Serilog.Core;
using StackExchange.Redis;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.AspNetCore.Mvc.UI.MultiTenancy;
using Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared;
using Volo.Abp.AspNetCore.Serilog;
using Volo.Abp.AuditLogging.EntityFrameworkCore;
using Volo.Abp.Autofac;
using Volo.Abp.Caching;
using Volo.Abp.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore.SqlServer;
using Volo.Abp.Localization;
using Volo.Abp.Modularity;
using Volo.Abp.MultiTenancy;
using Volo.Abp.PermissionManagement.EntityFrameworkCore;
using Volo.Abp.SettingManagement.EntityFrameworkCore;
using Volo.Abp.Swashbuckle;
using Volo.Abp.VirtualFileSystem;
using Volo.Abp.AspNetCore.Mvc;
using Volo.Abp.Auditing;
using Volo.Abp.Caching.StackExchangeRedis;
using Win_in.Sfs.Basedata.Application;
using Win_in.Sfs.Basedata.Application.Contracts;
using Win_in.Sfs.Basedata.Domain;
using Win_in.Sfs.Basedata.Domain.Shared;
using Win_in.Sfs.Basedata.HttpApi;
using Volo.Abp.BlobStoring;
using Win_in.Sfs.FileStorage.Domain;
using Volo.Abp.AspNetCore.ExceptionHandling;
using Volo.Abp.BlobStoring.Database;
using Win_in.Sfs.FileStorage;
using Volo.Abp.Http.Client;
using Volo.Abp.AutoMapper;

namespace Win_in.Sfs.Basedata
{
    [DependsOn(
        typeof(BasedataApplicationModule),
        typeof(BasedataEntityFrameworkCoreModule),
        typeof(BasedataHttpApiModule),
        typeof(AbpAspNetCoreMvcUiMultiTenancyModule),
        typeof(AbpAutofacModule),
        typeof(AbpCachingStackExchangeRedisModule),
        typeof(AbpEntityFrameworkCoreSqlServerModule),
        typeof(AbpAuditLoggingEntityFrameworkCoreModule),
        typeof(AbpPermissionManagementEntityFrameworkCoreModule),
        typeof(AbpSettingManagementEntityFrameworkCoreModule),
        typeof(AbpAspNetCoreSerilogModule),
        typeof(AbpSwashbuckleModule),
        typeof(AbpHttpClientModule),
        typeof(AbpAutoMapperModule)
        )]

    [DependsOn(
        typeof(FileStorageApplicationContractsModule)
    )]


    public class BasedataHttpApiHostModule : AbpModule
    {
        private bool _isMultiTenancy = true;

        public override void ConfigureServices(ServiceConfigurationContext context)
        {
         //   context.Services.AddAlwaysAllowAuthorization();
            var hostingEnvironment = context.Services.GetHostingEnvironment();
            var configuration = context.Services.GetConfiguration();

            var urls = configuration.GetValue<string>("Urls");

            Console.WriteLine($"URL: {urls}");

            LimitedResultRequestDto.MaxMaxResultCount = 100000;

            ConfigureHttpClientProxies(context);

            ConfigureExcelImporterAndExporter(context);

            ConfigureDbContext();

            ConfigureMultiTenancy(configuration);

            ConfigureVirtualFileSystem(hostingEnvironment);

            ConfigureConventionalController();

            ConfigureAuditing();

            ConfigureSwagger(context, configuration);

            ConfigureLocalization();

            ConfigureAuthentication(context, configuration);

            ConfigureDistributedCache(context, hostingEnvironment, configuration);

            ConfigureCors(context, configuration);

            ConfigureBlobStoring();
        }

        private static void ConfigureHttpClientProxies(ServiceConfigurationContext context)
        {
            context.Services.AddHttpClientProxies(
                   typeof(FileStorageApplicationContractsModule).Assembly,
                   "FileStorage"
               );
        }

        private static void ConfigureExcelImporterAndExporter(ServiceConfigurationContext context)
        {
            context.Services.AddTransient<IExcelImporter, ExcelImporter>();
            context.Services.AddTransient<IExcelExporter, ExcelExporter>();
        }

        private void ConfigureAuditing()
        {
            var basedataSelector = new NamedTypeSelector("BasedataSelector",
                type => typeof(SfsBaseDataAggregateRootBase).IsAssignableFrom(type));
            Configure<AbpAuditingOptions>(options =>
            {
                options.EntityHistorySelectors.Add(basedataSelector);
            });
        }

        private static void ConfigureCors(ServiceConfigurationContext context, IConfiguration configuration)
        {

            var origins = configuration.GetSection("App:CorsOrigins").Get<string[]>();

            context.Services.AddCors(options =>
            {
                options.AddDefaultPolicy(builder =>
                {
                    builder
                        .WithOrigins(
                            origins.Select(o => o.RemovePostFix("/"))
                                .ToArray()
                        )
                        .WithAbpExposedHeaders()
                        .SetIsOriginAllowedToAllowWildcardSubdomains()
                        .AllowAnyHeader()
                        .AllowAnyMethod()
                        .AllowCredentials();
                });
            });
        }

        private void ConfigureDistributedCache(ServiceConfigurationContext context, IWebHostEnvironment hostingEnvironment,
            IConfiguration configuration)
        {
            Configure<AbpDistributedCacheOptions>(options => { options.KeyPrefix = "Basedata:"; });

            if (!hostingEnvironment.IsDevelopment())
            {
                var redis = ConnectionMultiplexer.Connect(configuration["Redis:Configuration"]);
                context.Services
                    .AddDataProtection()
                    .PersistKeysToStackExchangeRedis(redis, "Basedata-Protection-Keys");
            }
        }

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

                        options.Audience = "Auth";
                    });
            }
        }

        private void ConfigureLocalization()
        {
            Configure<AbpLocalizationOptions>(options =>
            {
                options.Languages.Add(new LanguageInfo("en", "en", "English"));
                options.Languages.Add(new LanguageInfo("zh-Hans", "zh-Hans", "简体中文"));
            });
        }

        private static void ConfigureSwagger(ServiceConfigurationContext context, IConfiguration configuration)
        {
            context.Services.AddAbpSwaggerGenWithOAuth(
                configuration["AuthServer:Authority"],
                new Dictionary<string, string>
                {
                    { "Basedata", "Basedata API" }
                },
                options =>
                {
                    options.SwaggerDoc("v1", new OpenApiInfo { Title = "Basedata API", Version = "v1" });
                    options.DocInclusionPredicate((docName, description) => true);
                    options.ResolveConflictingActions(p => p.First());
                    var xmlapppath = Path.Combine(AppContext.BaseDirectory, "Win_in.Sfs.Basedata.Application.xml");
                    if (System.IO.File.Exists(xmlapppath))
                    {
                        options.IncludeXmlComments(xmlapppath);
                    }
                    // 为swagger添加默认值,有问题,不要用
                    // options.SchemaFilter<SchemaFilter>();
                });
        }

        private void ConfigureConventionalController()
        {
            Configure<AbpAspNetCoreMvcOptions>(options =>
            {
                options
                    .ConventionalControllers
                    .Create(typeof(BasedataApplicationModule).Assembly, opts
                        =>
                    {
                        opts.RootPath = "basedata";
                    })
                    ;
            });
        }

        private void ConfigureVirtualFileSystem(IWebHostEnvironment hostingEnvironment)
        {
            if (hostingEnvironment.IsDevelopment())
            {
                Configure<AbpVirtualFileSystemOptions>(options =>
                {
                    options.FileSets.ReplaceEmbeddedByPhysical<BasedataDomainSharedModule>(
                        Path.Combine(hostingEnvironment.ContentRootPath,
                            string.Format("..{0}..{0}src{0}Win_in.Sfs.Basedata.Domain.Shared", Path.DirectorySeparatorChar)));
                    options.FileSets.ReplaceEmbeddedByPhysical<BasedataDomainModule>(Path.Combine(
                        hostingEnvironment.ContentRootPath,
                        string.Format("..{0}..{0}src{0}Win_in.Sfs.Basedata.Domain", Path.DirectorySeparatorChar)));
                    options.FileSets.ReplaceEmbeddedByPhysical<BasedataApplicationContractsModule>(
                        Path.Combine(hostingEnvironment.ContentRootPath,
                            string.Format("..{0}..{0}src{0}Win_in.Sfs.Basedata.Application.Contracts",
                                Path.DirectorySeparatorChar)));
                    options.FileSets.ReplaceEmbeddedByPhysical<BasedataApplicationModule>(
                        Path.Combine(hostingEnvironment.ContentRootPath,
                            string.Format("..{0}..{0}src{0}Win_in.Sfs.Basedata.Application", Path.DirectorySeparatorChar)));
                });
            }
        }

        private void ConfigureMultiTenancy(IConfiguration configuration)
        {
            _isMultiTenancy = Convert.ToBoolean(configuration["IsMultiTenancy"]);
            Configure<AbpMultiTenancyOptions>(options => { options.IsEnabled = _isMultiTenancy; });
        }

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

        public override void OnApplicationInitialization(ApplicationInitializationContext context)
        {
            var app = context.GetApplicationBuilder();
            var env = context.GetEnvironment();
            var configuration = context.GetConfiguration();

            // if (env.IsDevelopment())
            // {
            //     app.UseDeveloperExceptionPage();
            // }
            // else
            // {
            //     app.UseErrorPage();
            //     app.UseHsts();
            // }

            app.UseHttpsRedirection();
            app.UseCorrelationId();
            app.UseStaticFiles();
            app.UseRouting();
            app.UseCors();
            app.UseAuthentication();
            if (_isMultiTenancy)
            {
                app.UseMultiTenancy();
            }
            app.UseAbpRequestLocalization();
            app.UseAuthorization();
            app.UseSwagger();
            app.UseAbpSwaggerUI(options =>
            {
                options.SwaggerEndpoint("/swagger/v1/swagger.json", "Support APP API");
                options.OAuthClientId(configuration["AuthServer:SwaggerClientId"]);
                options.OAuthClientSecret(configuration["AuthServer:SwaggerClientSecret"]);
                options.OAuthScopes("Basedata");
            });
            app.UseAuditing();
            app.UseAbpSerilogEnrichers();
            app.UseConfiguredEndpoints();
        }

        private void ConfigureBlobStoring()
        {
            Configure<AbpBlobStoringOptions>(options =>
            {
                options.Containers.Configure<FileStorageContainer>(container =>
                {
                    container.UseDatabase();
                });
            });

            Configure<AbpExceptionHandlingOptions>(options =>
            {
                options.SendExceptionsDetailsToClients = true; //向前端返回完整错误日志
            });
        }
    }
}