using Deal.Modules.Discovery.Application.Abstractions;
using Deal.Modules.Discovery.Application.Exceptions;
using Deal.Modules.Discovery.Application.Extensions;
using Deal.Modules.Discovery.Application.Models;
using Deal.Modules.Settings.Application.Abstractions;
using Deal.Modules.Settings.Application.Models;

namespace Deal.Modules.Discovery.Application.Services;

/// <summary>
/// Сервис задач поиска Discovery — create/patch/delete/start/pause/advance/bump.
/// </summary>
public sealed class DiscoveryTasksService(IDiscoveryStore store, DiscoveryPlanGuard planGuard, ISettingsStore settings)
{
    /// <summary>
    /// 400 create: пустое название после Trim.
    /// </summary>
    public const string NameRequiredDetail = "Укажите название задачи";

    /// <summary>
    /// 400 start: у задачи нет ключевых слов.
    /// </summary>
    public const string NoKeywordsDetail = "Нет ключевых слов для поиска — добавьте их в задачу";

    /// <summary>
    /// Все задачи, старые первыми.
    /// </summary>
    /// <returns>Задачи в порядке создания.</returns>
    public Task<IReadOnlyList<DiscoveryTaskDto>> ListAsync(CancellationToken ct)
    {
        return store.ListTasksAsync(ct);
    }

    /// <summary>
    /// Одна задача по id.
    /// </summary>
    /// <param name="taskId">Id задачи (<c>dt_...</c>).</param>
    /// <returns>Задача или null (404 «Задача не найдена» у эндпоинта).</returns>
    public Task<DiscoveryTaskDto?> GetAsync(string taskId, CancellationToken ct)
    {
        return store.GetTaskAsync(taskId, ct);
    }

    /// <summary>
    /// Создаёт задачу поиска.
    /// </summary>
    /// <param name="draft">Поля новой задачи (см. <see cref="DiscoveryTaskDraft"/>).</param>
    /// <returns>Созданная задача (полный DTO).</returns>
    /// <exception cref="DiscoveryValidationException">Пустое имя / план вне 1..discJoinLimit / бюджет исчерпан.</exception>
    public async Task<DiscoveryTaskDto> CreateAsync(DiscoveryTaskDraft draft, CancellationToken ct)
    {
        string name = (draft.Name ?? string.Empty).Trim();
        if (name.Length == 0)
        {
            throw new DiscoveryValidationException(NameRequiredDetail);
        }

        int planJoins = draft.PlanJoins ?? 1;
        await planGuard.AssertPlanAsync(planJoins, ct).ConfigureAwait(false);
        await planGuard.AssertBudgetAsync(planJoins, excludeTaskId: null, ct).ConfigureAwait(false);

        string lang = draft.Lang is "ru" or "any" ? draft.Lang : "ru";

        // Дефолты threshold/sampleSize — из типизированного снимка настроек (C30: один GetAllAsync на создание).
        TenantSettingsSnapshot settingsSnapshot = await TenantSettingsSnapshot.LoadAsync(settings, ct);
        int threshold = Clamp(
            settingsSnapshot.GetInt(SettingsKeys.DiscEvalThreshold, SettingsDefaults.DiscEvalThreshold),
            min: 1, max: 100);
        int sampleSize = Math.Max(1,
            settingsSnapshot.GetInt(SettingsKeys.DiscEvalSample, SettingsDefaults.DiscEvalSample));
        if (draft.Threshold is int requestedThreshold)
        {
            threshold = Clamp(requestedThreshold, min: 1, max: 100);
        }

        if (draft.SampleSize is int requestedSample)
        {
            sampleSize = Math.Max(1, requestedSample);
        }

        var row = new DiscoveryTaskRow
        {
            Id = DiscoveryIdPrefixes.NewTaskId(),
            Name = name,
            Description = draft.Description ?? string.Empty,
            Keywords = CleanKeywords(draft.Keywords),
            MinSubscribers = Math.Max(0, draft.MinSubscribers ?? 0),
            Lang = lang,
            Threshold = threshold,
            SampleSize = sampleSize,
            PlanJoins = planJoins,
            AutoJoin = draft.AutoJoin ?? false,
        };
        await store.CreateTaskAsync(row, ct).ConfigureAwait(false);
        DiscoveryTaskDto created = await store.GetTaskAsync(row.Id, ct).ConfigureAwait(false)
            ?? throw new InvalidOperationException("create_task: строка не прочиталась после INSERT");
        return created;
    }

    /// <summary>
    /// Обновляет поля задачи.
    /// </summary>
    /// <param name="taskId">Id задачи (<c>dt_...</c>).</param>
    /// <param name="patch">Изменяемые поля (null — не меняется).</param>
    /// <returns>Обновлённая задача либо null (404 «Задача не найдена»).</returns>
    /// <exception cref="DiscoveryValidationException">Новый план вне границ / бюджет исчерпан.</exception>
    public async Task<DiscoveryTaskDto?> PatchAsync(
        string taskId,
        DiscoveryTaskPatch patch,
        CancellationToken ct)
    {
        DiscoveryTaskDto? current = await store.GetTaskAsync(taskId, ct).ConfigureAwait(false);
        if (current is null)
        {
            return null;
        }

        DiscoveryTaskPatch normalized = NormalizeTaskPatch(patch);
        if (normalized.PlanJoins is int newPlan)
        {
            await planGuard.AssertPlanAsync(newPlan, ct).ConfigureAwait(false);
            if (newPlan > current.PlanJoins)
            {
                await planGuard.AssertBudgetAsync(newPlan, excludeTaskId: taskId, ct).ConfigureAwait(false);
            }
        }

        if (!normalized.HasChanges())
        {
            return current;
        }

        await store.PatchTaskAsync(taskId, normalized, ct).ConfigureAwait(false);
        return await store.GetTaskAsync(taskId, ct).ConfigureAwait(false);
    }

    /// <summary>
    /// Удаляет задачу вместе с кандидатами и логом.
    /// </summary>
    /// <param name="taskId">Id задачи (<c>dt_...</c>).</param>
    /// <returns>True — задача удалена; false — строки нет (404 у эндпоинта).</returns>
    public async Task<bool> DeleteAsync(string taskId, CancellationToken ct)
    {
        DiscoveryTaskDto? current = await store.GetTaskAsync(taskId, ct).ConfigureAwait(false);
        if (current is null)
        {
            return false;
        }

        return await store.DeleteTaskAsync(taskId, ct).ConfigureAwait(false);
    }

    /// <summary>
    /// Запускает поиск
    /// </summary>
    /// <param name="taskId">Id задачи (<c>dt_...</c>).</param>
    /// <returns>Задача в running либо null (404).</returns>
    /// <exception cref="DiscoveryValidationException">Ключевых слов нет.</exception>
    public async Task<DiscoveryTaskDto?> StartAsync(string taskId, CancellationToken ct)
    {
        DiscoveryTaskDto? current = await store.GetTaskAsync(taskId, ct).ConfigureAwait(false);
        if (current is null)
        {
            return null;
        }

        if (current.Keywords.Count == 0)
        {
            throw new DiscoveryValidationException(NoKeywordsDetail);
        }

        bool resetProgress = DiscoveryTaskStatuses.IsFinished(current.Status);
        await store.SetTaskRunningAsync(taskId, resetProgress, ct).ConfigureAwait(false);
        return await store.GetTaskAsync(taskId, ct).ConfigureAwait(false);
    }

    /// <summary>
    /// Ставит задачу на паузу.
    /// </summary>
    /// <param name="taskId">Id задачи (<c>dt_...</c>).</param>
    /// <returns>Задача в paused либо null (404).</returns>
    public async Task<DiscoveryTaskDto?> PauseAsync(string taskId, CancellationToken ct)
    {
        DiscoveryTaskDto? current = await store.GetTaskAsync(taskId, ct).ConfigureAwait(false);
        if (current is null)
        {
            return null;
        }

        await store.SetTaskPausedAsync(taskId, ct).ConfigureAwait(false);
        return await store.GetTaskAsync(taskId, ct).ConfigureAwait(false);
    }

    /// <summary>
    /// Увеличивает счётчик прогресса задачи
    /// </summary>
    /// <param name="taskId">Id задачи (<c>dt_...</c>).</param>
    /// <param name="field">Счётчик (found/evaluated/joined/rejected).</param>
    /// <param name="n">Приращение (по умолчанию 1).</param>
    /// <returns>True — счётчик увеличен; false — задачи нет.</returns>
    public Task<bool> BumpCounterAsync(
        string taskId,
        DiscoveryCounterField field,
        int n,
        CancellationToken ct)
    {
        return store.BumpTaskCounterAsync(taskId, field, Math.Max(0, n), ct);
    }

    /// <summary>
    /// Продвигает индекс поиска
    /// </summary>
    /// <param name="taskId">Id задачи (<c>dt_...</c>).</param>
    /// <returns>True — задача обновлена; false — строки нет.</returns>
    public async Task<bool> AdvanceSearchAsync(string taskId, CancellationToken ct)
    {
        DiscoveryTaskDto? current = await store.GetTaskAsync(taskId, ct).ConfigureAwait(false);
        if (current is null)
        {
            return false;
        }

        int nextIndex = current.SearchIdx + 1;
        bool searchDone = nextIndex >= current.Keywords.Count;
        return await store.AdvanceSearchAsync(taskId, nextIndex, searchDone, ct).ConfigureAwait(false);
    }

    private static DiscoveryTaskPatch NormalizeTaskPatch(DiscoveryTaskPatch patch)
    {
        int? threshold = patch.Threshold is int value ? Clamp(value, min: 1, max: 100) : null;
        int? sampleSize = patch.SampleSize is int sample ? Math.Max(1, sample) : null;
        int? minSubscribers = patch.MinSubscribers is int min ? Math.Max(0, min) : null;
        string? lang = patch.Lang is "ru" or "any" ? patch.Lang : patch.Lang is null ? null : "ru";
        string? name = patch.Name is null ? null : patch.Name.Trim();
        string? description = patch.Description;
        return new DiscoveryTaskPatch
        {
            Name = name,
            Description = description,
            Keywords = patch.Keywords is null ? null : CleanKeywords(patch.Keywords),
            MinSubscribers = minSubscribers,
            Lang = lang,
            Threshold = threshold,
            SampleSize = sampleSize,
            PlanJoins = patch.PlanJoins,
            AutoJoin = patch.AutoJoin,
        };
    }

    private static IReadOnlyList<string> CleanKeywords(IReadOnlyList<string>? keywords)
    {
        return keywords?.Where(keyword => !string.IsNullOrWhiteSpace(keyword))
            .Select(keyword => keyword.Trim())
            .ToList() ?? new List<string>();
    }

    private static int Clamp(
        int value,
        int min,
        int max)
    {
        return Math.Max(min, Math.Min(max, value));
    }
}