using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using PARR.AIHITRelationshipsSyncer.Models;
using PARR.AIHITRelationshipsSyncer.Services.Interfaces;
using PARR.DAL.Models.Unit;
using PARR.DAL.Services.Interfaces.Unit;
using System.Reactive;
using Unit = PARR.DAL.Models.Unit.Unit;

namespace PARR.AIHITRelationshipsSyncer.Services.Implementations
{
    internal class RelationshipsSyncSrevice : IRelationshipsSyncService
    {
        private readonly ILogger<RelationshipsSyncSrevice> logger;
        private readonly IUnitService unitService;

        public RelationshipsSyncSrevice(ILogger<RelationshipsSyncSrevice> logger,
            IUnitService unitService
            )
        {
            this.logger = logger;
            this.unitService = unitService;
        }


        public async Task SyncAsync(List<AihitData> aihitdata)
        {
            var groupedData = aihitdata.Where(t => t.EKFindCode != null && t.ChildEk != null).GroupBy(ad => ad.EKFindCode);

            //Перебираем сгруппированные по родительскому ЭК данные
            foreach (var parrent in groupedData)
            {
                //Получаем имя родителя
                var parentName = parrent.First().EKFindCode;

                //По имени получаем экземпляр Unit со всеми дочерними связями
                var unit = await GetUnitByNameAsync(parentName!);

                if (unit == null)
                {
                    logger.LogError($"Не удалось получиться родительский ЭК по имени{parentName}");
                    return;
                }
                //Из данных АИХ ИТ получаем имена всех дочерних ЭК
                var childsName = parrent.Select(t => t.ChildEk);

                //Проходим циклом по полученному списку для актуализации связей в полученном нами экземпляре Unit
                await SyncChildSUnitAsync(unit, childsName);

                //применяем изменения в базе данных
                if (!await unitService.CommitAsync())
                    logger.LogError($"Не удалось изменить связи Unit {unit.Name}");
                else
                    logger.LogDebug($"----- Изменены связи Unit: {unit.Name}  -----");
            }

            //Удаляем детей у тех кого детей в выборке АИХ ИТ не оказалось
            await RemoveWasteRelationships(groupedData);

            //применяем изменения в базе данных
            if (!await unitService.CommitAsync())
                logger.LogError($"Не удалось удалить лишние связи");
            else
                logger.LogInformation($"-----  Иереархические связи актуализированы -----");
        }

        private async Task RemoveWasteRelationships(IEnumerable<IGrouping<string?, AihitData>> groupedData)
        {
            var parentNames = groupedData.Select(t => t.Key);

            var units = await unitService.Get()
                .Include(t => t.ChildUnits).ToListAsync();

            var parentsToDeleteChild = units.Where(t => parentNames.All(a => t.Name != a) && t.ChildUnits.Any());

            if (parentsToDeleteChild.Any())
            {
                foreach (var unit in parentsToDeleteChild)
                {
                    unit.ChildUnits.Clear();
                }
            }
        }

        private async Task SyncChildSUnitAsync(Unit unit, IEnumerable<string?> childsName)
        {
            var isChanged = false;

            //удаляем лишние дочерние связи существующие только в БД
            var childsToDelete = unit.ChildUnits.Where(t => !childsName.Any(a => t.ChildUnit?.Name.ToLower() == a!.ToLower().Trim()));
            if (childsToDelete.Any())
            {
                DeleteChilds(unit, childsToDelete);
                if (!isChanged)
                    isChanged = true;
            }

            
            //проверяем отсутсвующие связи
            var absentChildrens = childsName.Where(c => !unit.ChildUnits.Any(x => x.ChildUnit?.Name.ToLower() == c.ToLower().Trim()));
            foreach (var absentChildren in absentChildrens)
            {
                var childUnit = await GetUnitByNameAsync(absentChildren!);
                if (childUnit == null)
                {
                    logger.LogError($"Ошибка получения дочернего ЭК. Из базы пришел NULL для ЭК{absentChildren}");
                    return ;
                }

                unit.ChildUnits.Add(
                    new UnitInUnit
                    {
                        ParentUnitId = unit.Id,
                        ChildUnitId = childUnit.Id,
                        DateCreated = DateTimeOffset.UtcNow,
                    }
                );
            }

            foreach (var child in unit.ChildUnits)
            {
                child.DateSynced = DateTimeOffset.UtcNow;
            }           
        }


        /// <summary>
        /// Синхронизация дочерней связи в ЭК по имени
        /// </summary>
        /// <param name="unit">Unit должен иметь в себе все данные о дочерних связях</param>
        /// <param name="childName">Имя дочернего ЭК</param>
        /// <returns></returns>
        private async Task SyncChildUnitAsync(Unit unit, string childName)
        {
            //if (childName.ToLower() != "рпа-робин-рцку-спиуи-прочее-26-гор")
            //    continue;
            //Ищем детей по имени
            var child = unit.ChildUnits.FirstOrDefault(t => t.ChildUnit?.Name.ToLower() == childName!.ToLower().Trim());

            //Не нашли создаём и сразу пишем в базу, чтобы если попадуться дубликаты в списке они были созданы
            if (child == null)
            {
                var childUnit = await GetUnitByNameAsync(childName!);
                unit.ChildUnits.Add(
                    new UnitInUnit
                    {
                        ParentUnitId = unit.Id,
                        ChildUnitId = childUnit.Id,
                        DateCreated = DateTimeOffset.UtcNow,
                        DateSynced = DateTimeOffset.UtcNow
                    }
                );

                //не чесно!!! todo: 
                if (!await unitService.CommitAsync())
                    logger.LogError($"Не удалось создать связь Unit {unit.Name} с {childUnit.Name}");
                else
                    logger.LogInformation($"----- Создана новая связь Unit {unit.Name} с {childUnit.Name} -----");
            }
            //Для всех обновляем дату синхронизации
            else
                child.DateSynced = DateTimeOffset.UtcNow;
        }


        /// <summary>
        /// Удаление дочерних связей у ЭК
        /// </summary>
        /// <param name="unit"></param>
        /// <param name="unitToDeleteChilds"></param>
        private void DeleteChilds(Unit unit, IEnumerable<UnitInUnit> unitToDeleteChilds)
        {
            foreach (var childUnit in unitToDeleteChilds)
            {
                logger.LogInformation($"----- Удаление связи Unit: {unit.Name} -----");
                unit.ChildUnits.Remove(childUnit);
            }
        }


        /// <summary>
        /// Создать новый ЭК по имени
        /// </summary>
        /// <param name="ekName"></param>
        /// <returns></returns>
        private async Task<Unit?> CreateUnit(string ekName)
        {
            var unit = new Unit
            {
                Name = ekName.Trim()
            };

            if (!await unitService.CreateAsync(unit))
            {
                logger.LogError($"Не удалось создать Unit {unit.Name}");
                return null;
            }
            else
            {
                logger.LogDebug($"----- Создан Unit: {unit.Name}  -----");
                return unit;
            }
        }


        /// <summary>
        /// Получить ЭК с дочерними связями по имени, если такого ещё нет создать
        /// </summary>
        /// <param name="ekName"></param>
        /// <returns></returns>
        private async Task<Unit?> GetUnitByNameAsync(string ekName)
        {
            if (!unitService.Get().AsNoTracking().Any(u => u.Name.ToLower() == ekName.ToLower().Trim()))
            {
                return await CreateUnit(ekName);
            }

            return await unitService.Get()
                .Include(u => u.ChildUnits)
                    .ThenInclude(t => t.ChildUnit)
                .FirstAsync(u => u.Name.ToLower() == ekName.ToLower().Trim());
        }
    }
}