// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Startup.cs" company="Deloitte">
//   Copyright © 2020 - 2022 All Rights Reserved
// </copyright>
// --------------------------------------------------------------------------------------------------------------------

namespace myInsight.API.Service
{
    using System;
    using System.IO;
    using System.Linq;
    using System.Reflection;
    using Microsoft.AspNet.OData.Builder;
    using Microsoft.AspNet.OData.Extensions;
    using Microsoft.AspNetCore.Builder;
    using Microsoft.AspNetCore.Hosting;
    using Microsoft.AspNetCore.Http;
    using Microsoft.AspNetCore.Mvc.ApiExplorer;
    using Microsoft.Extensions.Configuration;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Hosting;
    using Microsoft.Extensions.Options;
    using Microsoft.Extensions.PlatformAbstractions;
    using myInsight.API.BusinessLayer;
    using myInsight.API.Data.myInsightContext;
    using myInsight.API.Service.Filters;
    using myInsight.API.Service.Utils;
    using Swashbuckle.AspNetCore.SwaggerGen;

    /// <summary>
    /// Startup class
    /// </summary>
    public class Startup
    {
        readonly string apiSpecificOrigins = "apiSpecificOrigins";
        readonly string[] headers = new string[] { "Content-Type", "Accept", "Authorization", "myInsightAuthorization" };
        readonly string[] methods = new string[] { "GET", "POST", "PUT", "DELETE", "OPTIONS" };
        readonly bool isDevelopment;
        readonly string serverRegion;
        /// <summary>
        /// Startup constructor
        /// </summary>
        /// <param name="configuration"></param>
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
            isDevelopment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development";
            serverRegion = configuration["ServerRegion"];
        }

        /// <summary>
        /// Configuration variable
        /// </summary>
        public static IConfiguration Configuration { get; private set; }

        /// <summary>
        /// Add methods to the container
        /// </summary>
        /// <param name="services"></param>
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();

            services.AddApiVersioning(options =>
            {
                options.ReportApiVersions = true;
            });
            
            services.AddOData().EnableApiVersioning();
            
            services.AddODataApiExplorer(options =>
            {
                options.GroupNameFormat = "'v'VVV";
                options.SubstituteApiVersionInUrl = true;
            });
            services.AddMvc(options =>
            {
                options.OutputFormatters.Insert(0, new CustomODataOutputFormatter(isDevelopment));
            });

            services.AddTransient<IConfigureOptions<SwaggerGenOptions>, ConfigureSwaggerOptions>();

            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();

            services.AddSwaggerGen(
                options =>
                {
                    options.DocumentFilter<SwaggerDocumentFilter>();
#if !DEBUG
                    options.DocumentFilter<HideEndPointsFilter>();
#endif
                    options.OperationFilter<ODataQueryOptionsFilter>();
                    options.IncludeXmlComments(XmlCommentsFilePath);
                });

            services.AddCors(options =>
            {
                options.AddPolicy(name: apiSpecificOrigins,
                                  builder =>
                                  {
                                      builder.WithOrigins(Configuration["AccessControlAllowOrigins"].Split(","))
                                             .WithHeaders(headers)
                                             .WithMethods(methods)
                                             .AllowCredentials();
                                  });
            });



            AddAppInsights(services);

            services.AddDbContext<ReadOnlyContext>();
            services.AddDbContext<ReadWriteConnection>();

            services.AddScoped<IAdminUsersService, AdminUsersService>();
            services.AddScoped<IAdminRolesService, AdminRolesService>();
            services.AddScoped<INotificationsService, NotificationsService>();
            services.AddScoped<ILanguagesService, LanguagesService>();
            services.AddScoped<ITermsOfUseService, TermsOfUseService>();
            services.AddScoped<IUsersService, UsersService>();
            services.AddScoped<IIndustriesService, IndustriesService>();
            services.AddScoped<IServicesService, ServicesService>();
            services.AddScoped<ISourcesService, SourcesService>();
            services.AddScoped<ITopicsService, TopicsService>();
            services.AddScoped<ICategoriesService, CategoriesService>();
            services.AddScoped<IColorsService, ColorsService>();
            services.AddScoped<ICountriesService, CountriesService>();
            services.AddScoped<IIconsService, IconsService>();
            services.AddScoped<IMemberFirmsService, MemberFirmsService>();
            services.AddScoped<INotificationTypesService, NotificationTypesService>();
            services.AddScoped<IServiceLinesService, ServiceLinesService>();
            services.AddScoped<ITileTypesService, TileTypesService>();
            services.AddScoped<IUserGlobalFilterClientsService, UserGlobalFilterClientsService>();
            services.AddScoped<IUserGlobalFilterJurisdictionsService, UserGlobalFilterJurisdictionsService>();
            services.AddScoped<IUserGlobalFilterProcessesService, UserGlobalFilterProcessesService>();
            services.AddScoped<ITilesService, TilesService>();
            services.AddScoped<IGroupsService, GroupsService>();
            services.AddScoped<IGroupTypesService, GroupTypesService>();
            services.AddScoped<IPermissionsService, PermissionsService>();
            services.AddScoped<IFeedCountriesService, FeedCountriesService>();
            services.AddScoped<IIdentitiesService, IdentitiesService>();
            services.AddScoped<IAbstractionLayerService, AbstractionLayerService>();
            services.AddScoped<ILoggingService, LoggingService>();
            services.AddScoped<ILinkListsService, LinkListsService>();
            services.AddScoped<ITileScreenShotsService, TileScreenShotsService>();
            services.AddScoped<IAzureFileAccessService, AzureFileAccessService>();
            services.AddScoped<IAzureRedisCacheService, AzureRedisCacheService>();
            services.AddScoped<IIntelaService, IntelaService>();
            services.AddScoped<IConfigurationsService, ConfigurationsService>();
            services.AddScoped<IProfilesService, ProfilesService>();
        }

        /// <summary>
        /// Http request pipeline
        /// </summary>
        /// <param name="app"></param>
        /// <param name="env"></param>
        /// <param name="modelBuilder"></param>
        /// <param name="provider"></param>
        public void Configure(IApplicationBuilder app,
                              IWebHostEnvironment env,
                              VersionedODataModelBuilder modelBuilder,
                              IApiVersionDescriptionProvider provider)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseCors(apiSpecificOrigins);

            app.Use(async (context, next) =>
            {
                if (context.Request.Method == "OPTIONS")
                {
                    context.Response.StatusCode = 204;
                    context.Response.Headers.Add("Access-Control-Allow-Origin", context.Request.Headers["Origin"]);
                    context.Response.Headers.Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
                    context.Response.Headers.Add("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
                    context.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
                    return;
                }
                context.Response.Headers.Add("ServerRegion", serverRegion);
                await next();
            });

            app.UseAuthorization();

            app.UseEndpoints(routeBuilder =>
            {
                routeBuilder.EnableDependencyInjection();
                routeBuilder.Select().Filter().OrderBy().Expand().Count().MaxTop(100);
                routeBuilder.MapVersionedODataRoute("odata", "{version:apiVersion}", modelBuilder);
            });

            app.UseSwagger();

            app.UseSwaggerUI(options =>
            {
#if DEBUG
                options.RoutePrefix = "swagger";
#else
                options.RoutePrefix = String.Empty;
#endif

                foreach (var description in provider.ApiVersionDescriptions)
                {
                    options.SwaggerEndpoint($"/swagger/{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant());
                }
            });
        }

        static string XmlCommentsFilePath
        {
            get
            {
                var basePath = PlatformServices.Default.Application.ApplicationBasePath;
                var fileName = typeof(Startup).GetTypeInfo().Assembly.GetName().Name + ".xml";
                return Path.Combine(basePath, fileName);
            }
        }
        private void AddAppInsights(IServiceCollection services)
        {
            string appInsightsKey = Configuration["APPINSIGHTS_INSTRUMENTATIONKEY"];
            if (!string.IsNullOrEmpty(appInsightsKey))
            {
                // The following line enables Application Insights telemetry collection.
                services.AddApplicationInsightsTelemetry();
            }
        }
    }
}