using Microsoft.EntityFrameworkCore;
using PARR.Constants.Shortcodes;
using PARR.DAL.Contracts;
using PARR.DAL.Services.Interfaces.Job;
using PARR.DAL.Services.Interfaces.Unit;
using System.Text.RegularExpressions;

namespace PARR.DAL.DomainServices
{
    internal class TemplateNameGeneratorService : ITemplateNameGeneratorService
    {
        private readonly SettingsFromDb settingsFromDb;
        private readonly IJobService jobService;
        private readonly IUnitService unitService;

        public TemplateNameGeneratorService(
            SettingsFromDb settingsFromDb,
            IJobService jobService,
            IUnitService unitService
            )
        {
            this.settingsFromDb = settingsFromDb;
            this.jobService = jobService;
            this.unitService = unitService;
        }


        public async Task<string> GetTemplateNameAsync(Guid jobId, Guid unitId)
        {
            var nameConstants = settingsFromDb.TemplateNameConstantPartsList;

            var job = await jobService.Get().FirstOrDefaultAsync(t => t.Id == jobId);
            var unit = await unitService.Get().FirstOrDefaultAsync(t => t.Id == unitId);

            if (job != null && unit != null && job.TemplateNameMask != null)
            {
                var resultName = job.TemplateNameMask;

                var shortcodesInMask = GetShortCodes(resultName);

                //Проверяем и меняем наличие статичных частей в маске имени шаблона
                if (shortcodesInMask.Any(x => nameConstants.Select(x => "%" + x.Name + "%").ToList().Contains(x.Value)))
                {
                    resultName = ReplaceConstants(nameConstants, resultName);
                }

                //Проверяем и меняем Shortcodes в маске имени шаблона
                var shortCodes = GetShortcodesNames();
                if (shortcodesInMask.Any(x => shortCodes.Select(x => x).ToList().Contains(x.Value)))
                {
                    resultName = ReplaceShortcodes(job, unit, resultName, shortcodesInMask);
                }

                //Если остались %переменные% проверяем совпадение по имени поля
                shortcodesInMask = GetShortCodes(resultName);
                if (shortcodesInMask.Count > 0)
                {
                    resultName = await ReplaceFieldValues(unitId, resultName, shortcodesInMask);
                }

                return resultName;
            }

            return "";
        }

        private async Task<string> ReplaceFieldValues(Guid unitId, string resultName, List<Match> shortcodesInMask)
        {
            var unitWithFields = await unitService.Get()
                .Include(u => u.UnitValues)
                    .ThenInclude(uv => uv.Field)
                .Include(u => u.UnitValues)
                    .ThenInclude(uv => uv.Value)
                .FirstOrDefaultAsync(t => t.Id == unitId);

            foreach (var item in shortcodesInMask)
            {
                var fieldName = item.Value.Replace("%", "").ToUpper();

                var value = unitWithFields!.UnitValues!.FirstOrDefault(t => t.Field!.AihitName!.ToUpper() == fieldName!);

                if (value != null)
                    resultName = resultName.Replace(item.Value, value!.Value!.Value);
            }

            return resultName;
        }

        private static string ReplaceShortcodes(Models.Job.Job job, Models.Unit.Unit unit, string resultName, List<Match> shortcodesInMask)
        {
            if (shortcodesInMask.Any(x => x.Value == Shortcodes.GetShortcodeName(ShortcodeEnum.Work)))
                resultName = resultName.Replace(Shortcodes.GetShortcodeName(ShortcodeEnum.Work), job.WorkName);

            if (shortcodesInMask.Any(x => x.Value == Shortcodes.GetShortcodeName(ShortcodeEnum.EK)))
                resultName = resultName.Replace(Shortcodes.GetShortcodeName(ShortcodeEnum.EK), unit.Name);
            return resultName;
        }

        private static string ReplaceConstants(List<BLL.Domain.TemplateNameConstantPart> nameConstants, string resultName)
        {
            foreach (var item in nameConstants)
            {
                resultName = resultName.Replace($"%{item.Name}%", item.Value);
            }

            return resultName;
        }

        private static List<Match> GetShortCodes(string resultName)
        {
            var shortcodePattern = "%[^%\\s]+%";
            var shortcodesInMask = Regex.Matches(resultName, shortcodePattern).ToList();
            return shortcodesInMask;
        }

        private List<string> GetShortcodesNames()
        {
            var result = new List<string>();
            var shortcodes = Enum.GetValues(typeof(ShortcodeEnum)).Cast<ShortcodeEnum>();
            foreach (var item in shortcodes)
            {
                result.Add(Shortcodes.GetShortcodeName(item).ToUpper());
            }

            return result;
        }
    }
}