using System.Runtime.InteropServices;
using System.Threading;
using Sdcb.FFmpeg.Codecs;
using Sdcb.FFmpeg.Formats;
using Sdcb.FFmpeg.Raw;
using Sdcb.FFmpeg.Utils;
using T3.Core.Logging;
using T3.Core.Resource;
using T3.Core.Video;

namespace T3.VideoServices;

/// <summary>
/// Wraps one open video file: its demuxer (<see cref="FormatContext"/>) and decoder
/// (<see cref="CodecContext"/>). Provides the two access patterns the playback controller needs —
/// <see cref="TryReadNextFrame"/> for the fast sequential stream (forward play / export) and
/// <see cref="SeekToKeyframeBefore"/> + decode-forward for exact, frame-accurate seeking.
///
/// Decode runs on the CPU (software) by default. When the D3D11VA hardware path is requested it decodes on
/// the GPU and — in this first hardware milestone — reads the surface back to CPU memory so the existing
/// software converter is reused (the zero-copy GPU convert is a later step). Either way <see cref="CurrentFrame"/>
/// exposes a CPU frame, so the controller is unaffected by the decode backend.
///
/// Not thread-safe: a session is owned by exactly one decode worker thread. FFmpeg's contexts are not
/// reentrant, so single ownership avoids locking them.
/// </summary>
public sealed class VideoDecoderSession : IDisposable
{
    public double DurationSeconds { get; }
    public int Width { get; }
    public int Height { get; }

    /// <summary>
    /// The pixel format of <see cref="CurrentFrame"/> on the CPU (e.g. <c>Nv12</c>, <c>Yuv420p</c>,
    /// <c>P010le</c>). In hardware mode this is the read-back (software) format, not <c>D3d11</c>.
    /// </summary>
    public AVPixelFormat PixelFormat { get; }

    /// <summary>True for PQ/HLG transfer or ≥10-bit formats — the converter should target RGBA16.</summary>
    public bool IsHdr { get; }

    /// <summary>True when decoding runs through the D3D11VA hardware path (with CPU read-back in this milestone).</summary>
    public bool UsesHardwareDecode { get; }

    /// <summary>True when the decoded surface stays on the GPU (no read-back); the caller converts it on the GPU.</summary>
    public bool UsesZeroCopy { get; }

    public int TimeBaseNum { get; }
    public int TimeBaseDen { get; }

    /// <summary>The stream's <c>start_time</c> in time-base ticks (0 when unset).</summary>
    public long StreamStartPts { get; }

    /// <summary>Nominal average frame rate (fps); 0 when unknown.</summary>
    public double FrameRate { get; }

    /// <summary>
    /// The most recently decoded frame as CPU planes; valid after <see cref="TryReadNextFrame"/> returned
    /// true, until the next read. In hardware mode this is the read-back frame. Backends read its
    /// <c>Data</c>/<c>Linesize</c> before advancing.
    /// </summary>
    public Frame CurrentFrame => _lastFrameReadBack ? _swFrame : _frame;

    /// <summary>
    /// Opens <paramref name="url"/> (file or network stream) and selects the best video stream. Returns null
    /// on failure. <paramref name="demuxerOptions"/> passes demuxer options (e.g. <c>rtsp_transport=tcp</c>).
    /// </summary>
    public static unsafe VideoDecoderSession? TryOpen(string url, VideoPlaybackOptimization optimization, out string? error,
                                                      IReadOnlyDictionary<string, string>? demuxerOptions = null)
    {
        error = null;
        if (!FfmpegLibrary.EnsureInitialized())
        {
            error = FfmpegLibrary.StatusError ?? "FFmpeg is not available";
            return null;
        }

        FormatContext? formatContext = null;
        MediaDictionary? options = null;
        try
        {
            if (demuxerOptions != null)
            {
                options = new MediaDictionary();
                foreach (var pair in demuxerOptions)
                    options[pair.Key] = pair.Value;
            }

            formatContext = FormatContext.OpenInputUrl(url, null, options);
            formatContext.LoadStreamInfo();

            var stream = formatContext.FindBestStreamOrNull(AVMediaType.Video);
            if (stream == null)
            {
                error = "No video stream found in " + url;
                formatContext.Dispose();
                return null;
            }

            var videoStream = stream.Value;
            var codecParameters = videoStream.Codecpar;
            if (codecParameters == null)
            {
                error = "Video stream has no codec parameters: " + url;
                formatContext.Dispose();
                return null;
            }

            var codec = Codec.FindDecoderById(codecParameters.CodecId);

            // Playback-performance decodes on the GPU (zero-copy below). Fast-seeking decodes in software: it keeps
            // the GPU free for the editor and avoids a per-frame GPU→CPU read-back stall (the readback path syncs
            // every frame and stutters), while caching the CPU frames for cheap re-seeks. Hardware is the fallback
            // target only for playback-performance; fast-seeking is already software.
            //
            // Only prefer hardware for codecs the decoder can actually decode on D3D11VA. A decoder without a
            // D3D11VA hwaccel (e.g. ProRes) still *accepts* a hw_device_ctx and opens fine, but decodes in
            // software — which would make the session look hardware/zero-copy yet emit CPU frames, freezing the
            // zero-copy convert path. The hw-config probe rules those codecs out up front.
            var preferHardware = optimization == VideoPlaybackOptimization.PlaybackPerformance
                                 && CodecSupportsD3d11va(codec);

            CodecContext codecContext = null!;
            AVBufferRef* hwDeviceCtx = null;
            var usesHardware = false;
            if (preferHardware)
                usesHardware = TryOpenHardware(codec, codecParameters, out codecContext, out hwDeviceCtx);

            if (!usesHardware)
            {
                codecContext = new CodecContext(codec);
                codecContext.FillParameters(codecParameters);
                codecContext.Open();
            }

            // Playback-performance keeps the decoded surface on the GPU (zero-copy, no read-back, no cache); the
            // controller converts it with a compute shader. The GPU converter handles 4:2:0 NV12 (8-bit) and
            // P010/P016 (10/12-bit), adapting the plane-SRV format to the bit depth; if the codec produces some
            // other layout it falls back to hardware read-back here.
            var wantsZeroCopy = usesHardware && optimization == VideoPlaybackOptimization.PlaybackPerformance;
            var zeroCopy = wantsZeroCopy && SupportsZeroCopy(codecContext, codecParameters);
            if (wantsZeroCopy && !zeroCopy)
                Log.Info("Zero-copy decode skipped: stream pixel format isn't a supported 4:2:0 surface. "
                         + "Using hardware decode with CPU read-back.");

            return new VideoDecoderSession(formatContext, codecContext, videoStream, usesHardware, zeroCopy, hwDeviceCtx);
        }
        catch (Exception e)
        {
            error = "Failed to open video: " + e.Message;
            formatContext?.Dispose();
            return null;
        }
        finally
        {
            options?.Dispose();
        }
    }

    /// <summary>
    /// Sets up a D3D11VA hardware decoder on FFmpeg's own D3D11 device (no shared device yet — that's a later
    /// step that has to AddRef the global device). Returns false on any failure so the caller falls back to a
    /// plain software open; never worse than software.
    /// </summary>
    private static unsafe bool TryOpenHardware(Codec codec, CodecParameters codecParameters,
                                               out CodecContext codecContext, out AVBufferRef* hwDeviceCtx)
    {
        codecContext = null!;
        hwDeviceCtx = null;
        try
        {
            // Decode onto TiXL's own D3D11 device (shared) rather than a fresh FFmpeg-owned one: the decoder's
            // output surfaces then live on the same device the compute converter and the output texture use.
            // A separate device would put the surfaces out of reach — using a texture across two D3D11 devices
            // crashes. FFmpeg releases this device on teardown but never AddRefs it, so AddRef once here to keep
            // TiXL's reference alive (a slip here double-frees the global device).
            var deviceCtx = ffmpeg.av_hwdevice_ctx_alloc(AVHWDeviceType.D3d11va);
            if (deviceCtx == null)
                return false;
            hwDeviceCtx = deviceCtx;

            EnsureMultithreadProtected();

            var d3d11 = (AVD3D11VADeviceContext*)((AVHWDeviceContext*)deviceCtx->data)->hwctx;
            var devicePtr = ResourceManager.Device.NativePointer;
            Marshal.AddRef(devicePtr);
            d3d11->device = (ID3D11Device*)devicePtr.ToPointer();

            // Serialize FFmpeg's decode against the GPU converter: FFmpeg calls these around its device access,
            // and the converter takes the same lock. Without them the decoder and the converter corrupt each
            // other on the shared device (the decode-fail-then-reinit loop we saw).
            d3d11->@lock = _lockDevice;
            d3d11->unlock = _unlockDevice;

            if (ffmpeg.av_hwdevice_ctx_init(deviceCtx) < 0)
            {
                Marshal.Release(devicePtr);   // init didn't take our AddRef
                d3d11->device = null;          // so the unref below doesn't release TiXL's device
                ffmpeg.av_buffer_unref(&deviceCtx);
                hwDeviceCtx = null;
                return false;
            }

            codecContext = new CodecContext(codec);
            codecContext.FillParameters(codecParameters);

            AVCodecContext* raw = codecContext;
            raw->hw_device_ctx = ffmpeg.av_buffer_ref(deviceCtx);
            raw->get_format = _selectHardwareFormat;

            codecContext.Open();
            return true;
        }
        catch
        {
            codecContext?.Dispose();
            codecContext = null!;
            if (hwDeviceCtx != null)
            {
                var local = hwDeviceCtx;
                ffmpeg.av_buffer_unref(&local);
                hwDeviceCtx = null;
            }

            return false;
        }
    }

    // get_format: pick the D3D11 hardware surface when the decoder offers it, and give the frames context's
    // pool textures the SHADER_RESOURCE bind flag (default D3D11VA pool textures are decode-only) so the GPU
    // converter can wrap them in SRVs. If that setup fails (driver/profile limits) the read-back path still
    // works on the decode-only pool. Falls back to the decoder's first (software) format when D3D11 isn't
    // offered. Held in a static field so the delegate is never collected while FFmpeg holds the function pointer.
    private static unsafe AVPixelFormat SelectHardwareFormat(AVCodecContext* ctx, AVPixelFormat* formats)
    {
        for (var p = formats; *p != AVPixelFormat.None; p++)
        {
            if (*p != AVPixelFormat.D3d11)
                continue;

            // FFmpeg re-calls get_format on every flush — so on every backward seek / scrub. Reuse the existing
            // frames context instead of re-allocating the whole texture pool each time; that churn drops frames.
            if (ctx->hw_frames_ctx != null)
                return AVPixelFormat.D3d11;

            AVBufferRef* framesRef;
            if (ffmpeg.avcodec_get_hw_frames_parameters(ctx, ctx->hw_device_ctx, AVPixelFormat.D3d11, &framesRef) >= 0
                && framesRef != null)
            {
                var framesCtx = (AVHWFramesContext*)framesRef->data;
                var d3d11Frames = (AVD3D11VAFramesContext*)framesCtx->hwctx;
                d3d11Frames->BindFlags |= D3D11BindShaderResource;

                if (ffmpeg.av_hwframe_ctx_init(framesRef) >= 0)
                {
                    ctx->hw_frames_ctx = framesRef;
                    if (!_loggedFramesContext)
                    {
                        Log.Debug("D3D11VA: SHADER_RESOURCE frames context ready (zero-copy capable)");
                        _loggedFramesContext = true;
                    }
                }
                else
                {
                    ffmpeg.av_buffer_unref(&framesRef);
                    Log.Warning("D3D11VA: frames-context init rejected SHADER_RESOURCE; using decode-only read-back");
                }
            }

            return AVPixelFormat.D3d11;
        }

        return *formats;
    }

    // D3D11_BIND_SHADER_RESOURCE — added to the decoder pool's bind flags so the surfaces can be sampled by the
    // GPU NV12→RGBA converter, on top of the decoder's own D3D11_BIND_DECODER.
    private const uint D3D11BindShaderResource = 8;

    private static bool _loggedFramesContext;

    private static readonly unsafe AVCodecContext_get_format _selectHardwareFormat = SelectHardwareFormat;

    // FFmpeg calls these around its decode on the shared device; they take the same lock the GPU converter
    // takes, so decode and convert never overlap. Held in static fields so the delegates aren't collected.
    private static unsafe void LockDevice(void* lockCtx) => Monitor.Enter(HardwareFrameConverter.DeviceLock);
    private static unsafe void UnlockDevice(void* lockCtx) => Monitor.Exit(HardwareFrameConverter.DeviceLock);
    private static readonly unsafe AVD3D11VADeviceContext_lock _lockDevice = LockDevice;
    private static readonly unsafe AVD3D11VADeviceContext_unlock _unlockDevice = UnlockDevice;

    private static bool _multithreadProtected;

    private static void EnsureMultithreadProtected()
    {
        if (_multithreadProtected)
            return;

        using var mt = ResourceManager.Device.QueryInterface<SharpDX.Direct3D11.Multithread>();
        mt.SetMultithreadProtected(true);
        _multithreadProtected = true;
    }

    // The CPU/GPU pixel format a hardware decode will produce. Prefer the codec's reported software format, but
    // libavcodec only sets it on the first get_format (first decode), so before any frame is decoded fall back to
    // the container's bitstream format and map by bit depth: 8-bit 4:2:0 -> NV12, deeper -> P010. Used to label
    // the read-back format for the converter/cache (the GPU converter reads the real surface format directly).
    private static AVPixelFormat HardwareSurfaceFormat(AVPixelFormat swPixelFormat, AVPixelFormat bitstreamFormat)
    {
        if (swPixelFormat != AVPixelFormat.None)
            return swPixelFormat;

        // 8-bit 4:2:0 is 12 bits/pixel; 10-bit is 15 (planar) or 24 (P010), 12-bit higher still.
        return BitsPerPixel(bitstreamFormat) > 12 ? AVPixelFormat.P010le : AVPixelFormat.Nv12;
    }

    // The zero-copy GPU converter handles 4:2:0 NV12/P010/P016 (8/10/12-bit); the plane-SRV format adapts to the
    // bit depth. Other layouts (4:2:2, 4:4:4) stay on read-back. This only runs once hardware decode engaged,
    // which D3D11VA does only for 4:2:0, so the bit-depth bounds are a guard rather than a real filter.
    private static bool SupportsZeroCopy(CodecContext codecContext, CodecParameters codecParameters)
    {
        var format = codecContext.SwPixelFormat != AVPixelFormat.None
                         ? codecContext.SwPixelFormat
                         : (AVPixelFormat)codecParameters.Format;
        var bitsPerPixel = BitsPerPixel(format);
        return bitsPerPixel is >= 12 and <= 24;   // 4:2:0: 8-bit = 12 bpp, up to 12-bit P016 = 24 bpp
    }

    private static unsafe int BitsPerPixel(AVPixelFormat format)
    {
        var desc = ffmpeg.av_pix_fmt_desc_get(format);
        return desc != null ? ffmpeg.av_get_bits_per_pixel(desc) : 0;
    }

    // True only when the decoder advertises a D3D11VA device config — i.e. it can genuinely decode this codec on
    // the GPU. Decoders without one (ProRes, FFV1, …) accept a hw_device_ctx but fall back to software silently.
    private static unsafe bool CodecSupportsD3d11va(Codec codec)
    {
        AVCodec* c = codec;
        if (c == null)
            return false;

        for (var i = 0; ; i++)
        {
            var config = ffmpeg.avcodec_get_hw_config(c, i);
            if (config == null)
                return false;

            if (config->device_type == AVHWDeviceType.D3d11va
                && (config->methods & AvCodecHwConfigMethodHwDeviceCtx) != 0)
                return true;
        }
    }

    // AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX — the decoder is driven via a hw_device_ctx (our D3D11VA path).
    private const int AvCodecHwConfigMethodHwDeviceCtx = 0x01;

    /// <summary>
    /// Decodes the next frame in presentation order into <see cref="CurrentFrame"/>. Returns false at
    /// end-of-stream. This is the fast path: forward playback and export stay here and never seek. In hardware
    /// mode a GPU surface is transferred to CPU memory before returning.
    /// </summary>
    public unsafe bool TryReadNextFrame(out long framePts)
    {
        framePts = 0;
        while (true)
        {
            var receive = _codecContext.ReceiveFrame(_frame);
            if (receive == CodecResult.Success)
            {
                var pts = _frame.BestEffortTimestamp;
                framePts = pts != NoPts ? pts : _frame.Pts;

                // Read the GPU surface back to CPU memory only when not zero-copy; otherwise leave it on the GPU
                // for the compute-shader converter.
                _lastFrameReadBack = (AVPixelFormat)_frame.Format == AVPixelFormat.D3d11 && !_zeroCopy;
                if (_lastFrameReadBack)
                {
                    _swFrame.Unref();
                    if (ffmpeg.av_hwframe_transfer_data(_swFrame, _frame, 0) < 0)
                        return false;
                }

                return true;
            }

            if (receive == CodecResult.EOF)
                return false;

            // CodecResult.Again — the decoder needs another packet.
            if (_draining)
                return false;

            var read = _formatContext.ReadFrame(_packet);
            if (read == CodecResult.EOF)
            {
                // Flush the decoder so it emits any buffered frames, then drain on the next receive.
                _draining = true;
                SendDrainPacket();
                continue;
            }

            try
            {
                if (_packet.StreamIndex == _videoStreamIndex)
                    _codecContext.SendPacket(_packet);
            }
            finally
            {
                _packet.Unref();
            }
        }
    }

    /// <summary>
    /// Seeks to the keyframe at or before <paramref name="targetPts"/> and flushes the decoder. The caller
    /// then decodes forward (<see cref="TryReadNextFrame"/>) until reaching the target frame.
    /// </summary>
    public void SeekToKeyframeBefore(long targetPts)
    {
        _formatContext.SeekFrame(targetPts, _videoStreamIndex, AVSEEK_FLAG.Backward);
        FlushDecoder();
        _draining = false;
    }

    /// <summary>
    /// Exact seek: keyframe seek then decode-forward to the first frame whose PTS reaches
    /// <paramref name="targetPts"/>. <paramref name="targetPts"/> is expected to already sit on the frame
    /// grid (the controller floors seconds→PTS), so this lands on the intended frame. Returns false if the
    /// stream ends before the target (target past end).
    /// </summary>
    public bool SeekAndDecodeTo(long targetPts, out long framePts)
    {
        SeekToKeyframeBefore(targetPts);
        framePts = 0;
        while (TryReadNextFrame(out var pts))
        {
            framePts = pts;
            if (pts >= targetPts)
                return true;
        }

        return false;
    }

    public unsafe void Dispose()
    {
        _frame.Dispose();
        _swFrame.Dispose();
        _packet.Dispose();
        _codecContext.Dispose();
        _formatContext.Dispose();

        if (_hwDeviceCtx != null)
        {
            var local = _hwDeviceCtx;
            ffmpeg.av_buffer_unref(&local);
            _hwDeviceCtx = null;
        }
    }

    private unsafe VideoDecoderSession(FormatContext formatContext, CodecContext codecContext,
                                       MediaStream videoStream, bool usesHardware, bool zeroCopy, AVBufferRef* hwDeviceCtx)
    {
        _formatContext = formatContext;
        _codecContext = codecContext;
        _videoStreamIndex = videoStream.Index;
        _hwDeviceCtx = hwDeviceCtx;
        UsesHardwareDecode = usesHardware;
        UsesZeroCopy = zeroCopy;
        _zeroCopy = zeroCopy;

        var timeBase = videoStream.TimeBase;
        TimeBaseNum = timeBase.Num;
        TimeBaseDen = timeBase.Den;
        StreamStartPts = videoStream.StartTime != NoPts ? videoStream.StartTime : 0;

        Width = codecContext.Width;
        Height = codecContext.Height;

        // In hardware mode the codec's pix_fmt is D3d11; the CPU read-back is the codec's sw_pix_fmt (Nv12 for
        // 8-bit, P010 for 10-bit). sw_pix_fmt isn't reported until the first decode, so derive it from the
        // bitstream bit depth meanwhile (so the format label, HDR test, and cache budget are right from frame 0).
        var cpuFormat = codecContext.PixelFormat;
        if (usesHardware)
            cpuFormat = HardwareSurfaceFormat(codecContext.SwPixelFormat, (AVPixelFormat)(videoStream.Codecpar?.Format ?? -1));
        PixelFormat = cpuFormat;
        IsHdr = DetectHdr(codecContext, cpuFormat);

        var avg = videoStream.AvgFrameRate;
        FrameRate = avg.Den != 0 ? avg.Num / (double)avg.Den : 0;
        DurationSeconds = ComputeDurationSeconds(formatContext, videoStream, timeBase);
    }

    private static double ComputeDurationSeconds(FormatContext formatContext, MediaStream videoStream, AVRational timeBase)
    {
        if (videoStream.Duration != NoPts && timeBase.Den != 0)
            return videoStream.Duration * timeBase.Num / (double)timeBase.Den;

        // FormatContext.Duration is in AV_TIME_BASE (microsecond) units.
        if (formatContext.Duration > 0)
            return formatContext.Duration / (double)ffmpeg.AV_TIME_BASE;

        return 0;
    }

    private static bool DetectHdr(CodecContext codecContext, AVPixelFormat cpuFormat)
    {
        if (codecContext.ColorTrc is AVColorTransferCharacteristic.Smpte2084 or AVColorTransferCharacteristic.AribStdB67)
            return true;

        return cpuFormat is AVPixelFormat.P010le or AVPixelFormat.P010be
                         or AVPixelFormat.P016le or AVPixelFormat.P016be;
    }

    private unsafe void FlushDecoder() => ffmpeg.avcodec_flush_buffers(_codecContext);

    // A null packet puts the decoder into drain mode so it emits its remaining buffered frames.
    private unsafe void SendDrainPacket() => ffmpeg.avcodec_send_packet(_codecContext, null);

    private static readonly long NoPts = ffmpeg.AV_NOPTS_VALUE;

    private readonly FormatContext _formatContext;
    private readonly CodecContext _codecContext;
    private readonly int _videoStreamIndex;
    private readonly Packet _packet = new();
    private readonly Frame _frame = new();
    private readonly Frame _swFrame = new();
    private unsafe AVBufferRef* _hwDeviceCtx;
    private readonly bool _zeroCopy;
    private bool _lastFrameReadBack;
    private bool _draining;
}