using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using PARR.Core.Common.Interfaces;
using PARR.Core.Common.Interfaces.RabbitServices;
using PARR.Core.Repositories.Interfaces.Job;
using PARR.Core.Repositories.Interfaces.JobGroupRepositories;
using PARR.Domain.Common.Rabbit.Messages;
using PARR.Domain.Entities.Base.History;
using PARR.Domain.Enums;
using PARR.JobAutoControl.Settings;

namespace PARR.JobAutoControl
{
    internal class JobAutoControlManager : IJobAutoControlManager
    {
        private readonly WorkerSettings _workerSettings;
        private readonly ILogger<JobAutoControlManager> _logger;
        private readonly IIntervalService _intervalService;
        private readonly IServiceProvider _serviceProvider;
        private readonly MqSettings _mqSettings;

        public JobAutoControlManager(
            WorkerSettings workerSettings,
            ILogger<JobAutoControlManager> logger,
            IIntervalService intervalService,
            IServiceProvider serviceProvider,
            MqSettings mqSettings
            )
        {
            _workerSettings = workerSettings;
            _logger = logger;
            _intervalService = intervalService;
            _serviceProvider = serviceProvider;
            _mqSettings = mqSettings;
        }

        public async Task StartAsync()
        {
            _logger.LogInformation("Запуск сервиса управления авто-контролем РР (JobAutoControl)");

            await _intervalService.IntervalInitAsync(async () =>
            {
                await using (var scope = _serviceProvider.CreateAsyncScope())
                {
                    var jobAutoControlRepository = scope.ServiceProvider.GetRequiredService<IJobAutoControlRepository>();
                    var jobGroupAutoControlRepository = scope.ServiceProvider.GetRequiredService<IJobGroupAutoControlRepository>();
                    var mqService = scope.ServiceProvider.GetRequiredService<IRabbitService>();

                    await HandlerAsync(jobAutoControlRepository, jobGroupAutoControlRepository, mqService);
                }
            }, _workerSettings.RepeatEvery);
        }


        private async Task HandlerAsync(IJobAutoControlRepository jobAutoControlRepository, IJobGroupAutoControlRepository jobGroupAutoControlRepository, IRabbitService mqService)
        {
            // Список JobGroup с включенным автоконтролем
            var jobGroupsIds = await jobGroupAutoControlRepository.Get()
                                                                    .AsNoTracking()
                                                                    .Where(t => t.IsEnable)
                                                                    .Select(t => t.JobGroupId)
                                                                    .ToListAsync();

            // Список Job с включенным автоконтролем, но у которых в JobGroupType.IsJobGroupAutocOntrol==false
            var jobIds = await jobAutoControlRepository.Get()
                                                            .AsNoTracking()
                                                            .Where(t => t.IsEnable && t.Job!.Group!.GroupType!.IsJobGroupAutoControl == false)
                                                            .Select(t => t.JobId)
                                                            .ToListAsync();

            _logger.LogInformation("Найдено объектов с включенным автоконтролем, групп: {JobGroupCount} шт., работ: {JobCount} шт.", jobGroupsIds.Count, jobIds.Count);

            if (jobGroupsIds.Count == 0 && jobIds.Count == 0)
                return;

            // формируем сообщения
            var msgList = new List<TemplateMatcherMq>(jobGroupsIds.Count + jobIds.Count);

            var initiator = new HistoryInitiator
            {
                InitiatorComment = $"Инициатор авто-контроль, периодичность: {_workerSettings.RepeatEvery}",
                InitiatorIp = null,
                InitiatorParrComponentId = ParrComponentsEnum.JobAutoControl
            };

            // группы
            msgList.AddRange(jobGroupsIds.Select(id => new TemplateMatcherMq
            {
                Action = TemplateMatcherActionEnum.Sync,
                EntityType = SyncTaskEntityTypeEnum.JobGroup,
                Id = id,
                Initiator = initiator
            }));

            // работы
            msgList.AddRange(jobIds.Select(id => new TemplateMatcherMq
            {
                Action = TemplateMatcherActionEnum.Sync,
                EntityType = SyncTaskEntityTypeEnum.Job,
                Id = id,
                Initiator = initiator
            }));

            // отправляем задания в очередь template matcher`a
            var sendResult = await mqService.SendAsync(_mqSettings.TemplateMatcher, msgList);

            if (!sendResult.IsSuccess)
                _logger.LogError("Ошибка при отправке сообщений ({Count} шт.) в очередь.", msgList.Count);
            else
                _logger.LogInformation("Выполнена отправка сообщений в очередь, {Count} шт.", msgList.Count);
        }

    }
}