using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using PARR.DAL.NextRunServices.Models;
using PARR.DAL.Services.Interfaces;

namespace PARR.DAL.NextRunServices.Subservices
{
    /// <summary>
    /// Распределитель шаблонов с поддержкой часовых поясов.
    /// Все входные даты интерпретируются в целевом часовом поясе (параметр offset).
    /// Все результаты возвращаются строго в UTC (TimeSpan.Zero).
    /// </summary>
    internal class TemplateDistributorV2 : ITemplateDistributorV2
    {
        private readonly ILogger<TemplateDistributorV2> logger;
        private readonly IWeekendDayService weekendDayService;

        /// <summary>
        /// Смещение nextRun на несколько лет вперед, если не смог его рассчитать
        /// </summary>
        private const int offsetYearsIfErrorCalcNextRun = 5;

        /// <summary>
        /// Максимальное количество попыток расширения периода при отсутствии рабочих дней
        /// </summary>
        private const int maxPeriodExpansions = 2;

        public TemplateDistributorV2(ILogger<TemplateDistributorV2> logger, IWeekendDayService weekendDayService)
        {
            this.logger = logger;
            this.weekendDayService = weekendDayService;
        }


        public async Task<TemplateNextRunResultDto> GetNextRunForTemplateAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, TimeSpan? offset, TemplateNextRunDto targetTemplate, List<TemplateNextRunDto> allTemplates, bool excludeWeekends, bool isNew)
        {
            // Валидация входных параметров
            if (duration <= 0)
                throw new ArgumentException($"Duration must be positive, got {duration}", nameof(duration));

            if (allTemplates == null)
                throw new ArgumentNullException(nameof(allTemplates));

            logger.LogInformation("Начинаем проверку/расчёт NextRun для шаблона {templateId}, nextRun={nextRun}. isNew={isNew}, offset={offset}, referenceDate={referenceDate}", targetTemplate.Id, targetTemplate.NextRun, isNew, offset, referenceDate);

            // 1. Определяем целевой часовой пояс
            var targetOffset = offset ?? TimeSpan.Zero;
            var referenceDateInTargetTz = referenceDate.ToOffset(targetOffset);

            logger.LogDebug("Целевой часовой пояс: {offset}. ReferenceDate в целевом поясе: {refDate}", targetOffset, referenceDateInTargetTz);


            // 2. Рассчитываем период распределения в целевом поясе
            var _startDate = GetStartPeriodDate(startDate, referenceDateInTargetTz, targetOffset);
            var _endDate = GetEndPeriodDate(_startDate, duration);

            logger.LogInformation("Период распределения: {_startDate} - {_endDate} (в поясе {offset})", _startDate, _endDate, targetOffset);

            // 3. Получаем список рабочих дней с расширением периода при необходимости
            var (expandedEndDate, workDays) = await GetWorkDaysWithExpansionAsync(_startDate, duration, excludeWeekends);

            // Обновляем _endDate на расширенный период для дальнейших расчётов
            _endDate = expandedEndDate;

            if (workDays.Count == 0)
            {
                logger.LogError("Не удалось найти рабочие дни даже после {maxAttempts} попыток расширения периода [{start}, {end}]. Возвращаем ошибку со смещением.", maxPeriodExpansions, _startDate, _endDate);
                return FillTemplateResultWithOffsetError(targetTemplate, _startDate, referenceDateInTargetTz, targetOffset);
            }

            #region 4. Строим план нагрузки и рассчитываем текущую нагрузку

            logger.LogDebug("Строим план распределения для шаблона {templateId}. Всего шаблонов: {totalTemplates}", targetTemplate.Id, allTemplates.Count);

            // Исключаем текущий шаблон из расчёта
            var templatesForPlan = allTemplates.Where(t => t.Id != targetTemplate.Id).ToList();

            logger.LogDebug("Исключили текущий шаблон из расчёта. Осталось {count} шаблонов для плана", templatesForPlan.Count);

            // Определяем тип плана (обычный или зеркальный)
            bool useMirrorPlan = false;

            // Определяем тип плана на основе контекста
            if (!targetTemplate.NextRun.HasValue)
            {
                // Нет текущего NextRun — тип плана зависит от isNew
                useMirrorPlan = !isNew;
                logger.LogDebug("Нет текущего NextRun. Тип плана: {planType} (isNew={isNew})", useMirrorPlan ? "зеркальный" : "обычный", isNew);
            }
            else
            {
                // Есть текущий NextRun — проверяем, в периоде ли он
                var _nextRunInTargetTz = targetTemplate.NextRun.Value.ToOffset(targetOffset);
                var _nextRunDate = DateOnly.FromDateTime(_nextRunInTargetTz.Date);

                bool _isInPeriod = _nextRunDate >= _startDate && _nextRunDate <= _endDate;
                bool _isWorkDay = workDays.Contains(_nextRunDate);

                if (_isInPeriod && !_isWorkDay)
                {
                    // В периоде, но нерабочий день — обычный план
                    useMirrorPlan = false;
                    logger.LogDebug("NextRun в периоде, но на нерабочем дне. Используем обычный план.");
                }
                else if (!_isInPeriod)
                {
                    // Не в периоде — тип плана зависит от isNew
                    useMirrorPlan = !isNew;
                    logger.LogDebug("NextRun вне периода. Тип плана: {planType} (isNew={isNew})", useMirrorPlan ? "зеркальный" : "обычный", isNew);
                }
                else
                {
                    // В периоде и рабочий день — будем проверять актуальность
                    useMirrorPlan = false;
                    logger.LogDebug("NextRun в периоде и на рабочем дне. Используем обычный план для проверки.");
                }
            }

            // Строим план распределения
            List<DateOnly> plan;
            if (useMirrorPlan)
            {
                // Зеркальный план
                plan = GetDistributionPlan(templatesForPlan.Count + 1, workDays, mirror: true);
                logger.LogDebug("Построен зеркальный план для {count} шаблонов", templatesForPlan.Count + 1);
            }
            else
            {
                // Обычный план
                plan = GetDistributionPlan(templatesForPlan.Count + 1, workDays);
                logger.LogDebug("Построен обычный план для {count} шаблонов", templatesForPlan.Count + 1);
            }

            // Считаем ожидаемую нагрузку из плана
            var expectedDailyLoad = plan.GroupBy(d => d).ToDictionary(g => g.Key, g => g.Count());

            logger.LogDebug("Ожидаемая нагрузка по плану: {loadCount} дней", expectedDailyLoad.Count);
            foreach (var kvp in expectedDailyLoad.OrderBy(x => x.Key))
                logger.LogDebug("  {date}: ожидаемо {count} шаблонов", kvp.Key, kvp.Value);

            // Считаем текущую нагрузку (только шаблоны внутри периода)
            var currentDailyLoad = BuildCurrentLoad(templatesForPlan, workDays, _startDate, _endDate, targetOffset);

            logger.LogDebug("Текущая нагрузка (без учёта текущего шаблона): {loadCount} дней", currentDailyLoad.Count);
            foreach (var kvp in currentDailyLoad.OrderBy(x => x.Key))
                logger.LogDebug("  {date}: текущая {current}, ожидаемая {expected}", kvp.Key, kvp.Value, expectedDailyLoad.GetValueOrDefault(kvp.Key, 0));

            #endregion

            // 5. Случай: нет текущего NextRun
            if (!targetTemplate.NextRun.HasValue)
            {
                logger.LogInformation("Шаблон {templateId} не имеет текущего NextRun. Ищем новое место...", targetTemplate.Id);

                return HandleNoNextRun(
                    targetTemplate,
                    workDays,
                    currentDailyLoad,
                    expectedDailyLoad,
                    referenceDateInTargetTz,
                    targetOffset,
                    isNew);
            }

            #region 6. Случай: есть текущий NextRun — проверяем актуальность

            logger.LogDebug("Шаблон {templateId} имеет текущий NextRun: {nextRun}. Проверяем актуальность...", targetTemplate.Id, targetTemplate.NextRun.Value);

            var nextRunInTargetTz = targetTemplate.NextRun.Value.ToOffset(targetOffset);
            var nextRunDate = DateOnly.FromDateTime(nextRunInTargetTz.Date);

            logger.LogDebug("NextRun в целевом поясе {offset}: {nextRunTarget} (дата: {date})", targetOffset, nextRunInTargetTz, nextRunDate);

            // Проверка 1: В периоде?
            var isInPeriod = nextRunDate >= _startDate && nextRunDate <= _endDate;
            logger.LogDebug("Проверка 1 (в периоде): {result} ({date} ∈ [{start}, {end}])", isInPeriod, nextRunDate, _startDate, _endDate);

            // Проверка 2: Рабочий день?
            var isWorkDay = workDays.Contains(nextRunDate);
            logger.LogDebug("Проверка 2 (рабочий день): {result}", isWorkDay ? "да" : "нет");

            // Проверка 3: В будущем?
            var nextRunMoment = new DateTimeOffset(
                                            nextRunDate.Year, nextRunDate.Month, nextRunDate.Day,
                                            nextRunInTargetTz.Hour, nextRunInTargetTz.Minute, nextRunInTargetTz.Second,
                                            targetOffset);

            var isFuture = nextRunMoment >= DateTimeOffset.UtcNow;
            logger.LogDebug("Проверка 3 (в будущем): {result} ({moment} >= {now})", isFuture, nextRunMoment, DateTimeOffset.UtcNow);

            // Проверка 4: Время совпадает с referenceDate?
            var hasMatchingTime = nextRunInTargetTz.Hour == referenceDateInTargetTz.Hour &&
                                  nextRunInTargetTz.Minute == referenceDateInTargetTz.Minute &&
                                  nextRunInTargetTz.Second == referenceDateInTargetTz.Second;
            logger.LogDebug("Проверка 4 (время совпадает): {result} (NextRun: {nextRunHour}:{nextRunMin}:{nextRunSec} vs Reference: {refHour}:{refMin}:{refSec})",
                                                                                            hasMatchingTime,
                                                                                            nextRunInTargetTz.Hour, nextRunInTargetTz.Minute, nextRunInTargetTz.Second,
                                                                                            referenceDateInTargetTz.Hour, referenceDateInTargetTz.Minute, referenceDateInTargetTz.Second);

            // СЛУЧАЙ А: Дата актуальна, но время не совпадает → корректируем ТОЛЬКО время
            if (isInPeriod && isWorkDay && isFuture && !hasMatchingTime)
            {
                logger.LogDebug("Дата NextRun шаблона {templateId} актуальна, но время не совпадает. Корректируем время с {oldTime} на {newTime} (пояс {offset}).",
                    targetTemplate.Id,
                    $"{nextRunInTargetTz.Hour:D2}:{nextRunInTargetTz.Minute:D2}:{nextRunInTargetTz.Second:D2}",
                    $"{referenceDateInTargetTz.Hour:D2}:{referenceDateInTargetTz.Minute:D2}:{referenceDateInTargetTz.Second:D2}",
                    targetOffset);

                // Сохраняем ту же дату, но меняем время на время из referenceDate
                var correctedNextRunInTargetTz = new DateTimeOffset(
                                                            nextRunDate.Year, nextRunDate.Month, nextRunDate.Day,
                                                            referenceDateInTargetTz.Hour,
                                                            referenceDateInTargetTz.Minute,
                                                            referenceDateInTargetTz.Second,
                                                            targetOffset);

                //скорректированный момент ещё в будущем?
                if (correctedNextRunInTargetTz >= DateTimeOffset.UtcNow)
                {
                    // Время актуально — возвращаем скорректированный NextRun
                    var correctedNextRunUtc = correctedNextRunInTargetTz.ToOffset(TimeSpan.Zero);

                    logger.LogInformation("Скорректированный NextRun для шаблона {templateId}: {nextRunTarget} (пояс {offset}) → {nextRunUtc} (UTC). NextRunOld: {nextRunOld}",
                        targetTemplate.Id, correctedNextRunInTargetTz, targetOffset, correctedNextRunUtc, targetTemplate.NextRun);

                    return new TemplateNextRunResultDto(
                        Id: targetTemplate.Id,
                        NextRun: correctedNextRunUtc,
                        NextRunOld: targetTemplate.NextRun);
                }
                else
                {
                    // Скорректированное время уже прошло — считаем дату НЕАКТУАЛЬНОЙ
                    logger.LogDebug("Скорректированное время {correctedTime} уже прошло (сейчас {now}). Считаем дату неактуальной и передаём в основную логику поиска.",
                        correctedNextRunInTargetTz, DateTimeOffset.UtcNow);

                    // Помечаем дату как неактуальную по времени
                    isFuture = false;
                    // Дальнейшая логика сама вызовет HandleOutdatedNextRun с правильными параметрами
                }
            }

            // СЛУЧАЙ Б: Все проверки пройдены (включая время) → возвращаем без изменений
            if (isInPeriod && isWorkDay && isFuture && hasMatchingTime)
            {
                var nextRunUtc = targetTemplate.NextRun.Value.ToOffset(TimeSpan.Zero);
                logger.LogInformation("NextRun шаблона {templateId} полностью актуален. Возвращаем без изменений: {nextRunUtc} (UTC)",
                                                                            targetTemplate.Id, nextRunUtc);

                return new TemplateNextRunResultDto(
                                    Id: targetTemplate.Id,
                                    NextRun: nextRunUtc,
                                    NextRunOld: targetTemplate.NextRun);
            }

            // СЛУЧАЙ В: Дата неактуальна (не в периоде / нерабочий день / уже прошло) → ищем новое место
            logger.LogDebug("NextRun шаблона {templateId} неактуален по дате (в периоде={inPeriod}, рабочий={workDay}, будущее={future}). Ищем новое место...",
                                        targetTemplate.Id, isInPeriod, isWorkDay, isFuture);

            #endregion

            // 7. NextRun неактуален — ищем новое место
            logger.LogDebug("NextRun шаблона {templateId} неактуален (в периоде={inPeriod}, рабочий={workDay}, будущее={future}). Ищем новое место...", targetTemplate.Id, isInPeriod, isWorkDay, isFuture);

            return HandleOutdatedNextRun(
                                targetTemplate,
                                nextRunDate,
                                isInPeriod,
                                isWorkDay,
                                isNew,
                                workDays,
                                currentDailyLoad,
                                expectedDailyLoad,
                                referenceDateInTargetTz,
                                targetOffset,
                                _startDate,
                                _endDate);
        }


        /// <summary>
        /// Распределить шаблоны
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="duration"></param>
        /// <param name="referenceDate"></param>
        /// <param name="offset"></param>
        /// <param name="allTemplates"></param>
        /// <param name="excludeWeekends"></param>
        /// <returns></returns>
        public async Task<List<TemplateNextRunResultDto>> DistributeTemplatesAsync(DateOnly startDate, int duration, DateTimeOffset referenceDate, TimeSpan? offset, List<TemplateNextRunDto> allTemplates, bool excludeWeekends)
        {
            // Валидация входных параметров
            if (duration <= 0)
                throw new ArgumentException($"Duration must be positive, got {duration}", nameof(duration));

            if (allTemplates == null)
                throw new ArgumentNullException(nameof(allTemplates));


            // 1. Определяем целевой часовой пояс
            var targetOffset = offset ?? TimeSpan.Zero;

            // 2. Применяем оффсет к referenceDate для расчётов в целевом поясе
            var referenceDateInTargetTz = referenceDate.ToOffset(targetOffset);

            logger.LogDebug("Распределение шаблонов в часовом поясе {offset}. ReferenceDate в целевом поясе: {refDate}", targetOffset, referenceDateInTargetTz);

            // 3. Рассчитываем период распределения С УЧЁТОМ ЧАСОВОГО ПОЯСА
            var _startDate = GetStartPeriodDate(startDate, referenceDateInTargetTz, targetOffset);
            var _endDate = GetEndPeriodDate(_startDate, duration);

            logger.LogInformation("Начинаем распределение {Count} шаблонов на {duration} дней, с {_startDate} по {_endDate}. ReferenceDateInTargetTz: {referenceDateInTargetTz} в целевом поясе: {targetOffset} ReferenceDate UTC: {referenceDate}. Исключить выходные и праздники: {excludeWeekends}.", allTemplates.Count, duration, _startDate, _endDate, referenceDateInTargetTz, targetOffset, referenceDate, excludeWeekends);

            // 4. Получаем рабочие дни с расширением периода при необходимости
            var (expandedEndDate, workDays) = await GetWorkDaysWithExpansionAsync(_startDate, duration, excludeWeekends);

            // Обновляем _endDate на расширенный период для дальнейших расчётов
            _endDate = expandedEndDate;

            if (workDays.Count == 0)
            {
                logger.LogError("Не удалось найти рабочие дни даже после {maxAttempts} попыток расширения периода [{start}, {end}]. Возвращаем шаблоны со смещением {years} лет.", maxPeriodExpansions, _startDate, _endDate, offsetYearsIfErrorCalcNextRun);

                var errorResult = allTemplates.Select(t =>
                                                        FillTemplateResultWithOffsetError(t, _startDate, referenceDateInTargetTz, targetOffset)
                                                     ).OrderBy(t => t.NextRun).ToList();

                logger.LogInformation("Распределение завершено с ошибкой. Возвращаем {Count} записей.", errorResult.Count);
                return errorResult;
            }

            // 5. Строим план распределения
            // строим план, дни на которые должны быть назанчены шаблоны
            var plan = GetDistributionPlan(allTemplates.Count, workDays);
            // Подсчитываем, сколько работ должно быть на каждый день
            var expectedDailyLoad = plan.GroupBy(d => d)
                                            .ToDictionary(g => g.Key, g => g.Count());

            #region Группируем шаблоны по дням В ЦЕЛЕВОМ ПОЯСЕ, на которые они уже назначены

            var templatesByDay = new Dictionary<DateOnly, List<TemplateNextRunDto>>();

            foreach (var template in allTemplates)
            {
                if (template.NextRun.HasValue)
                {
                    // КОНВЕРТИРУЕМ В ЦЕЛЕВОЙ ПОЯС ДЛЯ ОПРЕДЕЛЕНИЯ ДАТЫ!
                    var dayInTargetTz = DateOnly.FromDateTime(template.NextRun.Value.ToOffset(targetOffset).Date);
                    //var day = DateOnly.FromDateTime(template.NextRun.Value.Date);

                    if (!templatesByDay.ContainsKey(dayInTargetTz))
                    {
                        templatesByDay[dayInTargetTz] = new List<TemplateNextRunDto>();
                    }
                    templatesByDay[dayInTargetTz].Add(template);

                    logger.LogDebug("Шаблон {Id} с NextRun={nextRun} отнесён к дате {day} в поясе {offset}", template.Id, template.NextRun.Value, dayInTargetTz, targetOffset);
                }
            }

            #endregion

            #region 7. Подсчитываем текущую нагрузку на каждый день

            var currentDailyLoad = workDays.ToDictionary(day => day, _ => 0);

            foreach (var kvp in templatesByDay)
            {
                if (currentDailyLoad.ContainsKey(kvp.Key))
                    currentDailyLoad[kvp.Key] = kvp.Value.Count;
            }

            #endregion


            #region 8. Определяем, какие шаблоны нужно оставить, а какие — переназначить
            var templatesToKeep = new List<TemplateNextRunResultDto>();
            var templatesToReassign = new List<TemplateNextRunDto>();

            foreach (var kvp in templatesByDay)
            {
                var day = kvp.Key;
                var templates = kvp.Value;

                // Если день — нерабочий, то все шаблоны нужно переназначить
                if (!workDays.Contains(day))
                {
                    foreach (var template in templates)
                    {
                        templatesToReassign.Add(template);
                        logger.LogDebug("Шаблон {TemplateId} назначен на нерабочий день {NextRun} — будет переназначен.", template.Id, template.NextRun);
                    }
                    continue;
                }

                var expectedCount = expectedDailyLoad.GetValueOrDefault(day, 0);
                var currentCount = templates.Count;

                if (currentCount <= expectedCount)
                {
                    // Все шаблоны в этом дне можно оставить, но нужно проверить/скорректировать время
                    foreach (var template in templates)
                    {
                        // Конвертируем текущий NextRun в целевой пояс для проверки времени
                        var nextRunInTargetTz = template.NextRun.Value.ToOffset(targetOffset);
                        var nextRunDate = DateOnly.FromDateTime(nextRunInTargetTz.Date);

                        // Проверяем, совпадает ли время с referenceDate
                        var hasMatchingTime = nextRunInTargetTz.Hour == referenceDateInTargetTz.Hour &&
                                              nextRunInTargetTz.Minute == referenceDateInTargetTz.Minute &&
                                              nextRunInTargetTz.Second == referenceDateInTargetTz.Second;

                        DateTimeOffset newNextRun;

                        if (hasMatchingTime)
                        {
                            // Время совпадает — оставляем как есть (только конвертируем в чистый UTC)
                            newNextRun = template.NextRun.Value.ToOffset(TimeSpan.Zero);
                            logger.LogDebug("Шаблон {TemplateId} оставлен без изменений (время совпадает): {NextRun} (UTC)",
                                template.Id, newNextRun);
                        }
                        else
                        {
                            // Время НЕ совпадает — корректируем ТОЛЬКО время, сохраняя ту же дату
                            var correctedNextRunInTargetTz = new DateTimeOffset(
                                nextRunDate.Year, nextRunDate.Month, nextRunDate.Day,
                                referenceDateInTargetTz.Hour,
                                referenceDateInTargetTz.Minute,
                                referenceDateInTargetTz.Second,
                                targetOffset);

                            // Проверяем, что скорректированный момент ещё в будущем
                            if (correctedNextRunInTargetTz >= DateTimeOffset.UtcNow)
                            {
                                newNextRun = correctedNextRunInTargetTz.ToOffset(TimeSpan.Zero);
                                logger.LogDebug("Шаблон {TemplateId} оставлен на дате {date}, время скорректировано с {oldTime} на {newTime} (UTC): {NextRun}",
                                    template.Id, nextRunDate,
                                    $"{nextRunInTargetTz.Hour:D2}:{nextRunInTargetTz.Minute:D2}:{nextRunInTargetTz.Second:D2}",
                                    $"{referenceDateInTargetTz.Hour:D2}:{referenceDateInTargetTz.Minute:D2}:{referenceDateInTargetTz.Second:D2}",
                                    newNextRun);
                            }
                            else
                            {
                                // Скорректированное время уже прошло — переназначаем шаблон
                                templatesToReassign.Add(template);
                                logger.LogDebug("Шаблон {TemplateId} переназначается, т.к. скорректированное время {correctedTime} уже прошло",
                                    template.Id, correctedNextRunInTargetTz);
                                continue;
                            }
                        }

                        templatesToKeep.Add(new TemplateNextRunResultDto(
                            Id: template.Id,
                            NextRun: newNextRun,
                            NextRunOld: template.NextRun
                        ));
                    }
                }
                else
                {
                    // Оставляем только expectedCount штук, остальные — переназначить
                    // (для оставляемых тоже нужно проверить/скорректировать время)
                    for (int i = 0; i < expectedCount; i++)
                    {
                        var template = templates[i];

                        // Конвертируем текущий NextRun в целевой пояс для проверки времени
                        var nextRunInTargetTz = template.NextRun.Value.ToOffset(targetOffset);
                        var nextRunDate = DateOnly.FromDateTime(nextRunInTargetTz.Date);

                        var hasMatchingTime = nextRunInTargetTz.Hour == referenceDateInTargetTz.Hour &&
                                              nextRunInTargetTz.Minute == referenceDateInTargetTz.Minute &&
                                              nextRunInTargetTz.Second == referenceDateInTargetTz.Second;

                        DateTimeOffset newNextRun;

                        if (hasMatchingTime)
                        {
                            newNextRun = template.NextRun.Value.ToOffset(TimeSpan.Zero);
                            logger.LogDebug("Шаблон {TemplateId} (часть перегрузки) оставлен без изменений (время совпадает): {NextRun} (UTC)",
                                template.Id, newNextRun);
                        }
                        else
                        {
                            var correctedNextRunInTargetTz = new DateTimeOffset(
                                nextRunDate.Year, nextRunDate.Month, nextRunDate.Day,
                                referenceDateInTargetTz.Hour,
                                referenceDateInTargetTz.Minute,
                                referenceDateInTargetTz.Second,
                                targetOffset);

                            if (correctedNextRunInTargetTz >= DateTimeOffset.UtcNow)
                            {
                                newNextRun = correctedNextRunInTargetTz.ToOffset(TimeSpan.Zero);
                                logger.LogDebug("Шаблон {TemplateId} (часть перегрузки) оставлен на дате {date}, время скорректировано: {NextRun}",
                                    template.Id, nextRunDate, newNextRun);
                            }
                            else
                            {
                                templatesToReassign.Add(template);
                                logger.LogDebug("Шаблон {TemplateId} (часть перегрузки) переназначается, т.к. скорректированное время уже прошло",
                                    template.Id);
                                continue;
                            }
                        }

                        templatesToKeep.Add(new TemplateNextRunResultDto(
                            Id: template.Id,
                            NextRun: newNextRun,
                            NextRunOld: template.NextRun
                        ));
                    }

                    for (int i = expectedCount; i < currentCount; i++)
                    {
                        var template = templates[i];
                        templatesToReassign.Add(template);
                        logger.LogDebug("Шаблон {TemplateId} переназначается, т.к. нагрузка в день превышена.", template.Id);
                    }
                }
            }
            #endregion


            #region 9. Добавляем шаблоны, у которых не было даты — тоже нужно распределить

            foreach (var template in allTemplates)
            {
                if (!template.NextRun.HasValue)
                {
                    templatesToReassign.Add(template);
                    logger.LogDebug("Шаблон {TemplateId} не имел даты — будет распределён.", template.Id);
                }
            }

            #endregion

            #region 10. Распределяем шаблоны, которые нужно переназначить, учитывая нагрузку

            var updatedTemplates = new List<TemplateNextRunResultDto>(templatesToKeep);

            foreach (var template in templatesToReassign)
            {
                var nextRunInTargetTz = FindNextAvailableDateWithLoad(currentDailyLoad, workDays, referenceDateInTargetTz, expectedDailyLoad, targetOffset);
                if (nextRunInTargetTz.HasValue)
                {
                    var day = DateOnly.FromDateTime(nextRunInTargetTz.Value.Date);
                    currentDailyLoad[day]++;

                    // КОНВЕРТИРУЕМ В UTC ПЕРЕД ВОЗВРАТОМ!
                    updatedTemplates.Add(new TemplateNextRunResultDto
                    (
                        Id: template.Id,
                        NextRun: nextRunInTargetTz.Value.ToOffset(TimeSpan.Zero), // ← В UTC!
                        NextRunOld: template.NextRun
                    ));

                    logger.LogDebug("Шаблону {Id} назначен NextRun: {nextRunTarget} (пояс {offset}) → {nextRunUtc} (UTC). NextRunOld: {NextRunOld}", template.Id, nextRunInTargetTz.Value, targetOffset, nextRunInTargetTz.Value.ToOffset(TimeSpan.Zero), template.NextRun);
                }
                else
                {
                    logger.LogWarning("Не удалось назначить дату для шаблона {TemplateId}", template.Id);

                    // Возвращаем со смещением на несколько лет, так как ошибка
                    // конвертируем в UTC
                    updatedTemplates.Add(FillTemplateResultWithOffsetError(template, _startDate, referenceDateInTargetTz, targetOffset));
                }
            }

            #endregion

            // 11. Сортируем и возвращаем результат в UTC

            var result = updatedTemplates.OrderBy(t => t.NextRun).ToList();

            logger.LogDebug("--- Результат распределения ---");
            foreach (var item in result)
                logger.LogDebug("Шаблон {templateId}, NextRun UTC: {NextRun}, NextRunOld UTC: {NextRunOld}", item.Id, item.NextRun, item.NextRunOld);

            logger.LogInformation("Распределение завершено. Возвращаем {Count} записей в UTC. Изменено: {changedCount}. Остались прежние значения: {oldCount}", result.Count, result.Count(t => t.NextRun != t.NextRunOld), result.Count(t => t.NextRun == t.NextRunOld));

            return result;
        }


        /// <summary>
        /// Обрабатывает случай, когда у шаблона нет текущего NextRun.
        /// </summary>
        private TemplateNextRunResultDto HandleNoNextRun(TemplateNextRunDto targetTemplate, List<DateOnly> workDays, Dictionary<DateOnly, int> currentDailyLoad, Dictionary<DateOnly, int> expectedDailyLoad, DateTimeOffset referenceDateInTargetTz, TimeSpan targetOffset, bool isNew)
        {
            logger.LogDebug("Обработка случая 'нет текущего NextRun' для шаблона {templateId} (isNew={isNew})", targetTemplate.Id, isNew);

            DateOnly? foundDay = null;

            if (isNew)
            {
                // Ищем от начала периода к концу
                logger.LogDebug("isNew=true: ищем от начала периода к концу");

                foreach (var day in workDays)
                {
                    if (currentDailyLoad[day] < expectedDailyLoad.GetValueOrDefault(day, 0))
                    {
                        foundDay = day;
                        logger.LogDebug("Нашли первый не перегруженный день: {day}", day);
                        break;
                    }
                }

                if (!foundDay.HasValue)
                {
                    // Не нашли свободного места — берём первый день периода
                    foundDay = workDays.First();
                    logger.LogWarning("Все дни перегружены. Берём первый день периода: {day}", foundDay.Value);
                }
            }
            else
            {
                // Ищем от конца периода к началу
                logger.LogDebug("isNew=false: ищем от конца периода к началу");

                foreach (var day in workDays.AsEnumerable().Reverse())
                {
                    if (currentDailyLoad[day] < expectedDailyLoad.GetValueOrDefault(day, 0))
                    {
                        foundDay = day;
                        logger.LogDebug("Нашли первый не перегруженный день: {day}", day);
                        break;
                    }
                }

                if (!foundDay.HasValue)
                {
                    // Не нашли свободного места — берём последний день периода
                    foundDay = workDays.Last();
                    logger.LogWarning("Все дни перегружены. Берём последний день периода: {day}", foundDay.Value);
                }
            }

            // Формируем результат
            var nextRunInTargetTz = new DateTimeOffset(
                                                foundDay.Value.Year, foundDay.Value.Month, foundDay.Value.Day,
                                                referenceDateInTargetTz.Hour,
                                                referenceDateInTargetTz.Minute,
                                                referenceDateInTargetTz.Second,
                                                targetOffset);



            // Корректируем найденный день, чтобы момент времени был в будущем
            DateTimeOffset? adjustedNextRun;
            TemplateNextRunResultDto? errorResult = null;

            adjustedNextRun = AdjustNextRunToFuture(
                foundDay.Value,
                workDays,
                currentDailyLoad,
                expectedDailyLoad,
                referenceDateInTargetTz,
                targetOffset,
                workDays.First(), // startDateForError для случая ошибки
                targetTemplate,
                out errorResult);

            if (errorResult != null)
                return errorResult;

            //var nextRunUtc = nextRunInTargetTz.ToOffset(TimeSpan.Zero);
            var nextRunUtc = adjustedNextRun.Value.ToOffset(TimeSpan.Zero);

            logger.LogInformation("Найдено новое место для шаблона {templateId}: {nextRunTarget} (пояс {offset}) → {nextRunUtc} (UTC)", targetTemplate.Id, nextRunInTargetTz, targetOffset, nextRunUtc);

            return new TemplateNextRunResultDto(
                                    Id: targetTemplate.Id,
                                    NextRun: nextRunUtc,
                                    NextRunOld: targetTemplate.NextRun);
        }


        /// <summary>
        /// Обрабатывает случай, когда текущий NextRun неактуален.
        /// </summary>
        private TemplateNextRunResultDto HandleOutdatedNextRun(TemplateNextRunDto targetTemplate, DateOnly nextRunDate, bool isInPeriod, bool isWorkDay, bool isNew, List<DateOnly> workDays, Dictionary<DateOnly, int> currentDailyLoad, Dictionary<DateOnly, int> expectedDailyLoad, DateTimeOffset referenceDateInTargetTz, TimeSpan targetOffset, DateOnly periodStart, DateOnly periodEnd)
        {
            logger.LogDebug("Обработка случая 'неактуальный NextRun' для шаблона {templateId}", targetTemplate.Id);

            DateOnly? foundDay = null;

            if (isInPeriod && !isWorkDay)
            {
                // СЦЕНАРИЙ А: В периоде, но нерабочий день
                logger.LogDebug("Сценарий А: в периоде ({date}), но нерабочий день. Ищем слева...", nextRunDate);

                // Вычисляем максимальную нагрузку по всему периоду
                var maxLoadInPeriod = expectedDailyLoad.Values.Max();
                logger.LogDebug("Максимальная нагрузка по периоду: {maxLoad}", maxLoadInPeriod);

                // Берём все рабочие дни СТРОГО ЛЕВЕЕ исходной даты
                var leftDays = workDays
                                    .Where(d => d < nextRunDate)
                                    .OrderByDescending(d => d) // Ближайший к исходной дате — первый
                                    .ToList();

                if (leftDays.Any())
                {
                    logger.LogDebug("Слева найдено {count} рабочих дней. Ищем первый не перегруженный...", leftDays.Count);

                    // Ищем первый день где текущая_нагрузка < максимальная_нагрузка_периода
                    foreach (var day in leftDays)
                    {
                        if (currentDailyLoad[day] < maxLoadInPeriod) // ← КЛЮЧЕВОЕ ИЗМЕНЕНИЕ
                        {
                            foundDay = day;
                            logger.LogDebug("Нашли слева день с допустимой нагрузкой (< {maxLoad}): {day}", maxLoadInPeriod, day);
                            break;
                        }
                    }

                    //// Ищем первый не перегруженный
                    //foreach (var day in leftDays)
                    //{
                    //    if (currentDailyLoad[day] < expectedDailyLoad.GetValueOrDefault(day, 0))
                    //    {
                    //        foundDay = day;
                    //        logger.LogDebug("Нашли слева не перегруженный день: {day}", day);
                    //        break;
                    //    }
                    //}

                    // Если не нашли — берём ближайший слева
                    if (!foundDay.HasValue)
                    {
                        foundDay = leftDays.First();
                        logger.LogWarning("Все дни слева перегружены. Берём ближайший: {day}", foundDay.Value);
                    }
                }
                else
                {
                    // Слева нет рабочих дней — берём ближайший справа
                    var rightDays = workDays
                                        .Where(d => d > nextRunDate)
                                        .OrderBy(d => d) // Ближайший к исходной дате — первый
                                        .ToList();

                    if (rightDays.Any())
                    {
                        foundDay = rightDays.First();
                        logger.LogDebug("Слева нет рабочих дней. Берём ближайший справа: {day}", foundDay.Value);
                    }
                    else
                    {
                        // Совсем нет рабочих дней — ошибка
                        logger.LogError("Нет рабочих дней ни слева, ни справа от {date}. Возвращаем ошибку.", nextRunDate);
                        return FillTemplateResultWithOffsetError(targetTemplate, periodStart, referenceDateInTargetTz, targetOffset);
                    }
                }
            }
            else if (!isInPeriod)
            {
                // СЦЕНАРИЙ Б: Не в периоде
                logger.LogDebug("Сценарий Б: не в периоде ({date}). Ищем в зависимости от isNew...", nextRunDate);

                if (isNew)
                {
                    // Ищем от начала периода к концу (обычный план)
                    logger.LogDebug("isNew=true: ищем от начала периода к концу");

                    foreach (var day in workDays)
                    {
                        if (currentDailyLoad[day] < expectedDailyLoad.GetValueOrDefault(day, 0))
                        {
                            foundDay = day;
                            logger.LogDebug("Нашли первый не перегруженный день: {day}", day);
                            break;
                        }
                    }

                    if (!foundDay.HasValue)
                    {
                        foundDay = workDays.First();
                        logger.LogWarning("Все дни перегружены. Берём первый день периода: {day}", foundDay.Value);
                    }
                }
                else
                {
                    // Ищем от конца периода к началу (зеркальный план)
                    logger.LogDebug("isNew=false: ищем от конца периода к началу");

                    foreach (var day in workDays.AsEnumerable().Reverse())
                    {
                        if (currentDailyLoad[day] < expectedDailyLoad.GetValueOrDefault(day, 0))
                        {
                            foundDay = day;
                            logger.LogDebug("Нашли первый не перегруженный день: {day}", day);
                            break;
                        }
                    }

                    if (!foundDay.HasValue)
                    {
                        foundDay = workDays.Last();
                        logger.LogWarning("Все дни перегружены. Берём последний день периода: {day}", foundDay.Value);
                    }
                }
            }
            else
            {
                // Другие случаи (например, время уже прошло)
                logger.LogDebug("NextRun неактуален по другим причинам. Используем логику в зависимости от isNew...");

                if (isNew)
                {
                    foreach (var day in workDays)
                    {
                        if (currentDailyLoad[day] < expectedDailyLoad.GetValueOrDefault(day, 0))
                        {
                            foundDay = day;
                            break;
                        }
                    }
                    foundDay ??= workDays.First();
                }
                else
                {
                    foreach (var day in workDays.AsEnumerable().Reverse())
                    {
                        if (currentDailyLoad[day] < expectedDailyLoad.GetValueOrDefault(day, 0))
                        {
                            foundDay = day;
                            break;
                        }
                    }
                    foundDay ??= workDays.Last();
                }
            }

            // Формируем результат
            var nextRunInTargetTz = new DateTimeOffset(
                                            foundDay.Value.Year, foundDay.Value.Month, foundDay.Value.Day,
                                            referenceDateInTargetTz.Hour,
                                            referenceDateInTargetTz.Minute,
                                            referenceDateInTargetTz.Second,
                                            targetOffset);

            // Корректируем найденный день, чтобы момент времени был в будущем
            DateTimeOffset? adjustedNextRun;
            TemplateNextRunResultDto? errorResult = null;

            adjustedNextRun = AdjustNextRunToFuture(
                foundDay.Value,
                workDays,
                currentDailyLoad,
                expectedDailyLoad,
                referenceDateInTargetTz,
                targetOffset,
                periodStart, // startDateForError для случая ошибки
                targetTemplate,
                out errorResult);

            if (errorResult != null)
                return errorResult;


            //var nextRunUtc = nextRunInTargetTz.ToOffset(TimeSpan.Zero);
            var nextRunUtc = adjustedNextRun.Value.ToOffset(TimeSpan.Zero);

            logger.LogInformation("Найдено новое место для шаблона {templateId}: {nextRunTarget} (пояс {offset}) → {nextRunUtc} (UTC). NextRunOld: {nextRunOld}", targetTemplate.Id, nextRunInTargetTz, targetOffset, nextRunUtc, targetTemplate.NextRun);

            return new TemplateNextRunResultDto(
                                Id: targetTemplate.Id,
                                NextRun: nextRunUtc,
                                NextRunOld: targetTemplate.NextRun);
        }


        /// <summary>
        /// Корректирует найденный день, чтобы момент времени был в будущем.
        /// Если момент времени уже прошёл, ищет следующий рабочий день в будущем с учётом нагрузки.
        /// В случае ошибки (нет будущих рабочих дней) возвращает ошибку через out-параметр.
        /// </summary>
        private DateTimeOffset? AdjustNextRunToFuture(DateOnly foundDay, List<DateOnly> workDays, Dictionary<DateOnly, int> currentDailyLoad, Dictionary<DateOnly, int> expectedDailyLoad, DateTimeOffset referenceDateInTargetTz, TimeSpan targetOffset, DateOnly startDateForError, TemplateNextRunDto targetTemplate, out TemplateNextRunResultDto? errorResult)
        {
            errorResult = null;

            // Создаём момент времени для найденного дня
            var nextRunInTargetTz = new DateTimeOffset(
                foundDay.Year, foundDay.Month, foundDay.Day,
                referenceDateInTargetTz.Hour,
                referenceDateInTargetTz.Minute,
                referenceDateInTargetTz.Second,
                targetOffset);

            // ФИНАЛЬНАЯ ПРОВЕРКА: момент времени должен быть в будущем
            if (nextRunInTargetTz < DateTimeOffset.UtcNow)
            {
                logger.LogWarning("Найденный момент времени {nextRun} уже прошёл (сейчас {now}). Ищем следующий рабочий день в будущем.",
                    nextRunInTargetTz, DateTimeOffset.UtcNow);

                // Берём все рабочие дни СТРОГО ПОСЛЕ найденного дня
                var futureWorkDays = workDays.Where(d => d > foundDay).ToList();

                if (futureWorkDays.Any())
                {
                    // Ищем первый день с допустимой нагрузкой (текущая < ожидаемая)
                    var notOverloadedDays = futureWorkDays
                        .Where(d => currentDailyLoad[d] < expectedDailyLoad.GetValueOrDefault(d, 0))
                        .ToList();

                    var futureDay = notOverloadedDays.Any()
                        ? notOverloadedDays.First()
                        : futureWorkDays.First();

                    logger.LogDebug("Выбран следующий рабочий день в будущем: {day}", futureDay);

                    // Пересоздаём момент времени с новой датой
                    nextRunInTargetTz = new DateTimeOffset(
                        futureDay.Year, futureDay.Month, futureDay.Day,
                        referenceDateInTargetTz.Hour,
                        referenceDateInTargetTz.Minute,
                        referenceDateInTargetTz.Second,
                        targetOffset);
                }
                else
                {
                    // Нет будущих рабочих дней — ошибка
                    logger.LogError("Нет будущих рабочих дней после {date} в периоде. Возвращаем ошибку со смещением.",
                        foundDay);

                    errorResult = FillTemplateResultWithOffsetError(targetTemplate, startDateForError, referenceDateInTargetTz, targetOffset);
                    return null;
                }
            }
            else
            {
                logger.LogDebug("Момент времени {nextRun} актуален (в будущем). Коррекция не требуется.", nextRunInTargetTz);
            }

            return nextRunInTargetTz;
        }


        /// <summary>
        /// Строит текущую нагрузку на дни, учитывая ТОЛЬКО шаблоны внутри периода.
        /// Шаблоны вне периода игнорируются.
        /// </summary>
        private Dictionary<DateOnly, int> BuildCurrentLoad(List<TemplateNextRunDto> templates, List<DateOnly> workDays, DateOnly periodStart, DateOnly periodEnd, TimeSpan targetOffset)
        {
            var load = workDays.ToDictionary(day => day, _ => 0);

            foreach (var template in templates)
            {
                if (!template.NextRun.HasValue)
                    continue;

                // Конвертируем в целевой пояс для определения даты
                var templateDate = DateOnly.FromDateTime(template.NextRun.Value.ToOffset(targetOffset).Date);

                // Учитываем ТОЛЬКО шаблоны внутри периода
                if (templateDate >= periodStart && templateDate <= periodEnd)
                {
                    if (load.ContainsKey(templateDate))
                        load[templateDate]++;
                }
            }

            return load;
        }


        /// <summary>
        /// Заполнить TemplateNextRunResultDto, если нет рабочих дней со смещением несколько лет
        /// </summary>
        /// <param name="template"></param>
        /// <returns></returns>
        private TemplateNextRunResultDto FillTemplateResultWithOffsetError(TemplateNextRunDto template, DateOnly startDate, DateTimeOffset referenceDateInTargetTz, TimeSpan targetOffset)
        {
            // Создаём дату в целевом поясе
            var errorDateInTargetTz = new DateTimeOffset(
                startDate.AddYears(offsetYearsIfErrorCalcNextRun).Year,
                startDate.AddYears(offsetYearsIfErrorCalcNextRun).Month,
                startDate.AddYears(offsetYearsIfErrorCalcNextRun).Day,
                referenceDateInTargetTz.Hour,
                referenceDateInTargetTz.Minute,
                referenceDateInTargetTz.Second,
                targetOffset);

            // КОНВЕРТИРУЕМ В UTC ДЛЯ ВОЗВРАТА
            var errorDateUtc = errorDateInTargetTz.ToOffset(TimeSpan.Zero);

            logger.LogWarning("Шаблон {Id}: нет рабочих дней в периоде, сдвиг на {years} лет → {nextRun} (UTC)", template.Id, offsetYearsIfErrorCalcNextRun, errorDateUtc);

            return new TemplateNextRunResultDto(
                    Id: template.Id,
                    NextRun: errorDateUtc,
                    NextRunOld: template.NextRun
                );
        }


        /// <summary>
        /// Находит следующий день с доступной нагрузкой, учитывая expectedDailyLoad
        /// </summary>
        /// <param name="currentDailyLoad"></param>
        /// <param name="workDays"></param>
        /// <param name="referenceDate"></param>
        /// <param name="expectedDailyLoad"></param>
        /// <returns></returns>
        private DateTimeOffset? FindNextAvailableDateWithLoad(Dictionary<DateOnly, int> currentDailyLoad, List<DateOnly> workDays, DateTimeOffset referenceDateInTargetTz, Dictionary<DateOnly, int> expectedDailyLoad, TimeSpan targetOffset)
        {
            foreach (var day in workDays)
            {
                var expected = expectedDailyLoad.GetValueOrDefault(day, 0);
                var current = currentDailyLoad.GetValueOrDefault(day, 0);

                if (current < expected)
                {
                    // Создаём момент времени В ЦЕЛЕВОМ ПОЯСЕ
                    return new DateTimeOffset(
                                        day.Year, day.Month, day.Day,
                                        referenceDateInTargetTz.Hour,
                                        referenceDateInTargetTz.Minute,
                                        referenceDateInTargetTz.Second,
                                        targetOffset);
                }
            }

            // Если все дни загружены — берём день с минимальной нагрузкой
            var minDay = currentDailyLoad.MinBy(x => x.Value).Key;
            return new DateTimeOffset(
                            minDay.Year, minDay.Month, minDay.Day,
                            referenceDateInTargetTz.Hour,
                            referenceDateInTargetTz.Minute,
                            referenceDateInTargetTz.Second,
                            targetOffset);
        }


        /// <summary>
        /// Получить план распределения шаблонов по рабочим дням.
        /// </summary>
        /// <param name="totalWorks">Общее количество шаблонов для распределения</param>
        /// <param name="workDays">Список рабочих дней в периоде</param>
        /// <param name="mirror">Если true — строит зеркальный план (справа налево от конца периода), иначе обычный (слева направо от начала периода)</param>
        /// <returns>Список дат, на которые должны быть назначены шаблоны</returns>
        private List<DateOnly> GetDistributionPlan(int totalWorks, List<DateOnly> workDays, bool mirror = false)
        {
            var totalDays = workDays.Count;
            var interval = CalculateDistributionInterval(totalDays, totalWorks);

            var plan = new List<DateOnly>();

            for (int i = 0; i < totalWorks; i++)
            {
                // Базовый индекс для обычного плана (слева → направо)
                var baseIndex = (int)Math.Floor(i * interval);

                // Применяем зеркалирование, если нужно
                var index = mirror
                    ? totalDays - 1 - baseIndex  // Зеркальный индекс: от конца периода
                    : baseIndex;                 // Обычный индекс: от начала периода

                // Защита от выхода за границы массива
                index = Math.Max(0, Math.Min(index, totalDays - 1));

                plan.Add(workDays[index]);
            }

            // Логгирование
            var planType = mirror ? "Зеркальный" : "Обычный";
            logger.LogDebug("--- {planType} план распределения ({totalWorks} шаблонов, {totalDays} раб. дней) ---", planType, totalWorks, totalDays);

            foreach (var item in plan.GroupBy(t => t).OrderBy(g => g.Key))
                logger.LogDebug("Дата: {date}, кол-во работ: {workCount}", item.Key, item.Count());

            return plan;
        }


        /// <summary>
        /// Рассчитать интервал между шаблонами
        /// </summary>
        /// <param name="totalDays">Кол-во рабочих дней</param>
        /// <param name="totalWorks">Кол-во шаблонов</param>
        /// <returns></returns>
        private double CalculateDistributionInterval(int totalDays, int totalWorks)
        {
            var interval = (double)totalDays / totalWorks;

            logger.LogDebug("Интервал распределения: {interval} (дней на шаблон)", interval);

            return interval;
        }


        /// <summary>
        /// Получить дату начала распределения с учётом целевого часового пояса.
        /// Метод возвращает календарную дату (DateOnly), рассчитанную в контексте указанного оффсета.
        /// </summary>
        /// <param name="startDate">Стартовая дата (интерпретируется в целевом часовом поясе)</param>
        /// <param name="referenceDate">Момент времени в целевом часовом поясе (после применения оффсета)</param>
        /// <param name="offset">Целевой часовой пояс (оффсет)</param>
        /// <returns>Дата начала распределения</returns>
        private DateOnly GetStartPeriodDate(DateOnly startDate, DateTimeOffset referenceDate, TimeSpan offset)
        {
            var dateStart = startDate;

            // 1. Дата начала не может быть раньше даты из referenceDate (в целевом поясе)
            var refDateInTargetTz = DateOnly.FromDateTime(referenceDate.Date);
            if (dateStart < refDateInTargetTz)
            {
                logger.LogDebug("Дата начала {startDate} раньше даты из referenceDate в поясе {offset} ({refDate}). Используем {refDate}.",
                    dateStart, offset, refDateInTargetTz, refDateInTargetTz);
                dateStart = refDateInTargetTz;
            }

            // 2. Дата начала не может быть раньше "сегодня" в целевом часовом поясе
            var todayInTargetTz = DateOnly.FromDateTime(DateTimeOffset.UtcNow.ToOffset(offset).Date);
            if (dateStart < todayInTargetTz)
            {
                logger.LogDebug("Дата начала {startDate} раньше 'сегодня' в поясе {offset} ({today}). Используем {today}.",
                    dateStart, offset, todayInTargetTz, todayInTargetTz);
                dateStart = todayInTargetTz;
            }

            // 3. Если момент времени "начало дня в целевом поясе + время из referenceDate" уже прошёл — добавляем 1 день
            // ВАЖНО: время берём из самого referenceDate (который уже в целевом поясе!)
            var dateTimeStart = new DateTimeOffset(
                dateStart.Year, dateStart.Month, dateStart.Day,
                referenceDate.Hour,        // ← Время из целевого пояса!
                referenceDate.Minute,
                referenceDate.Second,
                offset);                   // ← Оффсет целевого пояса

            // Сравниваем абсолютные моменты времени (работает корректно даже с разными оффсетами)
            if (dateTimeStart < DateTimeOffset.UtcNow)
            {
                logger.LogDebug("Момент времени {dateTimeStart} (в поясе {offset}) уже прошёл (сейчас {now}). Добавляем 1 день.",
                    dateTimeStart, offset, DateTimeOffset.UtcNow);
                dateStart = dateStart.AddDays(1);
            }

            logger.LogDebug("Итоговая дата начала распределения в поясе {offset}: {dateStart}", offset, dateStart);
            return dateStart;
        }


        /// <summary>
        /// Получить дату окончания периода распределения.
        /// Продолжительность включает стартовый день (например, duration=7 означает 7 дней: с 1 по 7 июня).
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="duration"></param>
        /// <returns></returns>
        private DateOnly GetEndPeriodDate(DateOnly startDate, int duration)
        {
            if (duration <= 0)
            {
                logger.LogWarning("Некорректная продолжительность периода: {duration}. Используем минимальное значение 1.", duration);
                duration = 1;
            }

            // duration — количество дней, включая startDate
            // поэтому вычитаем 1, чтобы получить сдвиг

            var endDate = startDate.AddDays(duration - 1);
            logger.LogDebug("Расчёт даты окончания периода: startDate={startDate}, duration={duration}, endDate={endDate}", startDate, duration, endDate);

            return endDate;
        }


        /// <summary>
        /// Получить список выходных дней
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <returns></returns>
        public async Task<HashSet<DateOnly>> GetWeekendsAsync(DateOnly startDate, DateOnly endDate)
        {
            //Возвращает все выходные дни включая сб и вск, и праздники
            var weekends = await weekendDayService.GetWeekends(startDate, endDate).ToListAsync();

            logger.LogDebug("Найдено не рабочих дней: {Count}", weekends.Count);
            foreach (var weekend in weekends)
                logger.LogDebug("Не рабочий день: {weekend}", weekend);

            return weekends.ToHashSet();
        }


        /// <summary>
        /// Получить список рабочих дней в диапазоне, исключая выходные и праздники.
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="excludeWeekends">Исключить выходные и праздники</param>
        /// <returns></returns>
        private async Task<List<DateOnly>> GetWorkDaysAsync(DateOnly start, DateOnly end, bool excludeWeekends)
        {
            // Получаем список выходных/праздничных дней
            var weekends = new HashSet<DateOnly>();
            if (excludeWeekends)
                weekends = await GetWeekendsAsync(start, end);

            var result = new List<DateOnly>();
            var date = start;

            while (date <= end)
            {
                var dayOfWeek = date.DayOfWeek;
                if (!weekends.Contains(date))
                {
                    result.Add(date);
                }
                date = date.AddDays(1);
            }

            logger.LogDebug("Найдено рабочих дней: {Count}", result.Count);
            foreach (var workDay in result)
                logger.LogDebug("Рабочий день: {workDay}", workDay);

            return result;
        }


        /// <summary>
        /// Получает рабочие дни с автоматическим расширением периода при их отсутствии.
        /// Расширяет период до maxPeriodExpansions раз: _startDate + duration * N (N = 1, 2, 3)
        /// </summary>
        private async Task<(DateOnly endDate, List<DateOnly> workDays)> GetWorkDaysWithExpansionAsync(DateOnly startDate, int duration, bool excludeWeekends)
        {
            // Попытка 0: исходный период [_startDate, _startDate + duration - 1]
            var currentEndDate = startDate.AddDays(duration - 1);
            var workDays = await GetWorkDaysAsync(startDate, currentEndDate, excludeWeekends);

            if (workDays.Count > 0)
            {
                logger.LogDebug("Найдено {count} рабочих дней в исходном периоде [{start}, {end}]", workDays.Count, startDate, currentEndDate);
                return (currentEndDate, workDays);
            }

            // Попытки расширения 1..maxPeriodExpansions
            for (int attempt = 1; attempt <= maxPeriodExpansions; attempt++)
            {
                //расширяем период относительно ПРЕДЫДУЩЕГО конца
                currentEndDate = currentEndDate.AddDays(duration);

                logger.LogWarning("Попытка {attempt}/{maxAttempts} расширения периода: нет рабочих дней в [{start}, {end}]. Расширяем до {newEnd}.", attempt, maxPeriodExpansions, startDate, startDate.AddDays(duration - 1), currentEndDate);

                workDays = await GetWorkDaysAsync(startDate, currentEndDate, excludeWeekends);

                if (workDays.Count > 0)
                {
                    logger.LogInformation("Рабочие дни найдены после {attempt} попытки расширения. Период: [{start}, {end}], кол-во рабочих дней: {count}", attempt, startDate, currentEndDate, workDays.Count);
                    return (currentEndDate, workDays);
                }
            }

            // Все попытки исчерпаны — рабочих дней нет
            logger.LogError("После {maxAttempts} попыток расширения рабочие дни не найдены в периоде [{start}, {end}]. Возвращаем ошибку.", maxPeriodExpansions, startDate, currentEndDate);

            return (currentEndDate, new List<DateOnly>()); // Пустой список для обработки ошибки вызывающим кодом
        }
    }
}