using System;
using System.Collections.Generic;
using System.Threading;

namespace EyeTracking
{
    /// <summary>
    /// Handles buffering and processing of eye tracking data with configurable buffer sizes
    /// and analysis capabilities for smooth data processing
    /// </summary>
    public class EyeTrackingBuffer
    {
        private readonly Queue<EyeTrackingData> _dataBuffer;
        private readonly object _bufferLock = new object();
        private readonly int _maxBufferSize;
        private readonly int _minBufferSize;
        private readonly Func<List<EyeTrackingData>, EyeTrackingData> _analyzeChunkData;
        private readonly Action<EyeTrackingData> _processData;
        private readonly Func<bool> _canProcess;

        /// <summary>
        /// Initializes a new instance of the EyeTrackingBuffer class
        /// </summary>
        /// <param name="maxBufferSize">Maximum number of data points to buffer</param>
        /// <param name="minBufferSize">Minimum buffer size before processing begins</param>
        /// <param name="analyzeChunkData">Function to analyze chunk data and return processed data</param>
        /// <param name="processData">Action to process the analyzed data</param>
        /// <param name="canProcess">Function to check if processing is allowed (optional)</param>
        public EyeTrackingBuffer(
            int maxBufferSize = 40,
            int minBufferSize = 10,
            Func<List<EyeTrackingData>, EyeTrackingData> analyzeChunkData = null,
            Action<EyeTrackingData> processData = null,
            Func<bool> canProcess = null)
        {
            _maxBufferSize = maxBufferSize;
            _minBufferSize = minBufferSize;
            _analyzeChunkData = analyzeChunkData ?? DefaultAnalyzeChunkData;
            _processData = processData ?? DefaultProcessData;
            _canProcess = canProcess ?? (() => true);
            
            _dataBuffer = new Queue<EyeTrackingData>();
        }

        /// <summary>
        /// Adds new eye tracking data to the buffer and triggers processing if conditions are met
        /// </summary>
        /// <param name="data">Eye tracking data to add</param>
        public void AddData(EyeTrackingData data)
        {
            lock (_bufferLock)
            {
                // Add new data to buffer
                _dataBuffer.Enqueue(data);

                // Remove oldest data if buffer exceeds maximum size
                while (_dataBuffer.Count > _maxBufferSize)
                {
                    _dataBuffer.Dequeue();
                }
            }
            
            ProcessBufferData();
        }

        /// <summary>
        /// Processes buffered data if conditions are met
        /// </summary>
        public void ProcessBufferData()
        {
            if (!_canProcess())
                return;

            bool shouldProcess = false;
            int bufferCount;

            lock (_bufferLock)
            {
                bufferCount = _dataBuffer.Count;
                shouldProcess = bufferCount >= _minBufferSize;
            }

            if (shouldProcess)
            {
                ProcessOneFrameFromBuffer();
            }
        }

        /// <summary>
        /// Processes one frame from the buffer using the configured analysis function
        /// </summary>
        private void ProcessOneFrameFromBuffer()
        {
            EyeTrackingData dataToProcess = null;
            List<EyeTrackingData> currentBuffer = new List<EyeTrackingData>();

            lock (_bufferLock)
            {
                if (_dataBuffer.Count > 0)
                {
                    // Get the oldest data point to process
                    dataToProcess = _dataBuffer.Dequeue();
                    
                    // Create a copy of the remaining buffer for analysis
                    currentBuffer = new List<EyeTrackingData>(_dataBuffer);
                }
            }

            if (dataToProcess != null)
            {
                // Analyze the current buffer context (including the frame we're about to process)
                // Add the frame we're processing to the analysis buffer
                currentBuffer.Insert(0, dataToProcess);
                EyeTrackingData processedData = _analyzeChunkData(currentBuffer);
                
                // Process the analyzed data
                _processData(processedData);
            }
        }

        /// <summary>
        /// Clears all buffered data
        /// </summary>
        public void Clear()
        {
            lock (_bufferLock)
            {
                _dataBuffer.Clear();
            }
        }

        /// <summary>
        /// Gets the current number of items in the buffer
        /// </summary>
        public int Count
        {
            get
            {
                lock (_bufferLock)
                {
                    return _dataBuffer.Count;
                }
            }
        }

        /// <summary>
        /// Default analysis function that returns the first frame unchanged
        /// </summary>
        /// <param name="chunkData">List of eye tracking data</param>
        /// <returns>The first frame from the chunk</returns>
        private static EyeTrackingData DefaultAnalyzeChunkData(List<EyeTrackingData> chunkData)
        {
            return chunkData.Count > 0 ? chunkData[0] : new EyeTrackingData();
        }

        /// <summary>
        /// Default process function that does nothing
        /// </summary>
        /// <param name="data">Eye tracking data to process</param>
        private static void DefaultProcessData(EyeTrackingData data)
        {
            // Default implementation does nothing
        }
    }
}