using System;
using System.Drawing;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using FFMpegCore;
using FFMpegCore.Arguments;
using FFMpegCore.Enums;
using Microsoft.Extensions.Logging;
using Slopper.Domain;

namespace Slopper.Infrastructure.Ffmpeg;

internal sealed partial class ClipExtractor(ILogger<ClipExtractor> logger) : IClipExtractor
{
    public async Task ExtractClip(
        MediaItem media,
        TimeSpan start,
        TimeSpan duration,
        string outputPath,
        CancellationToken cancellationToken
    )
    {
        var crop = await AnalyzeCropArea(media, start, duration, cancellationToken);

        await CreateClip(media, start, duration, crop, outputPath, cancellationToken);
    }

    private async Task<Rectangle?> AnalyzeCropArea(
        MediaItem media,
        TimeSpan start,
        TimeSpan duration,
        CancellationToken cancellationToken
    )
    {
        Rectangle? crop = null;
        var args = FFMpegArguments
            .FromFileInput(media.Path, addArguments: options => options.Seek(start).EndSeek(start + duration))
            .OutputToFile(
                "-",
                addArguments: options =>
                    options
                        .WithVideoFilters(filter =>
                            filter
                                .Add("zscale", "t=linear:npl=100")
                                .Add("format", "yuv420p")
                                .Add("cropdetect", "mode=black:limit=24:round=2")
                        )
                        .ForceFormat("null")
            )
            .NotifyOnError(s =>
            {
                var match = CropPattern.Match(s);
                if (
                    !match.Success
                    || !int.TryParse(match.Groups[1].ValueSpan, out var width)
                    || !int.TryParse(match.Groups[2].ValueSpan, out var height)
                    || !int.TryParse(match.Groups[3].ValueSpan, out var x)
                    || !int.TryParse(match.Groups[4].ValueSpan, out var y)
                )
                {
                    return;
                }
                crop = new(x, y, width, height);
            })
            .CancellableThrough(cancellationToken);
        using var activity = Tracing.StartCropAreaAnalysis(media.Path, start, duration);
        logger.LogInformation("Running ffmpeg {FfmpegArguments}", args.Arguments);
        await args.ProcessAsynchronously();
        return crop;
    }

    [GeneratedRegex(@"crop=(\d+):(\d+):(\d+):(\d+)")]
    private static partial Regex CropPattern { get; }

    private async Task CreateClip(
        MediaItem media,
        TimeSpan start,
        TimeSpan duration,
        Rectangle? crop,
        string outputPath,
        CancellationToken cancellationToken
    )
    {
        var subtitleOptions = await CreateSubtitleOptions(media, cancellationToken);
        var args = FFMpegArguments
            .FromFileInput(
                media.Path,
                addArguments: options => options.Seek(start).EndSeek(start + duration).WithArgument("-copyts")
            )
            .OutputToFile(
                outputPath,
                addArguments: options =>
                    options
                        .Seek(start)
                        .EndSeek(start + duration)
                        .WithVideoFilters(filter =>
                        {
                            if (crop is { Width: var width, Height: var height, X: var x, Y: var y })
                            {
                                filter.Add("crop", $"{width}:{height}:{x}:{y}");
                            }
                            filter.Add("split", "2[s0][s1]");

                            filter.Add("[s0]scale", "1080:-1[sharp]");

                            filter
                                .Add("[s1]scale", "-1:1920[scaled1]")
                                .Add("[scaled1]gblur", "sigma=30[blurred]")
                                .Add("[blurred]crop", "1080:1920:(iw - 1080) / 2:0[cropped]")
                                .Add("[cropped][sharp]overlay", "0:(H - h) / 2");

                            filter.HardBurnSubtitle(subtitleOptions);
                        })
                        .WithFastStart()
                        .WithVideoCodec(VideoCodec.LibX264)
                        .WithAudioCodec(AudioCodec.Aac)
                        .WithFramerate(30.0d)
                        .WithVideoBitrate(4000)
                        .WithAudioBitrate(128)
                        .ForceFormat("mp4")
            )
            .CancellableThrough(cancellationToken);
        using var activity = Tracing.StartCreateClip(media.Path, start, duration);
        logger.LogInformation("Running ffmpeg {FfmpegArguments}", args.Arguments);
        await args.ProcessAsynchronously();
    }

    private async Task<SubtitleHardBurnOptions> CreateSubtitleOptions(
        MediaItem media,
        CancellationToken cancellationToken
    ) =>
        (
            media.Subtitles switch
            {
                Subtitles.External(var path) => SubtitleHardBurnOptions.Create(path),
                Subtitles.Embedded(var index) => await CreateEmbeddedSubtitleOptions(
                    media.Path,
                    index,
                    cancellationToken
                ),
                _ => throw new ArgumentException("Unknown subtitle type"),
            }
        ).WithParameter(
            "force_style",
            "FontSize=10,BorderStyle=1,Alignment=2,MarginV=80,PrimaryColour=&HFFFFFF&,BackColour=&H000000&"
        );

    private async Task<SubtitleHardBurnOptions> CreateEmbeddedSubtitleOptions(
        string path,
        int index,
        CancellationToken cancellationToken
    )
    {
        var analysis = await FFProbe.AnalyseAsync(path, cancellationToken: cancellationToken);
        var subIndex = analysis.SubtitleStreams.Count(s => s.Index < index);
        return SubtitleHardBurnOptions.Create(path).SetSubtitleIndex(subIndex);
    }
}