using System;
using Microsoft.Owin;
using Owin;
using System.Web.Http;
using Microsoft.Owin.StaticFiles;
using Microsoft.Owin.FileSystems;
using System.Configuration;
using Microsoft.Owin.Security.OAuth;
using Microsoft.Owin.Cors;
using Step.Provider;
using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Hubs;
using Step.Attributes;
using Step.Utils;
using static Step.Config.StartupConfig;
using System.IO;
using System.Net.NetworkInformation;
using System.Net;

[assembly: OwinStartup(typeof(Step.App_Start.Startup))]

namespace Step.App_Start
{
    public class Startup
    {
        public static OAuthAuthorizationServerOptions OAuthOptions;
        public void Configuration(IAppBuilder app)
        {
            // Configure HTTP
            HttpConfiguration config = new HttpConfiguration();

            // Register Web API config
            WebApiConfig.Register(config);

            // Register Swagger config
            SwaggerConfig.Register(config);

            // Configure api authentication
            ConfigureWebApiOAuth(app);

            app.UseWebApi(config);

            // SignalR config & startup
            SignalRConfig(app);
            var directoryBrowsing = ConfigurationManager.AppSettings["enableDirectoryBrowsing"] == "true";
            // Check if web site directory exists
            if (!Directory.Exists(Constants.WEBSITE_DIRECTORY))
                ExceptionManager.Manage(Constants.ERROR_LEVEL.FATAL, "Main window directory not found!");

            var options = new FileServerOptions()
            {
                EnableDefaultFiles = !directoryBrowsing,
                EnableDirectoryBrowsing = directoryBrowsing,
                RequestPath = PathString.Empty,
                FileSystem = new PhysicalFileSystem(Constants.WEBSITE_DIRECTORY)
            };

            app.UseFileServer(options);
            if (!ServerPortIsAvailable(ServerConfig.ServerPort))
            {
                ExceptionManager.Manage(Constants.ERROR_LEVEL.FATAL, "Server port is already in use by another process");
            }
        }

        private void ConfigureWebApiOAuth(IAppBuilder app)
        {  
            // Create new authorization options
            OAuthOptions = new OAuthAuthorizationServerOptions
            {
                // Login and Token generation end point 
                TokenEndpointPath = new PathString("/Token"),
                Provider = new ApplicationOAuthProvider(),
                // Bearer token expiration time
                AccessTokenExpireTimeSpan = TimeSpan.FromDays(14),
                //TODO: In modalità di produzione impostare AllowInsecureHttp = false
                AllowInsecureHttp = true
            };
            // Set authorization options
            app.UseOAuthAuthorizationServer(OAuthOptions);
            // Set bearer oAuth as authentication method
            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
        }

        public void SignalRConfig(IAppBuilder app)
        {
            //// Set up signalR config
            //app.Map("/signalr", map =>
            //{
            //    map.UseCors(CorsOptions.AllowAll);
            //    // Debug 
            //    HubConfiguration hubConfiguration = new HubConfiguration
            //    {
            //        EnableDetailedErrors = true
            //    };
            //    // Create an istance of custom authorize attribute
            //    SignalRAuthorizeAttribute authorizer = new SignalRAuthorizeAttribute();
            //    AuthorizeModule module = new AuthorizeModule(authorizer, authorizer);
            //    GlobalHost.HubPipeline.AddModule(module);
            //    map.RunSignalR();
            //});
            app.MapSignalR();
        }

        private bool ServerPortIsAvailable(int port)
        {
            bool isAvailable = true;

            IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();
            IPEndPoint[] ipEndPoints = ipProperties.GetActiveTcpListeners();

            foreach (IPEndPoint endPoint in ipEndPoints)
            {
                if (endPoint.Port == port)
                {
                    isAvailable = false;
                    break;
                }
            }

            return isAvailable;
        }
    }
}