using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading;
using Godot;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;

public partial class DGifPlayer : Node
{
    private ImageTexture texture;
    private List<byte[]> frames = new();
    private List<int> delays = new(); // in 1/100 sec
    private int width;
    private int height;

    private Thread playThread;
    private bool running;
    private int currentFrame = 0;

    private float frameTimer = 0f;

    public ImageTexture Texture => texture;

    /// <summary>
    /// Load GIF file and prepare frames
    /// </summary>
    public bool Load(string path)
    {
        if (!System.IO.File.Exists(path))
        {
            GD.PrintErr("Unable to find gif file: " + path);
            return false;
        }
        frames.Clear();
        delays.Clear();

        try
        {
            using var gif = SixLabors.ImageSharp.Image.Load<Rgba32>(path);

            width = gif.Width;
            height = gif.Height;
            texture = null;

            foreach (var frame in gif.Frames)
            {
                // Copy pixels to RGBA byte array
                var pixels = new byte[width * height * 4];
                frame.CopyPixelDataTo(pixels);
                frames.Add(pixels);

                // Frame delay in 1/100 sec
                var delay = frame.Metadata.GetGifMetadata().FrameDelay;
                delays.Add(delay > 0 ? delay : 10); // fallback to 100ms if 0
            }
        }
        catch(Exception ex)
        {
            GD.PrintErr("Failed to load gif file: " + ex.Message);
        }

        return true;
    }

    /// <summary>
    /// Start playback
    /// </summary>
    public void Play()
    {
        if (frames.Count == 0) return;

        running = true;
        playThread = new Thread(PlayLoop) { IsBackground = true };
        playThread.Start();
    }

    /// <summary>
    /// Stop playback
    /// </summary>
    public void Stop()
    {
        running = false;
        playThread?.Join();
    }

    /// <summary>
    /// Worker thread: cycles frames based on GIF delays
    /// </summary>
    private void PlayLoop()
    {
        while (running)
        {
            try
            {
                byte[] frameData = frames[currentFrame];

                // Push update to main thread
                CallDeferred(nameof(UpdateTexture), frameData);

                // Wait for frame delay
                int delayMs = delays[currentFrame] * 10; // GIF delay is in 1/100 sec
                Thread.Sleep(delayMs);

                // Next frame
                currentFrame = (currentFrame + 1) % frames.Count;
            }
            catch(Exception ex)
            {
                GD.PrintErr(ex.Message);
                break;
            }
        }
    }

    /// <summary>
    /// Update Godot texture with frame data
    /// </summary>
    private void UpdateTexture(byte[] frameData)
    {
        var img = Godot.Image.CreateFromData(width, height, false, Godot.Image.Format.Rgba8, frameData);

        if (texture == null)
        {
            texture = ImageTexture.CreateFromImage(img);
        }
        else
        {
            texture.Update(img);
        }
    }


    public void GifDispose()
    {
        Stop();
        frames.Clear();
        delays.Clear();
    }
}