using Godot;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Collections.Concurrent;


/// <summary>
/// Base class for eye tracking data producers
/// </summary>
public partial class EyeTrackingProducer : Node
{
    private readonly List<IEyeTrackingObserver> _observers = new List<IEyeTrackingObserver>();

    /// <summary>
    /// Register an observer to receive eye tracking data
    /// </summary>
    public void RegisterObserver(IEyeTrackingObserver observer)
    {
        if (!_observers.Contains(observer))
        {
            _observers.Add(observer);
            GD.Print($"Registered observer: {observer.GetType().Name}");
        }
    }

    /// <summary>
    /// Remove an observer
    /// </summary>
    public void RemoveObserver(IEyeTrackingObserver observer)
    {
        if (_observers.Contains(observer))
        {
            _observers.Remove(observer);
            GD.Print($"Removed observer: {observer.GetType().Name}");
        }
    }

    /// <summary>
    /// Notify all observers with new eye tracking data
    /// </summary>
    protected void NotifyObservers(EyeTrackingData data)
    {
        foreach (var observer in _observers)
        {
            observer.OnEyeDataUpdate(data);
        }
    }
}

/// <summary>
/// Interface for eye tracking data consumers
/// </summary>
public interface IEyeTrackingObserver
{
    /// <summary>
    /// Called when new eye tracking data is available
    /// </summary>
    void OnEyeDataUpdate(EyeTrackingData data);
}

/// <summary>
/// Base class for third-party integrations that consume eye tracking data
/// </summary>
public abstract partial class EyeTrackingConsumer : Node, IEyeTrackingObserver
{
    private bool _enabled = true;

    /// <summary>
    /// Gets or sets whether this consumer is enabled
    /// </summary>
    public bool Enabled
    {
        get => _enabled;
        set
        {
            if (_enabled != value)
            {
                if (value)
                {
                    Enable();
                }
                else
                {
                    Disable();
                }
            }
        }
    }

    /// <summary>
    /// Gets the last received eye tracking data
    /// </summary>
    protected EyeTrackingData LastData { get; private set; }

    /// <summary>
    /// Initializes a new instance of the EyeTrackingConsumer class
    /// </summary>
    /// <param name="name">The name of this consumer</param>
    protected EyeTrackingConsumer(string name = null)
    {
        Name = name ?? GetType().Name;
        Enabled = true;
    }

    /// <summary>
    /// Process new eye tracking data
    /// </summary>
    public virtual void OnEyeDataUpdate(EyeTrackingData data)
    {
        if (Enabled)
        {
            LastData = data;
            ProcessData(data);
        }
    }

    /// <summary>
    /// Process the eye tracking data - to be implemented by subclasses
    /// </summary>
    protected abstract void ProcessData(EyeTrackingData data);

    /// <summary>
    /// Enable this consumer
    /// </summary>
    public virtual void Enable()
    {
        _enabled = true;
        GD.Print($"Enabled {Name}");
    }

    /// <summary>
    /// Disable this consumer
    /// </summary>
    public virtual void Disable()
    {
        _enabled = false;
        GD.Print($"Disabled {Name}");
    }
}

/// <summary>
/// Base class for consumers that process data asynchronously
/// </summary>
public abstract partial class AsyncConsumer : EyeTrackingConsumer
{
    private readonly BlockingCollection<EyeTrackingData> _queue;
    private readonly int _queueSize;
    private Thread _workerThread;
    private bool _running;

    /// <summary>
    /// Initializes a new instance of the AsyncConsumer class
    /// </summary>
    /// <param name="name">The name of this consumer</param>
    /// <param name="queueSize">The maximum size of the queue</param>
    protected AsyncConsumer(string name = null, int queueSize = 100) : base(name)
    {
        _queueSize = queueSize;
        _queue = new BlockingCollection<EyeTrackingData>(queueSize);
    }

    /// <summary>
    /// Queue eye tracking data for async processing
    /// </summary>
    public override void OnEyeDataUpdate(EyeTrackingData data)
    {
        if (Enabled)
        {
            try
            {
                // Try to add to the queue without blocking
                if (!_queue.TryAdd(data))
                {
                    // Skip this update if queue is full
                    GD.PrintErr($"{Name} queue is full - skipping update");
                }
            }
            catch (Exception ex)
            {
                GD.PrintErr($"Error adding data to {Name} queue: {ex.Message}");
                GD.PrintErr(ex.StackTrace);
            }
        }
    }

    /// <summary>
    /// Start the worker thread
    /// </summary>
    public void Start()
    {
        if (!_running)
        {
            _running = true;
            _workerThread = new Thread(WorkerLoop)
            {
                IsBackground = true,
                Name = $"{Name}Worker"
            };
            _workerThread.Start();
            GD.Print($"Started {Name} worker thread");
        }
    }

    /// <summary>
    /// Stop the worker thread
    /// </summary>
    public virtual void Stop()
    {
        _running = false;

        if (_workerThread != null && _workerThread.IsAlive)
        {
            // Give the thread a chance to exit gracefully
            if (!_workerThread.Join(1000))
            {
                // If it doesn't exit in time, we don't force it in this implementation
                // You might want to add more aggressive thread termination if needed
            }

            GD.Print($"Stopped {Name} worker thread");
        }
    }

    /// <summary>
    /// Main worker loop - processes queued data
    /// </summary>
    private void WorkerLoop()
    {
        while (_running)
        {
            try
            {
                // Try to take from the queue with a timeout
                if (_queue.TryTake(out EyeTrackingData data, 100))
                {
                    ProcessData(data);
                }
            }
            catch (Exception ex)
            {
                GD.PrintErr($"Error in {Name} worker: {ex.Message}");
                GD.PrintErr(ex.StackTrace);
                // In C#, we don't re-throw here as that would terminate the thread
                // Instead, we log the error and continue
            }
        }
    }
}