{
  "Telegram": {
    "BotToken": "1234567890:AAFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "MaxMessagesPerSecond": 25
  },
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=notifyapp;Username=postgres;Password=secret"
  }
}

using Telegram.Bot;
using Telegram.Bot.Types.Enums;

namespace NotifyApp.Services;

public interface ITelegramNotificationService
{
    // Надіслати повідомлення одному користувачу
    Task SendMessageAsync(long chatId, string text, bool useMarkdown = false);

    // Масова розсилка — Hangfire-точка входу для кожного батчу
    Task SendBatchAsync(long[] chatIds, string text, string? markdownText = null);
}

public class TelegramNotificationService : ITelegramNotificationService
{
    private readonly ITelegramBotClient _bot;
    private readonly ILogger<TelegramNotificationService> _logger;

    public TelegramNotificationService(
        ITelegramBotClient bot,
        ILogger<TelegramNotificationService> logger)
    {
        _bot = bot;
        _logger = logger;
    }

    [AutomaticRetry(Attempts = 5, DelaysInSeconds = new[] { 5, 15, 30, 60, 120 })]
    public async Task SendMessageAsync(long chatId, string text, bool useMarkdown = false)
    {
        try
        {
            await _bot.SendMessage(
                chatId: chatId,
                text: text,
                parseMode: useMarkdown ? ParseMode.MarkdownV2 : null);

            _logger.LogDebug("Telegram message sent to {ChatId}", chatId);
        }
        catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            when (ex.ErrorCode == 403)
        {
            // 403 Forbidden: користувач заблокував бота або видалив акаунт
            // Такі помилки не потрібно повторювати — одразу помічаємо як неактивного
            _logger.LogWarning(
                "User {ChatId} blocked the bot or deleted account. Marking as inactive.",
                chatId);

            // НЕ перекидаємо — щоб Hangfire не ставив у retry
            // Замість цього — сигналізуємо через return або тихо ігноруємо
        }
        catch (Telegram.Bot.Exceptions.ApiRequestException ex)
            when (ex.ErrorCode == 429)
        {
            // 429 Too Many Requests — Telegram каже "зачекайте"
            // Отримуємо рекомендований час очікування
            var retryAfter = ex.Parameters?.RetryAfter ?? 30;
            _logger.LogWarning(
                "Telegram rate limit hit. Retry after {Seconds}s", retryAfter);

            // Чекаємо і перекидаємо — Hangfire повторить цю конкретну задачу
            await Task.Delay(TimeSpan.FromSeconds(retryAfter + 1));
            throw;
        }
    }

    // Цей метод — точка входу Hangfire для батчевої обробки
    // Він сам контролює паралелізм через SemaphoreSlim
    public async Task SendBatchAsync(long[] chatIds, string text, string? markdownText = null)
    {
        // Детальна реалізація — нижче, у "Частині 2"
        throw new NotImplementedException("Розглядається в Частині 2");
    }
}

using Telegram.Bot;

// Реєстрація TelegramBotClient як Singleton — один клієнт на весь застосунок
builder.Services.AddSingleton<ITelegramBotClient>(sp =>
    new TelegramBotClient(builder.Configuration["Telegram:BotToken"]!));

builder.Services.AddScoped<ITelegramNotificationService, TelegramNotificationService>();

app.MapPost("/notifications/telegram/single", async (
    SendTelegramRequest request,
    IBackgroundJobClient jobs,
    AppDbContext db) =>
{
    // Знаходимо telegram chat_id користувача в БД
    var user = await db.Users
        .Where(u => u.Id == request.UserId && u.TelegramChatId != null)
        .FirstOrDefaultAsync();

    if (user is null)
        return Results.NotFound(new { error = "Користувач або Telegram-акаунт не знайдено" });

    // Пишемо в Hangfire — не в HTTP-запиті
    var jobId = jobs.Enqueue<ITelegramNotificationService>(
        x => x.SendMessageAsync(user.TelegramChatId!.Value, request.Text, true));

    return Results.Accepted(null, new { jobId, message = "Повідомлення поставлено в чергу" });
});

public record SendTelegramRequest(int UserId, string Text);

namespace NotifyApp.Models;

public enum CampaignStatus
{
    Draft, Starting, InProgress, Completed, Failed, Cancelled
}

public class NotificationCampaign
{
    public int Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string MessageText { get; set; } = string.Empty;

    // Статистика
    public int TotalRecipients { get; set; }
    public int SentCount { get; set; }
    public int FailedCount { get; set; }
    public int BlockedCount { get; set; }  // Заблокували бота

    public CampaignStatus Status { get; set; } = CampaignStatus.Draft;

    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
    public DateTime? StartedAt { get; set; }
    public DateTime? CompletedAt { get; set; }

    // Результати батчів для аудиту
    public ICollection<CampaignBatch> Batches { get; set; } = [];
}

public class CampaignBatch
{
    public int Id { get; set; }
    public int CampaignId { get; set; }
    public int BatchNumber { get; set; }
    public int RecipientCount { get; set; }
    public int SentCount { get; set; }
    public int FailedCount { get; set; }
    public string? HangfireJobId { get; set; }
    public DateTime? CompletedAt { get; set; }
    public NotificationCampaign Campaign { get; set; } = null!;
}

using Hangfire;
using Microsoft.EntityFrameworkCore;

namespace NotifyApp.Services;

public class CampaignOrchestrator
{
    private readonly AppDbContext _db;
    private readonly IBackgroundJobClient _jobs;
    private readonly ILogger<CampaignOrchestrator> _logger;

    // Розмір одного батчу: скільки підписників обробляє один Hangfire-воркер
    private const int BatchSize = 1000;

    public CampaignOrchestrator(
        AppDbContext db,
        IBackgroundJobClient jobs,
        ILogger<CampaignOrchestrator> logger)
    {
        _db = db;
        _jobs = jobs;
        _logger = logger;
    }

    // Ця задача виконується Hangfire одразу після старту кампанії
    // Вона тільки розбиває на батчі — сама нічого не надсилає
    [AutomaticRetry(Attempts = 1)] // Стартова задача не потребує багато retry
    public async Task StartCampaignAsync(int campaignId)
    {
        var campaign = await _db.NotificationCampaigns
            .Include(c => c.Batches)
            .FirstOrDefaultAsync(c => c.Id == campaignId)
            ?? throw new InvalidOperationException($"Campaign {campaignId} not found");

        campaign.Status = CampaignStatus.Starting;
        campaign.StartedAt = DateTime.UtcNow;
        await _db.SaveChangesAsync();

        // Завантажуємо тільки TelegramChatId — мінімум даних
        // Не завантажуємо весь User-об'єкт — нам не потрібен
        var chatIds = await _db.Users
            .Where(u => u.TelegramChatId != null && u.IsTelegramNotificationsEnabled)
            .Select(u => u.TelegramChatId!.Value)
            .ToArrayAsync();

        campaign.TotalRecipients = chatIds.Length;
        campaign.Status = CampaignStatus.InProgress;

        _logger.LogInformation(
            "Starting campaign {CampaignId}: {Total} recipients, {Batches} batches",
            campaignId, chatIds.Length, (chatIds.Length + BatchSize - 1) / BatchSize);

        // Розбиваємо на батчі та ставимо кожен в окрему Hangfire задачу
        var batchNumber = 0;
        foreach (var chunk in chatIds.Chunk(BatchSize))
        {
            batchNumber++;

            // Зберігаємо запис батчу для відстеження
            var batch = new CampaignBatch
            {
                CampaignId = campaignId,
                BatchNumber = batchNumber,
                RecipientCount = chunk.Length
            };
            _db.CampaignBatches.Add(batch);
            await _db.SaveChangesAsync();

            // Ставимо батч у чергу "campaigns" — окрема черга для масових розсилок
            // Завдяки цьому звичайні нотифікації не "застрягають" за кампаніями
            var jobId = _jobs.Enqueue<ITelegramNotificationService>(
                x => x.SendBatchAsync(chunk, campaign.MessageText, null),
                queue: "campaigns");

            batch.HangfireJobId = jobId;
        }

        await _db.SaveChangesAsync();

        _logger.LogInformation(
            "Campaign {CampaignId}: {BatchCount} batches enqueued", campaignId, batchNumber);
    }
}

public async Task SendBatchAsync(long[] chatIds, string text, string? markdownText = null)
{
    // Читаємо ліміт з конфігурації: за замовчуванням 25 пар. запитів
    // (залишаємо 5 запитів як буфер до ліміту Telegram 30/с)
    var maxParallel = _config.GetValue<int>("Telegram:MaxMessagesPerSecond", 25);

    // SemaphoreSlim — механізм обмеження паралелізму
    // Дозволяє одночасно виконуватись не більше ніж maxParallel корутин
    using var semaphore = new SemaphoreSlim(maxParallel, maxParallel);

    var successCount = 0;
    var failedCount = 0;
    var blockedCount = 0;

    // Створюємо Task для кожного отримувача
    var tasks = chatIds.Select(async chatId =>
    {
        // Захоплюємо "слот" у семафорі — якщо всі maxParallel зайняті, очікуємо
        await semaphore.WaitAsync();
        try
        {
            await _bot.SendMessage(
                chatId: chatId,
                text: markdownText ?? text,
                parseMode: markdownText != null ? ParseMode.MarkdownV2 : null);

            Interlocked.Increment(ref successCount);
        }
        catch (Telegram.Bot.Exceptions.ApiRequestException ex) when (ex.ErrorCode == 403)
        {
            // Заблокували бота — рахуємо, але не падаємо
            Interlocked.Increment(ref blockedCount);
            _logger.LogDebug("ChatId {ChatId}: bot blocked (403)", chatId);
        }
        catch (Telegram.Bot.Exceptions.ApiRequestException ex) when (ex.ErrorCode == 429)
        {
            // Rate limit — чекаємо і РАХУЄМО ЯК ПОМИЛКУ для цього батчу
            // Hangfire повторить весь батч через retry — це прийнятно для батчів по 1000
            var retryAfter = ex.Parameters?.RetryAfter ?? 30;
            _logger.LogWarning("Rate limit 429, retry after {Sec}s", retryAfter);
            await Task.Delay(TimeSpan.FromSeconds(retryAfter + 1));
            Interlocked.Increment(ref failedCount);
            throw; // Перекидаємо щоб Hangfire повторив батч
        }
        catch (Exception ex)
        {
            Interlocked.Increment(ref failedCount);
            _logger.LogError(ex, "Failed to send to chatId {ChatId}", chatId);
        }
        finally
        {
            // ЗАВЖДИ звільняємо семафор — інакше дедлок
            semaphore.Release();
        }
    });

    // Task.WhenAll — чекаємо завершення ВСІХ Task-ів батчу
    // Семафор гарантує, що одночасно активних не більше maxParallel
    await Task.WhenAll(tasks);

    _logger.LogInformation(
        "Batch completed: {Total} total, {Success} sent, {Failed} failed, {Blocked} blocked",
        chatIds.Length, successCount, failedCount, blockedCount);
}

app.MapPost("/campaigns/{id}/send", async (
    int id,
    AppDbContext db,
    IBackgroundJobClient jobs) =>
{
    var campaign = await db.NotificationCampaigns.FindAsync(id);
    if (campaign is null) return Results.NotFound();
    if (campaign.Status != CampaignStatus.Draft)
        return Results.Conflict(new { error = "Кампанія вже запущена або завершена" });

    // Ставимо ЛИШЕ стартову задачу — вона сама розіб'є на батчі
    var jobId = jobs.Enqueue<CampaignOrchestrator>(
        x => x.StartCampaignAsync(id),
        queue: "campaigns");

    campaign.Status = CampaignStatus.Starting;
    await db.SaveChangesAsync();

    return Results.Accepted(null, new
    {
        campaignId = id,
        hangfireJobId = jobId,
        message = "Кампанія запущена. Батчі будуть сформовані найближчим часом."
    });
});

// Статус кампанії з прогресом
app.MapGet("/campaigns/{id}/status", async (int id, AppDbContext db) =>
{
    var campaign = await db.NotificationCampaigns
        .Include(c => c.Batches)
        .FirstOrDefaultAsync(c => c.Id == id);

    if (campaign is null) return Results.NotFound();

    var completedBatches = campaign.Batches.Count(b => b.CompletedAt.HasValue);
    var totalBatches = campaign.Batches.Count;

    return Results.Ok(new
    {
        campaign.Id,
        campaign.Title,
        status = campaign.Status.ToString(),
        progress = new
        {
            total = campaign.TotalRecipients,
            sent = campaign.SentCount,
            failed = campaign.FailedCount,
            blocked = campaign.BlockedCount,
            percentComplete = campaign.TotalRecipients > 0
                ? (double)(campaign.SentCount + campaign.FailedCount) / campaign.TotalRecipients * 100
                : 0
        },
        batches = new { completed = completedBatches, total = totalBatches },
        campaign.StartedAt,
        campaign.CompletedAt
    });
});

namespace NotifyApp.Notifications;

// Доступні канали доставки
public enum NotificationChannelType
{
    Telegram, Email, WebPush, Sms
}

// Пріоритет повідомлення — впливає на вибір каналу
public enum NotificationPriority
{
    Low,      // Маркетинг, дайджести — достатньо Email
    Normal,   // Стандартні події — Telegram або Email
    High,     // Важливі події — Telegram + Email
    Critical  // OTP, платіжні — SMS + Email + Telegram одночасно
}

// Уніфіковане повідомлення для всіх каналів
public class NotificationMessage
{
    // Загальні поля
    public string Subject { get; init; } = string.Empty;   // Email subject / Заголовок
    public string TextBody { get; init; } = string.Empty;  // Простий текст (Email, SMS)

    // Канало-специфічні поля (nullable — якщо немає, використовується TextBody)
    public string? HtmlBody { get; init; }            // Для Email (HTML-верстка)
    public string? TelegramMarkdown { get; init; }    // Для Telegram (MarkdownV2)
    public string? PushIconUrl { get; init; }         // Для Web Push
    public string? ActionUrl { get; init; }           // Кнопка / посилання

    public NotificationPriority Priority { get; init; } = NotificationPriority.Normal;
}

// Стратегія вибору каналів
public enum DispatchStrategy
{
    // Надіслати тільки через пріоритетний канал (визначається за Priority)
    PriorityFirst,
    // Надіслати через ВСІ доступні канали користувача
    AllAvailable,
    // Надіслати тільки через канали, які вибрав сам користувач
    UserPreference
}

// Контракт каналу доставки
public interface INotificationChannel
{
    NotificationChannelType ChannelType { get; }

    // Чи може цей канал надіслати повідомлення цьому користувачу?
    // (наприклад, чи є у користувача прив'язаний Telegram)
    bool CanSendTo(User user);

    // Надіслати повідомлення
    Task<bool> SendAsync(User user, NotificationMessage message);
}

using Telegram.Bot;
using Telegram.Bot.Types.Enums;

namespace NotifyApp.Notifications;

public class TelegramChannel : INotificationChannel
{
    private readonly ITelegramBotClient _bot;
    private readonly ILogger<TelegramChannel> _logger;

    public TelegramChannel(ITelegramBotClient bot, ILogger<TelegramChannel> logger)
    {
        _bot = bot;
        _logger = logger;
    }

    public NotificationChannelType ChannelType => NotificationChannelType.Telegram;

    public bool CanSendTo(User user)
        // Канал доступний тільки якщо у користувача є TelegramChatId і він не відмовився
        => user.TelegramChatId.HasValue && user.IsTelegramNotificationsEnabled;

    public async Task<bool> SendAsync(User user, NotificationMessage message)
    {
        try
        {
            var text = message.TelegramMarkdown ?? message.TextBody;
            var parseMode = message.TelegramMarkdown != null ? ParseMode.MarkdownV2 : null;

            await _bot.SendMessage(user.TelegramChatId!.Value, text, parseMode: parseMode);
            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "TelegramChannel: failed to send to user {UserId}", user.Id);
            return false;
        }
    }
}

namespace NotifyApp.Notifications;

public class EmailChannel : INotificationChannel
{
    private readonly IEmailService _email;
    private readonly ILogger<EmailChannel> _logger;

    public EmailChannel(IEmailService email, ILogger<EmailChannel> logger)
    {
        _email = email;
        _logger = logger;
    }

    public NotificationChannelType ChannelType => NotificationChannelType.Email;

    public bool CanSendTo(User user)
        => !string.IsNullOrEmpty(user.Email) && user.IsEmailNotificationsEnabled;

    public async Task<bool> SendAsync(User user, NotificationMessage message)
    {
        try
        {
            await _email.SendAsync(
                to: user.Email!,
                subject: message.Subject,
                htmlBody: message.HtmlBody,
                textBody: message.TextBody);
            return true;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "EmailChannel: failed to send to user {UserId}", user.Id);
            return false;
        }
    }
}

using Microsoft.EntityFrameworkCore;

namespace NotifyApp.Notifications;

public class ChannelDispatcher
{
    // DI інжектує ВСІ зареєстровані реалізації INotificationChannel
    private readonly IEnumerable<INotificationChannel> _channels;
    private readonly AppDbContext _db;
    private readonly ILogger<ChannelDispatcher> _logger;

    public ChannelDispatcher(
        IEnumerable<INotificationChannel> channels,
        AppDbContext db,
        ILogger<ChannelDispatcher> logger)
    {
        _channels = channels;
        _db = db;
        _logger = logger;
    }

    // Головний метод: вирішити через які канали надіслати і надіслати
    public async Task DispatchAsync(
        int userId,
        NotificationMessage message,
        DispatchStrategy strategy = DispatchStrategy.UserPreference)
    {
        var user = await _db.Users.FindAsync(userId)
            ?? throw new InvalidOperationException($"User {userId} not found");

        // Визначаємо список каналів для надсилання
        var selectedChannels = strategy switch
        {
            DispatchStrategy.AllAvailable =>
                // Усі канали, до яких є доступ
                _channels.Where(c => c.CanSendTo(user)).ToList(),

            DispatchStrategy.PriorityFirst =>
                // Вибір каналу за пріоритетом повідомлення
                SelectByPriority(user, message.Priority),

            DispatchStrategy.UserPreference =>
                // Тільки канали, які увімкнув сам користувач
                _channels.Where(c => c.CanSendTo(user)).ToList(),

            _ => throw new ArgumentOutOfRangeException(nameof(strategy))
        };

        if (selectedChannels.Count == 0)
        {
            _logger.LogWarning(
                "No available channels for user {UserId} with strategy {Strategy}",
                userId, strategy);
            return;
        }

        _logger.LogInformation(
            "Dispatching to user {UserId} via {Channels}: [{ChannelNames}]",
            userId, selectedChannels.Count,
            string.Join(", ", selectedChannels.Select(c => c.ChannelType)));

        // Надсилаємо через всі обрані канали паралельно
        var results = await Task.WhenAll(
            selectedChannels.Select(async channel =>
            {
                var success = await channel.SendAsync(user, message);
                return (channel.ChannelType, success);
            }));

        // Логуємо результати
        foreach (var (channelType, success) in results)
        {
            _logger.LogInformation(
                "Channel {Channel} for user {UserId}: {Status}",
                channelType, userId, success ? "success" : "failed");
        }
    }

    // Вибір каналу(ів) за пріоритетом
    private List<INotificationChannel> SelectByPriority(User user, NotificationPriority priority)
    {
        // Визначаємо пріоритетний порядок каналів залежно від важливості
        var channelOrder = priority switch
        {
            // Для критичних — одразу SMS + Telegram + Email
            NotificationPriority.Critical => new[]
            {
                NotificationChannelType.Sms,
                NotificationChannelType.Telegram,
                NotificationChannelType.Email
            },
            // Для важливих — Telegram або Email (обидва якщо є)
            NotificationPriority.High => new[]
            {
                NotificationChannelType.Telegram,
                NotificationChannelType.Email
            },
            // Для звичайних — перший доступний у порядку пріоритету
            NotificationPriority.Normal => new[]
            {
                NotificationChannelType.Telegram,
                NotificationChannelType.WebPush,
                NotificationChannelType.Email
            },
            // Для низького — тільки Email
            NotificationPriority.Low => new[]
            {
                NotificationChannelType.Email
            },
            _ => Array.Empty<NotificationChannelType>()
        };

        // Для Critical і High — надсилаємо в усі перераховані доступні канали
        if (priority is NotificationPriority.Critical or NotificationPriority.High)
        {
            return _channels
                .Where(c => channelOrder.Contains(c.ChannelType) && c.CanSendTo(user))
                .ToList();
        }

        // Для Normal і Low — беремо перший доступний
        foreach (var preferredType in channelOrder)
        {
            var channel = _channels
                .FirstOrDefault(c => c.ChannelType == preferredType && c.CanSendTo(user));
            if (channel is not null)
                return [channel];
        }

        return [];
    }
}

// Реєстрація каналів — порядок важливий: DI інжектує в тому порядку, в якому зареєстровано
// Для Priority-стратегії Telegram має йти першим (якщо треба надсилати першим)
builder.Services.AddScoped<INotificationChannel, TelegramChannel>();
builder.Services.AddScoped<INotificationChannel, EmailChannel>();
builder.Services.AddScoped<INotificationChannel, PushChannel>();
builder.Services.AddScoped<INotificationChannel, SmsChannel>();

// Диспетчер
builder.Services.AddScoped<ChannelDispatcher>();

namespace NotifyApp.Services;

public class EventNotificationService
{
    private readonly ChannelDispatcher _dispatcher;
    private readonly ILogger<EventNotificationService> _logger;

    public EventNotificationService(
        ChannelDispatcher dispatcher,
        ILogger<EventNotificationService> logger)
    {
        _dispatcher = dispatcher;
        _logger = logger;
    }

    // Нова публікація — Normal пріоритет, перший доступний канал
    public async Task NotifyNewArticleAsync(int userId, string articleTitle, string articleUrl)
    {
        var message = new NotificationMessage
        {
            Subject = $"Нова стаття: {articleTitle}",
            TextBody = $"Опублікована нова стаття \"{articleTitle}\"\n{articleUrl}",
            TelegramMarkdown = $"📖 *Нова стаття*\n[{EscapeMd(articleTitle)}]({articleUrl})",
            HtmlBody = $"<h2>Нова стаття</h2><p><a href='{articleUrl}'>{articleTitle}</a></p>",
            ActionUrl = articleUrl,
            Priority = NotificationPriority.Normal
        };

        // Диспетчер сам вирішить: Telegram або Email або Push
        await _dispatcher.DispatchAsync(userId, message, DispatchStrategy.UserPreference);
    }

    // Платіжне підтвердження — Critical, усі канали одночасно
    public async Task NotifyPaymentAsync(int userId, decimal amount, string orderId)
    {
        var message = new NotificationMessage
        {
            Subject = $"Підтвердження оплати #{orderId}",
            TextBody = $"Оплата {amount:C} підтверджена. Замовлення #{orderId}.",
            TelegramMarkdown =
                $"✅ *Оплата підтверджена*\n" +
                $"Сума: *{amount:C}*\n" +
                $"Замовлення: `{EscapeMd(orderId)}`",
            Priority = NotificationPriority.Critical  // → SMS + Telegram + Email
        };

        await _dispatcher.DispatchAsync(userId, message, DispatchStrategy.PriorityFirst);
    }

    // TelegramV2 MarkdownV2 escaping — обов'язково для спецсимволів
    private static string EscapeMd(string text)
        => text.Replace(".", "\\.").Replace("-", "\\-").Replace("(", "\\(").Replace(")", "\\)");
}