using System;
using System.IO;
using System.Net.Http;
using System.Reflection;
using IdentityModel.AspNetCore.OAuth2Introspection;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using xApi.Extensions;
using xCommons.Configurations;
using xCommons.Extensions;
using xDataHelper;
using xDataHelper.DbSeeder;
using xDataHelper.Helpers;
using xDataService.Configuration;
using xDataService.Constants;
using xDataService.DI;
using xDataService.Interfaces;
using xHttpService.DI;
using xIdentityService.DI;
using xPushHelper.DI;
using xPushService.DI;
using xPushService.Helpers;
using xServices.DI;

namespace xApi
{
    public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public void ConfigureServices(IServiceCollection services)
        {
            //
            // Register Validation Provider and all XCommons Module Services ...
            services.AddXCommons();

            //
            // Register App Configuration ...
            services.AddXAppConfiguration(Configuration);
            var appConfiguration = services.GetRegisteredService<XAppConfiguration>();

            //
            // Register Allowed Origins ...
            services.AddXCors(appConfiguration.AllowedOrigins);

            //
            // Register Swagger ...
            var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
            var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
            services.AddXSwagger(Configuration, xmlFilePath: xmlPath);

            //
            // Register HttpService ...
            services.AddXHttpService(Configuration);

            //
            // Register Api Versioning ...
            services.AddApiVersioning(opt =>
            {
                //
                // Set Default Api Version ...
                opt.DefaultApiVersion = new ApiVersion(1, 0);

                //
                // Set Routing to Default API Version, if Version unspecified ...
                opt.AssumeDefaultVersionWhenUnspecified = true;

                //
                // Report All Available Api Versions on Response ...
                opt.ReportApiVersions = true;
            });

            //
            var lifeTime = ServiceLifetime.Scoped;

            //
            // OAuthIntrospectin Http Client Handler ...
            // this is for handling SSLErrors ...
            services.AddHttpClient(OAuth2IntrospectionDefaults.BackChannelHttpClientName)
                .ConfigurePrimaryHttpMessageHandler(() =>
                {
                    return new HttpClientHandler
                    {
                        ServerCertificateCustomValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true
                    };
                });

            //
            // Register Authorizations ...
            services.AddXAuthorization();

            //
            services.AddControllers()
                .AddNewtonsoftJson(x =>
                {
                    x.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                    x.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
                });

            //
            // Register XPushService ...
            services.AddXPushService(Configuration);
            services.AddXPushHubProvider(lifeTime);

            //
            // Register XIdentityService ...
            services.AddXIdentityService(Configuration, lifeTime);

            //
            // Register DataService here ...
            #region Register xDataService ...
            //
            // Register IXDataServiceHelper ...
            services.AddSingleton<IXDataServiceHelper, XDataHelperDataProviderHelper>();

            //
            // Prepare Db Options Builder based on Provider ...
            var providerType = Configuration.GetXDbProviderType();
            switch (providerType)
            {
                //
                case XDbProviders.MySQL:
                case XDbProviders.SQLite:
                case XDbProviders.SQLServer:
                    Action<dynamic> optionsBuilder = optionsBuilder = b =>
                    {
                        b.MigrationsAssembly(typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
                    };

                    //
                    // Register xDataService on DI ...
                    services.AddXDataService<XDataHelperDbContext, XDataHelperDbSeeder>(
                        Configuration,
                        lifeTime,
                        XDbProviderConfigurations.DEFAULT_CONNECTION_NAME,
                        optionsBuilder
                    );
                    break;

                //
                case XDbProviders.MongoDB:
                    //
                    // Register xDataService on DI ...
                    services.AddXDataService<XDataHelperDbSeeder>(
                        Configuration,
                        lifeTime,
                        XDbProviderConfigurations.DEFAULT_CONNECTION_NAME
                    );
                    break;
            }
            #endregion

            //
            // Register GraphQL here ...
            #region Register xGraphQL ...
            //
            services.Configure<IISServerOptions>(options =>
            {
                options.AllowSynchronousIO = true;
            });

            //
            services.Configure<KestrelServerOptions>(options =>
            {
                options.AllowSynchronousIO = true;
            });

            //
            // Register XGraphQL Helper ...
            services.AddSingleton<IXGraphQLHelper, XDataHelperGraphQLHelper>();

            //
            services.AddXGraphQL(options =>
            {
                //
                options.EnableMetrics = true;
                options.UnhandledExceptionDelegate = context =>
                {
                    Console.WriteLine("XGraphQL Error: " + context.OriginalException.Message);
                };
            });
            #endregion

            //
            // Register Services Module Providers here ...
            #region Register xServices ...
            services.AddXServices(
                lifeTime: lifeTime,
                configuration: Configuration
            );
            #endregion            
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            //
            var withPlayground = false;
            if (env.IsDevelopment())
            {
                //
                withPlayground = true;
                app.UseDeveloperExceptionPage();
            }

            //
            // Use Swagger Middleware ...
            app.UseXSwagger();

            //
            app.UseHttpsRedirection();

            //
            // Using Cors ...
            app.UseXCors();

            //
            app.UseRouting();

            //
            // Use xIdentityService ...
            app.UseXIdentityService();

            //
            app.UseAuthorization();

            //
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });

            //
            #region XPushService ...
            //
            var helper = new XPushServiceHelper();

            //
            app.UseXPushService(helper);
            #endregion

            //
            // Use xDataService Middleware ...
            app.UseXDataService();

            //
            // Using Services ...
            app.UseXServices();

            //
            // Use xGraphQL Middleware ...
            app.UseXGraphQL(withPlayground: withPlayground);
        }
    }
}