namespace VideoTranscoder.Models;

public enum VideoJobStatus
{
    Uploading,      // Файл завантажується (HTTP)
    Analyzing,      // Job 1: аналіз метаданих
    Transcoding,    // Job 2-4: транскодування
    Finalizing,     // Job 5: генерація master playlist
    Completed,      // Готово до відтворення
    Failed          // Помилка на одному з кроків
}

// Цільова якість транскодування
public class VideoResolution
{
    public string Name { get; init; } = string.Empty;   // "360p", "720p", "1080p"
    public int Width { get; init; }                      // 640, 1280, 1920
    public int Height { get; init; }                     // 360, 720, 1080
    public int VideoBitrateKbps { get; init; }           // 800, 2500, 5000
    public int AudioBitrateKbps { get; init; }           // 96, 128, 192

    // Зручна перевірка: чи підтримує оригінал цю роздільну здатність
    public bool IsApplicableTo(int sourceWidth, int sourceHeight)
        => sourceWidth >= Width && sourceHeight >= Height;
}

// Головна сутність задачі транскодування
public class VideoJob
{
    public int Id { get; set; }
    public string OriginalPath { get; set; } = string.Empty;
    public string OriginalFileName { get; set; } = string.Empty;
    public long OriginalSizeBytes { get; set; }

    // Метадані відео (заповнюються на кроці аналізу)
    public int? SourceWidth { get; set; }
    public int? SourceHeight { get; set; }
    public double? DurationSeconds { get; set; }
    public string? SourceCodec { get; set; }

    // Шлях до директорії з HLS-файлами (відносний від wwwroot)
    public string? HlsOutputDirectory { get; set; }

    // URL master playlist (заповнюється після Job 5)
    public string? MasterPlaylistUrl { get; set; }

    // JSON-серіалізований список обраних якостей (після аналізу)
    public string? SelectedResolutionsJson { get; set; }

    public VideoJobStatus Status { get; set; } = VideoJobStatus.Uploading;
    public string? HangfireAnalysisJobId { get; set; }
    public string? ErrorMessage { get; set; }

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

using FFMpegCore;
using System.Text.Json;
using VideoTranscoder.Models;

namespace VideoTranscoder.Services;

public interface IVideoAnalysisService
{
    // Аналізує відео та визначає оптимальні варіанти якості
    Task<List<VideoResolution>> AnalyzeAndSelectResolutionsAsync(int videoJobId);
}

public class VideoAnalysisService : IVideoAnalysisService
{
    // Всі підтримувані якості, від найнижчої до найвищої
    private static readonly List<VideoResolution> AllResolutions =
    [
        new() { Name = "360p",  Width = 640,  Height = 360,  VideoBitrateKbps = 800,  AudioBitrateKbps = 96  },
        new() { Name = "480p",  Width = 854,  Height = 480,  VideoBitrateKbps = 1400, AudioBitrateKbps = 128 },
        new() { Name = "720p",  Width = 1280, Height = 720,  VideoBitrateKbps = 2500, AudioBitrateKbps = 128 },
        new() { Name = "1080p", Width = 1920, Height = 1080, VideoBitrateKbps = 5000, AudioBitrateKbps = 192 },
    ];

    private readonly AppDbContext _db;
    private readonly IStorageService _storage;
    private readonly ILogger<VideoAnalysisService> _logger;

    public VideoAnalysisService(
        AppDbContext db,
        IStorageService storage,
        ILogger<VideoAnalysisService> logger)
    {
        _db = db;
        _storage = storage;
        _logger = logger;
    }

    public async Task<List<VideoResolution>> AnalyzeAndSelectResolutionsAsync(int videoJobId)
    {
        var job = await _db.VideoJobs.FindAsync(videoJobId)
            ?? throw new InvalidOperationException($"VideoJob {videoJobId} not found");

        job.Status = VideoJobStatus.Analyzing;
        await _db.SaveChangesAsync();

        var absolutePath = _storage.GetAbsolutePath(job.OriginalPath);

        // FFMpegCore: отримати метадані медіафайлу
        // Під капотом виконує: ffprobe -v quiet -print_format json -show_format -show_streams "path"
        var mediaInfo = await FFProbe.AnalyseAsync(absolutePath);
        var videoStream = mediaInfo.VideoStreams.FirstOrDefault()
            ?? throw new InvalidOperationException("Відеопоток у файлі не знайдено");

        // Зберігаємо метадані в БД
        job.SourceWidth = videoStream.Width;
        job.SourceHeight = videoStream.Height;
        job.DurationSeconds = mediaInfo.Duration.TotalSeconds;
        job.SourceCodec = videoStream.CodecName; // h264, hevc, av1, тощо

        _logger.LogInformation(
            "Video analyzed: {W}x{H}, {Duration:F1}s, codec: {Codec}",
            videoStream.Width, videoStream.Height,
            mediaInfo.Duration.TotalSeconds, videoStream.CodecName);

        // Обираємо лише ті якості, для яких у вихідного відео достатня роздільна здатність
        // Немає сенсу робити 1080p якщо оригінал 480p — це апскейлінг, погана якість
        var selectedResolutions = AllResolutions
            .Where(r => r.IsApplicableTo(videoStream.Width, videoStream.Height))
            .ToList();

        // Завжди включаємо мінімум найнижчу якість
        if (selectedResolutions.Count == 0)
            selectedResolutions.Add(AllResolutions[0]);

        // Зберігаємо список обраних якостей для наступних кроків
        job.SelectedResolutionsJson = JsonSerializer.Serialize(selectedResolutions);
        job.Status = VideoJobStatus.Transcoding;
        await _db.SaveChangesAsync();

        _logger.LogInformation(
            "Selected {Count} resolutions for job {JobId}: {Resolutions}",
            selectedResolutions.Count, videoJobId,
            string.Join(", ", selectedResolutions.Select(r => r.Name)));

        return selectedResolutions;
    }
}

using FFMpegCore;
using FFMpegCore.Arguments;
using FFMpegCore.Enums;
using System.Text.Json;
using VideoTranscoder.Models;

namespace VideoTranscoder.Services;

public interface IHlsTranscodingService
{
    // Транскодує відео в одну якість і генерує variant playlist
    Task TranscodeToResolutionAsync(int videoJobId, string resolutionName);

    // Генерує master.m3u8, що об'єднує всі варіанти
    Task GenerateMasterPlaylistAsync(int videoJobId);
}

public class HlsTranscodingService : IHlsTranscodingService
{
    private readonly AppDbContext _db;
    private readonly IStorageService _storage;
    private readonly ILogger<HlsTranscodingService> _logger;

    // Тривалість HLS-сегменту в секундах
    // 4 секунди — баланс між латентністю переключення якості та кількістю файлів
    private const int SegmentDurationSeconds = 4;

    public HlsTranscodingService(
        AppDbContext db,
        IStorageService storage,
        ILogger<HlsTranscodingService> logger)
    {
        _db = db;
        _storage = storage;
        _logger = logger;
    }

    [AutomaticRetry(Attempts = 2)]
    public async Task TranscodeToResolutionAsync(int videoJobId, string resolutionName)
    {
        var job = await _db.VideoJobs.FindAsync(videoJobId)
            ?? throw new InvalidOperationException($"VideoJob {videoJobId} not found");

        // Десеріалізуємо список якостей, збережений кроком аналізу
        var resolutions = JsonSerializer.Deserialize<List<VideoResolution>>(
            job.SelectedResolutionsJson ?? "[]")!;

        var resolution = resolutions.FirstOrDefault(r => r.Name == resolutionName)
            ?? throw new InvalidOperationException(
                $"Resolution '{resolutionName}' not found in job {videoJobId}");

        // Визначаємо директорію для HLS-файлів
        // Структура: videos/hls/{jobId}/{resolutionName}/
        var hlsDir = job.HlsOutputDirectory
            ?? Path.Combine("videos", "hls", videoJobId.ToString());

        var resolutionDir = Path.Combine(hlsDir, resolutionName);
        var absoluteResDir = _storage.GetAbsolutePath(resolutionDir);
        Directory.CreateDirectory(absoluteResDir);

        // Якщо це перша якість — зберігаємо базову директорію HLS
        if (job.HlsOutputDirectory is null)
        {
            job.HlsOutputDirectory = hlsDir;
            await _db.SaveChangesAsync();
        }

        var inputPath = _storage.GetAbsolutePath(job.OriginalPath);
        // Шаблон імені сегментів: 720p_000.ts, 720p_001.ts, ...
        var segmentPattern = Path.Combine(absoluteResDir, $"{resolutionName}_%03d.ts");
        // Шлях до playlist для цієї якості
        var playlistPath = Path.Combine(absoluteResDir, $"playlist_{resolutionName}.m3u8");

        _logger.LogInformation(
            "Transcoding job {JobId} to {Resolution}: {W}x{H} @{Bitrate}kbps",
            videoJobId, resolutionName, resolution.Width, resolution.Height,
            resolution.VideoBitrateKbps);

        // Трекер прогресу
        var progressPercent = 0;

        // Будуємо FFmpeg команду через FFMpegCore fluent API
        await FFMpegArguments
            .FromFileInput(inputPath, verifyExists: true, opts => opts
                .WithHardwareAcceleration()) // Апаратне прискорення якщо доступне
            .OutputToFile(playlistPath, overwrite: true, opts => opts
                // Відеокодек: H.264 (libx264) — найбільш сумісний
                .WithVideoCodec(VideoCodec.LibX264)
                // Профіль і рівень для максимальної сумісності із пристроями
                .WithConstantRateFactor(23)    // Якість: 18 (краще) - 28 (гірше)
                // Цільовий відеобітрейт
                .WithVideoBitrate(resolution.VideoBitrateKbps)
                // Динамічне масштабування з коригуванням для парних чисел (вимога H.264)
                .WithVideoFilters(filterOptions => filterOptions
                    .Scale(resolution.Width, resolution.Height))
                // Аудіокодек: AAC — стандарт для HLS
                .WithAudioCodec(AudioCodec.Aac)
                .WithAudioBitrate(resolution.AudioBitrateKbps)
                // Формат виводу: HLS (hls)
                .ForceFormat("hls")
                // Тривалість кожного сегменту
                .WithCustomArgument($"-hls_time {SegmentDurationSeconds}")
                // Тип playlist: event = зростаючий під час запису, vod = фінальний
                .WithCustomArgument("-hls_playlist_type vod")
                // Шаблон імені сегментів
                .WithCustomArgument($"-hls_segment_filename \"{segmentPattern}\""))
            // Callback прогресу: викликається приблизно кожну секунду
            .NotifyOnProgress(progress =>
            {
                var percent = (int)(progress.Percentage);
                if (percent != progressPercent && percent % 10 == 0) // Логуємо кожні 10%
                {
                    progressPercent = percent;
                    _logger.LogInformation(
                        "Transcoding job {JobId} {Resolution}: {Percent}%",
                        videoJobId, resolutionName, percent);
                }
            }, job.DurationSeconds.HasValue
                ? TimeSpan.FromSeconds(job.DurationSeconds.Value)
                : null)
            .ProcessAsynchronously(); // Виконати FFmpeg як асинхронний процес

        _logger.LogInformation(
            "Transcoding completed: job {JobId}, resolution {Resolution}",
            videoJobId, resolutionName);
    }

    // Фінальний крок: генерація master.m3u8
    [AutomaticRetry(Attempts = 3)]
    public async Task GenerateMasterPlaylistAsync(int videoJobId)
    {
        var job = await _db.VideoJobs.FindAsync(videoJobId)
            ?? throw new InvalidOperationException($"VideoJob {videoJobId} not found");

        job.Status = VideoJobStatus.Finalizing;
        await _db.SaveChangesAsync();

        var resolutions = JsonSerializer.Deserialize<List<VideoResolution>>(
            job.SelectedResolutionsJson ?? "[]")!;

        // Генеруємо master.m3u8 вручну (це звичайний текстовий файл)
        var masterPlaylistContent = GenerateMasterPlaylistContent(resolutions, videoJobId);

        var hlsAbsDir = _storage.GetAbsolutePath(job.HlsOutputDirectory!);
        var masterPlaylistPath = Path.Combine(hlsAbsDir, "master.m3u8");
        await File.WriteAllTextAsync(masterPlaylistPath, masterPlaylistContent);

        // Зберігаємо публічний URL master playlist
        job.MasterPlaylistUrl = $"/{job.HlsOutputDirectory}/master.m3u8"
            .Replace(Path.DirectorySeparatorChar, '/');
        job.Status = VideoJobStatus.Completed;
        job.CompletedAt = DateTime.UtcNow;
        await _db.SaveChangesAsync();

        _logger.LogInformation(
            "Master playlist generated for job {JobId}: {Url}",
            videoJobId, job.MasterPlaylistUrl);
    }

    // Генерація вмісту master.m3u8 файлу
    private static string GenerateMasterPlaylistContent(
        List<VideoResolution> resolutions, int jobId)
    {
        // Master playlist — текстовий файл зі специфічним форматом HLS
        var sb = new System.Text.StringBuilder();
        sb.AppendLine("#EXTM3U");
        sb.AppendLine("#EXT-X-VERSION:3");
        sb.AppendLine();

        foreach (var res in resolutions.OrderBy(r => r.VideoBitrateKbps))
        {
            // Bandwidth в бітах/с (HLS специфікація)
            var bandwidthBps = (res.VideoBitrateKbps + res.AudioBitrateKbps) * 1000;
            sb.AppendLine($"#EXT-X-STREAM-INF:BANDWIDTH={bandwidthBps}," +
                         $"RESOLUTION={res.Width}x{res.Height}," +
                         $"CODECS=\"avc1.42E01E,mp4a.40.2\"," +
                         $"NAME=\"{res.Name}\"");
            // Відносний шлях до variant playlist
            sb.AppendLine($"{res.Name}/playlist_{res.Name}.m3u8");
            sb.AppendLine();
        }

        return sb.ToString();
    }
}

using Hangfire;
using VideoTranscoder.Models;

namespace VideoTranscoder.Services;

public class VideoProcessingOrchestrator
{
    private readonly IBackgroundJobClient _jobs;

    public VideoProcessingOrchestrator(IBackgroundJobClient jobs) => _jobs = jobs;

    public string StartProcessingPipeline(int videoJobId)
    {
        // Крок 1: Аналіз відео — виконується ОДРАЗУ
        // Повертає список обраних якостей через оновлення БД
        var analysisJobId = _jobs.Enqueue<IVideoAnalysisService>(
            x => x.AnalyzeAndSelectResolutionsAsync(videoJobId));

        // Крок 2: Транскодування в кожну якість — ПАРАЛЕЛЬНО після аналізу
        // ContinueJobWith: транскодування починається тільки після успішного завершення аналізу
        // Але між собою ці три задачі — незалежні, виконуються паралельно
        var transcode360Id = _jobs.ContinueJobWith<IHlsTranscodingService>(
            analysisJobId, x => x.TranscodeToResolutionAsync(videoJobId, "360p"),
            JobContinuationOptions.OnlyOnSucceededState);

        var transcode720Id = _jobs.ContinueJobWith<IHlsTranscodingService>(
            analysisJobId, x => x.TranscodeToResolutionAsync(videoJobId, "720p"),
            JobContinuationOptions.OnlyOnSucceededState);

        var transcode1080Id = _jobs.ContinueJobWith<IHlsTranscodingService>(
            analysisJobId, x => x.TranscodeToResolutionAsync(videoJobId, "1080p"),
            JobContinuationOptions.OnlyOnSucceededState);

        // Крок 3: Генерація master playlist — ПІСЛЯ ВСІХ транскодувань
        // BatchContinuation: чекає завершення ВСІХ попередніх задач
        // Примітка: Батчі — Hangfire Pro фіча. Для Hangfire Core:
        // генерація master playlist ставиться після кожного транскодування з перевіркою
        var masterJobId = _jobs.ContinueJobWith<IHlsTranscodingService>(
            transcode1080Id,  // Чекаємо тільки 1080p (зазвичай найдовше)
            x => x.GenerateMasterPlaylistAsync(videoJobId),
            JobContinuationOptions.OnlyOnSucceededState);

        return analysisJobId; // Повертаємо ID першої задачі для tracking
    }
}

// Версія GenerateMasterPlaylistAsync з перевіркою готовності всіх якостей
public async Task GenerateMasterPlaylistAsync(int videoJobId)
{
    var job = await _db.VideoJobs.FindAsync(videoJobId)!;
    var resolutions = JsonSerializer.Deserialize<List<VideoResolution>>(
        job.SelectedResolutionsJson ?? "[]")!;

    // Перевіряємо, чи всі очікувані playlist-файли вже існують
    foreach (var resolution in resolutions)
    {
        var playlistPath = _storage.GetAbsolutePath(
            Path.Combine(job.HlsOutputDirectory!, resolution.Name,
                $"playlist_{resolution.Name}.m3u8"));

        if (!File.Exists(playlistPath))
        {
            // Не всі якості ще готові — кидаємо виняток
            // Hangfire побачить це як тимчасову помилку і повторить через кілька хвилин
            throw new InvalidOperationException(
                $"Playlist для {resolution.Name} ще не готовий. Retry пізніше.");
        }
    }

    // Якщо всі є — генеруємо master playlist
    // ...
}

using Hangfire;
using VideoTranscoder.Models;
using VideoTranscoder.Services;

namespace VideoTranscoder.Endpoints;

public static class VideoEndpoints
{
    public static void MapVideoEndpoints(this IEndpointRouteBuilder app)
    {
        var group = app.MapGroup("/videos").WithTags("Videos");

        group.MapPost("/upload", UploadVideoAsync).DisableAntiforgery();
        group.MapGet("/{jobId:int}/status", GetJobStatusAsync);
        group.MapGet("/{jobId:int}/player", GetPlayerPageAsync);
    }

    // POST /videos/upload — завантаження відео та запуск pipeline
    private static async Task<IResult> UploadVideoAsync(
        IFormFile file,
        AppDbContext db,
        IStorageService storage,
        VideoProcessingOrchestrator orchestrator)
    {
        // Валідація формату
        var allowedExtensions = new[] { ".mp4", ".avi", ".mov", ".mkv", ".webm" };
        var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
        if (!allowedExtensions.Contains(extension))
        {
            return Results.BadRequest(new
            {
                error = $"Непідтримуваний формат '{extension}'. " +
                        "Дозволені: .mp4, .avi, .mov, .mkv, .webm"
            });
        }

        // Ліміт: 2 ГБ
        const long maxSizeBytes = 2L * 1024 * 1024 * 1024;
        if (file.Length > maxSizeBytes)
        {
            return Results.BadRequest(new
            {
                error = $"Файл занадто великий: {file.Length / 1024 / 1024} МБ. Максимум: 2 ГБ"
            });
        }

        // Зберігаємо оригінальний відеофайл
        var originalPath = await storage.SaveUploadedFileAsync(file, "videos/original");

        // Створюємо запис задачі в БД
        var job = new VideoJob
        {
            OriginalPath = originalPath,
            OriginalFileName = file.FileName,
            OriginalSizeBytes = file.Length,
            Status = VideoJobStatus.Analyzing
        };
        db.VideoJobs.Add(job);
        await db.SaveChangesAsync();

        // Запускаємо весь pipeline через оркестратор
        var hangfireJobId = orchestrator.StartProcessingPipeline(job.Id);
        job.HangfireAnalysisJobId = hangfireJobId;
        await db.SaveChangesAsync();

        return Results.Accepted($"/videos/{job.Id}/status", new
        {
            jobId = job.Id,
            statusUrl = $"/videos/{job.Id}/status",
            message = "Відео завантажено. Транскодування розпочато.",
            originalFileName = file.FileName,
            originalSizeMb = Math.Round(file.Length / 1024.0 / 1024.0, 2)
        });
    }

    // GET /videos/{jobId}/status — статус транскодування
    private static async Task<IResult> GetJobStatusAsync(int jobId, AppDbContext db)
    {
        var job = await db.VideoJobs.FindAsync(jobId);
        if (job is null) return Results.NotFound();

        return Results.Ok(new
        {
            jobId = job.Id,
            status = job.Status.ToString(),
            originalFileName = job.OriginalFileName,
            sourceResolution = job.SourceWidth.HasValue
                ? $"{job.SourceWidth}x{job.SourceHeight}"
                : null,
            durationSeconds = job.DurationSeconds,
            masterPlaylistUrl = job.MasterPlaylistUrl,
            playerUrl = job.Status == VideoJobStatus.Completed
                ? $"/videos/{job.Id}/player"
                : null,
            errorMessage = job.ErrorMessage,
            createdAt = job.CreatedAt,
            completedAt = job.CompletedAt
        });
    }

    // GET /videos/{jobId}/player — HTML-сторінка з відеоплеєром
    private static async Task<IResult> GetPlayerPageAsync(int jobId, AppDbContext db)
    {
        var job = await db.VideoJobs.FindAsync(jobId);
        if (job is null) return Results.NotFound();
        if (job.Status != VideoJobStatus.Completed)
            return Results.BadRequest(new { error = "Відео ще не готове до відтворення" });

        // Генеруємо простий HTML-плеєр з hls.js
        var html = GeneratePlayerHtml(job);
        return Results.Content(html, "text/html");
    }

    private static string GeneratePlayerHtml(VideoJob job) => $"""
        <!DOCTYPE html>
        <html lang="uk">
        <head>
            <meta charset="UTF-8">
            <title>{job.OriginalFileName}</title>
            <script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
            <style>
                body {{ margin: 0; background: #000; display: flex;
                        justify-content: center; align-items: center;
                        min-height: 100vh; }}
                video {{ max-width: 100%; max-height: 100vh; }}
            </style>
        </head>
        <body>
            <video id="video" controls autoplay></video>
            <script>
                const video = document.getElementById('video');
                const src = '{job.MasterPlaylistUrl}';

                if (Hls.isSupported()) {{
                    // Chrome, Firefox, Edge — через hls.js
                    const hls = new Hls({{
                        // Автоматичний вибір якості на основі пропускної здатності
                        startLevel: -1,
                        // Розмір буфера: 30 секунд вперед
                        maxBufferLength: 30
                    }});
                    hls.loadSource(src);
                    hls.attachMedia(video);
                    hls.on(Hls.Events.MANIFEST_PARSED, () => video.play());
                }} else if (video.canPlayType('application/vnd.apple.mpegurl')) {{
                    // Safari — нативна підтримка HLS
                    video.src = src;
                    video.play();
                }}
            </script>
        </body>
        </html>
        """;
}

using Hangfire;
using Hangfire.PostgreSql;
using VideoTranscoder.Data;
using VideoTranscoder.Endpoints;
using VideoTranscoder.Services;
using FFMpegCore;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// EF Core
builder.Services.AddDbContext<AppDbContext>(opts =>
    opts.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));

// FFMpegCore: глобальна конфігурація шляху до FFmpeg
// Якщо FFmpeg у PATH — цей рядок не потрібен
GlobalFFOptions.Configure(opts =>
    opts.BinaryFolder = builder.Configuration["FFmpeg:BinaryFolder"] ?? "/usr/bin");

// Hangfire
builder.Services.AddHangfire(config => config
    .SetDataCompatibilityLevel(CompatibilityLevel.Version_180)
    .UseSimpleAssemblyNameTypeSerializer()
    .UseRecommendedSerializerSettings()
    .UsePostgreSqlStorage(opts =>
        opts.UseNpgsqlConnection(
            builder.Configuration.GetConnectionString("DefaultConnection"))));

// Окремий сервер для CPU-інтенсивного транскодування відео
builder.Services.AddHangfireServer(opts =>
{
    // ProcessorCount - 1: залишаємо одне ядро для HTTP та ОС
    opts.WorkerCount = Math.Max(1, Environment.ProcessorCount - 1);
    opts.Queues = ["video-transcoding", "default"];
    opts.ServerName = "video-transcoder";
});

// Апаратне прискорення для FFMpegCore (якщо є GPU)
// Залежить від інфраструктури: NVENC (Nvidia), QSV (Intel), VideoToolbox (Apple)
// Якщо немає — FFmpeg автоматично використовує CPU

builder.Services.AddScoped<IVideoAnalysisService, VideoAnalysisService>();
builder.Services.AddScoped<IHlsTranscodingService, HlsTranscodingService>();
builder.Services.AddScoped<IStorageService, StorageService>();
builder.Services.AddScoped<VideoProcessingOrchestrator>();

// Ліміт для завантаження великих відеофайлів
builder.Services.Configure<FormOptions>(opts =>
{
    opts.MultipartBodyLengthLimit = 2L * 1024 * 1024 * 1024; // 2 ГБ
});

var app = builder.Build();

// Автоматичні міграції
using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    await db.Database.MigrateAsync();
}

app.UseStaticFiles();
app.UseHangfireDashboard("/hangfire");
app.MapVideoEndpoints();

app.Run();