using Castle.Core.Internal;
using Kruzya.TelegramBot.Core.Attributes;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Threading;
using System.Threading.Tasks;

namespace Kruzya.TelegramBot.Core.Service
{
    public class CoreManager : IHostedService
    {
        private readonly Core _core;
        private readonly IServiceScopeFactory _scopeFactory;

        public CoreManager(Core core, IServiceScopeFactory scopeFactory)
        {
            _core = core;
            _scopeFactory = scopeFactory;
        }

        public async Task StartAsync(CancellationToken cts)
        {
            await ManagerStartAsync(cts, _scopeFactory.CreateScope());
            foreach (var module in _core.Modules)
            {
                await module.StartAsync(cts, _scopeFactory.CreateScope());
            }
        }

        public async Task StopAsync(CancellationToken cts)
        {
            // await ManagerStopAsync(cts, _scopeFactory.CreateScope());
            foreach (var module in _core.Modules)
            {
                await module.StopAsync(cts, _scopeFactory.CreateScope());
            }
        }

        public Task ManagerStartAsync(CancellationToken cts, IServiceScope scope)
        {
            var binder = scope.ServiceProvider.GetRequiredService<SerializationBinder>();
            var allowedSerializationTypes = _core.Modules
                .SelectMany(module => module.GetType().Assembly.ExportedTypes)
                .Where(definedType => definedType.GetAttribute<AllowedSerializableTypeAttribute>() != null)
                .ToDictionary(type => type.GetAttribute<AllowedSerializableTypeAttribute>().Name);

            // Also need allow any Telegram Bot API type.
            var telegramTypes = typeof(Telegram.Bot.Types.Update).Assembly.ExportedTypes
                .Where(definedType => definedType.GetAttribute<JsonObjectAttribute>() != null)
                .ToDictionary(type => type.FullName);

            var mergedDictionaryTypes = new List<IDictionary<string, Type>>
                {
                    telegramTypes,
                    allowedSerializationTypes
                }
                .SelectMany(dict => dict)
                .ToDictionary(pair => pair.Key, pair => pair.Value);

            foreach (var pair in mergedDictionaryTypes)
            {
                binder.RegisterAllowedType(pair.Key, pair.Value);
            }

            return Task.CompletedTask;
        }
    }
}