using System;
using System.Linq;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using xAiModels.Providers.Dtos;
using xAiModels.Providers.Entities;
using xCommons.Extensions;
using xDataService.Constants;
using xDataService.Db;
using xDataService.Models;
using xExceptions.Constants;
using xPushService.Helpers;
using xPushService.DI;
using xDataService.DI;
using xAiModels.Interfaces.Dtos;
using xAiModels.Helpers;
using xCommons.Helpers;
using xAiModels.Interfaces.Entities;
using xAiModels.Interfaces;
using xAiModels.Providers;

namespace xAiModels.DI
{
    public static class XDIHelperExtension
    {
        /// <summary>
        /// Register Service ...
        /// </summary>
        /// <param name="services"></param>
        /// <param name="repositoryType"></param>
        /// <param name="lifeTime"></param>
        public static void AddXAiDataService(
            this IServiceCollection services,
            XRepositoryType repositoryType,
            ServiceLifetime lifeTime = ServiceLifetime.Scoped
        )
        {
            AddAiDataService(
                contextType: null,
                services: services,
                lifeTime: lifeTime,
                repositoryType: repositoryType
            );
        }

        /// <summary>
        /// Register Service ...
        /// </summary>
        /// <typeparam name="TContext"></typeparam>
        /// <param name="services"></param>
        /// <param name="repositoryType"></param>
        /// <param name="lifeTime"></param>
        public static void AddXAiDataService<TContext>(
            this IServiceCollection services,
            XRepositoryType repositoryType,
            ServiceLifetime lifeTime = ServiceLifetime.Scoped
        )
        where TContext : XDbContext
        {
            AddAiDataService(
                services: services,
                lifeTime: lifeTime,
                contextType: typeof(TContext),
                repositoryType: repositoryType
            );
        }

        /// <summary>
        /// Use XSubCategoryService Middleware ... 
        /// </summary>
        /// <param name="app"></param>
        /// <param name="isDevelopmentEnvironment"></param>
        public static void UseXAiDataService(
            this IApplicationBuilder app,
            bool isDevelopmentEnvironment = false
        )
        {
            //
            #region Using Hubs ...
            //
            var pushHelper = new XPushServiceHelper();

            //
            // XAiConversation ...
            pushHelper.AddHub<XAiConversationDtoHub>("aiConversationDto");
            pushHelper.AddHub<XAiConversationEntityHub>("aiConversationEntity");

            //
            // XAiMessage ...
            pushHelper.AddHub<XAiMessageDtoHub>("aiMessageDto");
            pushHelper.AddHub<XAiMessageEntityHub>("aiMessageEntity");

            //
            // XAiProject ...
            pushHelper.AddHub<XAiProjectDtoHub>("aiProjectDto");
            pushHelper.AddHub<XAiProjectEntityHub>("aiProjectEntity");

            //
            app.UseXPushService(pushHelper);
            #endregion

            //
            // Using XAiConversation Repository Descriptor ...
            if (!aiConversationDescriptor.IsNull())
            {
                //
                app.UseXRepository(
                    descriptor: aiConversationDescriptor,
                    isDevelopmentEnvironment: isDevelopmentEnvironment
                );
            }

            //
            // Using XAiMessage Repository Descriptor ...
            if (!aiMessageDescriptor.IsNull())
            {
                //
                app.UseXRepository(
                    descriptor: aiMessageDescriptor,
                    isDevelopmentEnvironment: isDevelopmentEnvironment
                );
            }

            //
            // Using XAiProject Repository Descriptor ...
            if (!aiProjectDescriptor.IsNull())
            {
                //
                app.UseXRepository(
                    descriptor: aiProjectDescriptor,
                    isDevelopmentEnvironment: isDevelopmentEnvironment
                );
            }

            //
            // Create an Scope for Services Acces ...
            // Handle Seeding Category/SubCategory Resources ...
            // TODO: Enable Seeding if Required ...
            // using (var scope = app.ApplicationServices.CreateScope())
            // {
            //     //
            //     // Retrieve Configuratuions ...
            //     var aiMessageProvider = scope.ServiceProvider.GetService<IXAiMessageServiceProvider>();
            //     var aiProjectProvider = scope.ServiceProvider.GetService<IXAiProjectServiceProvider>();
            //     var aiConversationProvider = scope.ServiceProvider.GetService<IXAiConversationServiceProvider>();
            //     var configuration = scope.ServiceProvider.GetService<XAiDataServiceServiceConfiguration>();
            //     if (!configuration.IsNullOrDefault() &&
            //         !categoryProvider.IsNullOrDefault() &&
            //         !subaiConversationDescriptor.IsNullOrDefault()
            //     )
            //     {
            //         //
            //         // Logging ...
            //         Log("Start Seeding ...");

            //         //
            //         // Count Data in Category ...
            //         var hasCategory = (categoryProvider.Count().GetAwaiter().GetResult()) > 0;
            //         var hasSubCategory = (subCategoryProvider.Count().GetAwaiter().GetResult()) > 0;

            //         //
            //         // Seed Category Resources ...
            //         var canSeed =
            //             !hasCategory &&
            //             configuration.Categories.HasChild();
            //         if (canSeed)
            //         {
            //             //
            //             // Loop through Provided items ...
            //             foreach (var cat in configuration.Categories)
            //             {
            //                 //
            //                 try
            //                 {
            //                     //
            //                     Log($"Start Seeding Category: {cat.Titles.Locales.ToArray()[0].Value} ...");

            //                     //
            //                     categoryProvider.Refresh(
            //                         resource: cat,
            //                         userInfo: null,
            //                         connectionId: null,
            //                         cancellationToken: default
            //                     )
            //                     .GetAwaiter()
            //                     .GetResult();

            //                     //
            //                     Log($"Seeding Category: {cat.Titles.Locales.ToArray()[0].Value} Finished Successfully ...");
            //                 }
            //                 catch (Exception ex)
            //                 {
            //                     Log($"Seeding Category: {cat.Titles.Locales.ToArray()[0].Value} Failed due: {ex.Message} ...");
            //                 }
            //             }
            //         }

            //         //
            //         // Seed SubCategory Resources ...
            //         canSeed =
            //             !hasSubCategory &&
            //             configuration.SubCategories.HasChild();
            //         if (canSeed)
            //         {
            //             //
            //             // Loop through Provided items ...
            //             foreach (var subcat in configuration.SubCategories)
            //             {
            //                 //
            //                 try
            //                 {
            //                     //
            //                     Log($"Start Seeding SubCategory: {subcat.Titles.Locales.ToArray()[0].Value} ...");

            //                     //
            //                     subCategoryProvider.Refresh(
            //                         userInfo: null,
            //                         resource: subcat,
            //                         connectionId: null,
            //                         cancellationToken: default
            //                     )
            //                     .GetAwaiter()
            //                     .GetResult();

            //                     //
            //                     Log($"Seeding SubCategory: {subcat.Titles.Locales.ToArray()[0].Value} Finished Successfully ...");
            //                 }
            //                 catch (Exception ex)
            //                 {
            //                     Log($"Seeding SubCategory: {subcat.Titles.Locales.ToArray()[0].Value} Failed due: {ex.Message} ...");
            //                 }
            //             }
            //         }

            //         //
            //         Log("Finish Seeding ...");
            //     }
            // }
        }

        //
        #region Private ...
        private static XRepositoryDescriptor aiMessageDescriptor = null;
        private static XRepositoryDescriptor aiProjectDescriptor = null;
        private static XRepositoryDescriptor aiConversationDescriptor = null;

        /// <summary>
        /// a LogTag for Service ...
        /// </summary>
        private static string XLogTag = "XAiModels";

        /// <summary>
        /// print a log in Console ...
        /// </summary>
        /// <param name="message"></param>
        private static void Log(string message)
        {
            Console.WriteLine($"{XLogTag} => {message}");
        }

        /// <summary>
        /// Register Service ...
        /// </summary>
        /// <param name="services"></param>
        /// <param name="repositoryType"></param>
        /// <param name="contextType"></param>
        /// <param name="lifeTime"></param>
        private static void AddAiDataService(
            IServiceCollection services,
            XRepositoryType repositoryType,
            Type contextType = null,
            ServiceLifetime lifeTime = ServiceLifetime.Scoped
        )
        {
            //
            var exception = XException.InvalidArgs.ToException(); ;

            //
            // Services ...
            var isServicesExists = !services.IsNull();
            if (!isServicesExists)
            {
                //
                Log("Service Registration failed, services not provided ...");
                throw exception;
            }

            //
            // Lifetime ...
            var isLifetimeExists = !lifeTime.IsNull();
            if (!isLifetimeExists)
            {
                //
                Log("Service Registration failed, lifetime not provided ...");
                throw exception;
            }

            //
            // Validate Repository Type ...
            var isRepositoryTypeValid =
                (repositoryType == XRepositoryType.EF &&
                !contextType.IsNull()) ||
                ((repositoryType == XRepositoryType.Mongo ||
                    repositoryType == XRepositoryType.InMemory) &&
                contextType.IsNull());
            if (!isRepositoryTypeValid)
            {
                //
                Log("Service Registration failed, Invalid Repository Type and Context Type ...");
                throw exception;
            }

            //
            // Maske Instance of Repository Descriptor 
            // Based on Provided Type ...
            switch (repositoryType)
            {
                //
                case XRepositoryType.EF:
                    //
                    // XAiMessage ...
                    aiMessageDescriptor = typeof(XAiModelsHelper)
                        .InvokeGenericMethod<XRepositoryDescriptor>(
                            methodName: "GetXAiMessageEFRepositoryDescriptor",
                            runtimeType: contextType,
                            args: null
                    );

                    //
                    // XAiProject ...
                    aiProjectDescriptor = typeof(XAiModelsHelper)
                        .InvokeGenericMethod<XRepositoryDescriptor>(
                            methodName: "GetXAiProjectEFRepositoryDescriptor",
                            runtimeType: contextType,
                            args: null
                    );

                    //
                    // XAiConversation ...
                    aiConversationDescriptor = typeof(XAiModelsHelper)
                        .InvokeGenericMethod<XRepositoryDescriptor>(
                            methodName: "GetXAiConversationEFRepositoryDescriptor",
                            runtimeType: contextType,
                            args: null
                    );
                    break;

                //
                case XRepositoryType.Mongo:
                    //
                    // XAiMessage ...
                    aiMessageDescriptor = XAiModelsHelper.GetXAiMessageMongoRepositoryDescriptor();

                    //
                    // XAiProject ...
                    aiProjectDescriptor = XAiModelsHelper.GetXAiProjectMongoRepositoryDescriptor();

                    //
                    // XAiConversation ...
                    aiConversationDescriptor = XAiModelsHelper.GetXAiConversationMongoRepositoryDescriptor();
                    break;

                //
                case XRepositoryType.InMemory:
                    //
                    // XAiMessage ...
                    aiMessageDescriptor = XAiModelsHelper.GetXAiMessageInMemoryRepositoryDescriptor();

                    //
                    // XAiProject ...
                    aiProjectDescriptor = XAiModelsHelper.GetXAiProjectInMemoryRepositoryDescriptor();

                    //
                    // XAiConversation ...
                    aiConversationDescriptor = XAiModelsHelper.GetXAiConversationInMemoryRepositoryDescriptor();
                    break;
            }

            //
            #region Register Repository Descriptor ...
            //
            // XAiMessage ...
            if (!aiMessageDescriptor.IsNull())
            {
                //
                services.AddXRepository(
                    lifeTime: lifeTime,
                    descriptor: aiMessageDescriptor
                );
            }

            //
            // XAiProject ...
            if (!aiProjectDescriptor.IsNull())
            {
                //
                services.AddXRepository(
                    lifeTime: lifeTime,
                    descriptor: aiProjectDescriptor
                );
            }

            //
            // XAiConversation ...
            if (!aiConversationDescriptor.IsNull())
            {
                //
                services.AddXRepository(
                    lifeTime: lifeTime,
                    descriptor: aiConversationDescriptor
                );
            }
            #endregion

            //
            #region Register Services ...
            //
            #region AiMessage ...
            //
            // Models ...
            services.Add(
                new ServiceDescriptor(typeof(IXAiMessageServiceProvider), typeof(XAiMessageServiceProvider), lifeTime)
            );
            services.Add(
                new ServiceDescriptor(typeof(IXAiMessageRepositoryService), typeof(XAiMessageRepositoryService), lifeTime)
            );
            services.Add(
                new ServiceDescriptor(typeof(IXAiMessageRepositoryProvider), typeof(XAiMessageRepositoryProvider), lifeTime)
            );
            #endregion

            //
            #region AiProject ...
            //
            // Models ...
            services.Add(
                new ServiceDescriptor(typeof(IXAiProjectServiceProvider), typeof(XAiProjectServiceProvider), lifeTime)
            );
            services.Add(
                new ServiceDescriptor(typeof(IXAiProjectRepositoryService), typeof(XAiProjectRepositoryService), lifeTime)
            );
            services.Add(
                new ServiceDescriptor(typeof(IXAiProjectRepositoryProvider), typeof(XAiProjectRepositoryProvider), lifeTime)
            );

            //
            // Resource Providers ...
            services.Add(
                new ServiceDescriptor(typeof(IXAiProjectTitleResourceProvider), typeof(XAiProjectTitleResourceProvider), lifeTime)
            );
            services.Add(
                new ServiceDescriptor(typeof(IXAiProjectDescriptionResourceProvider), typeof(XAiProjectDescriptionResourceProvider), lifeTime)
            );
            #endregion

            //
            #region AiConversation ...
            //
            // Models ...
            services.Add(
                new ServiceDescriptor(typeof(IXAiConversationServiceProvider), typeof(XAiConversationServiceProvider), lifeTime)
            );
            services.Add(
                new ServiceDescriptor(typeof(IXAiConversationRepositoryService), typeof(XAiConversationRepositoryService), lifeTime)
            );
            services.Add(
                new ServiceDescriptor(typeof(IXAiConversationRepositoryProvider), typeof(XAiConversationRepositoryProvider), lifeTime)
            );

            //
            // Resource Providers ...
            services.Add(
                new ServiceDescriptor(typeof(IXAiConversationTitleResourceProvider), typeof(XAiConversationTitleResourceProvider), lifeTime)
            );
            #endregion
            #endregion

            //
            Log("Service Regitration Succeed ...");
        }
        #endregion        
    }
}