using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Pithos.Core.Agents;

namespace Pithos.Core
{
    public class Agent<TMessage> : IDisposable
    {
        private readonly ConcurrentQueue<TMessage> _queue;
        private readonly BlockingCollection<TMessage> _messages;
        private readonly CancellationTokenSource _cancelSource = new CancellationTokenSource();
        public CancellationToken CancellationToken;

        private readonly Action<Agent<TMessage>> _process;


        public Agent(Action<Agent<TMessage>> action)
        {
            _queue=new ConcurrentQueue<TMessage>();
            _messages = new BlockingCollection<TMessage>(_queue);
            _process = action;
            CancellationToken = _cancelSource.Token;
        }

        public void Post(TMessage message)
        {
            _messages.Add(message);
        }

        /// <summary>
        /// Receives a message asynchronously, optionally with a timeout. Receive throws a TimeoutException if the timeout expires
        /// </summary>
        /// <param name="timeout">Optional timeout in milliseconds. If provided, Receive fails with a TimeoutException if no message is available in the specified time</param>
        /// <returns>A Task that will return the message asynchronously</returns>
        public Task<TMessage> Receive(int timeout = -1)
        {
            return Task<TMessage>.Factory.StartNew(() =>
            {
                TMessage item;
                if (!_messages.TryTake(out item, timeout, CancellationToken))
                    throw new TimeoutException();
                return item;
            });
        }


        /// <summary>
        /// Receives a message asynchronously, optionally with a timeout. TryReceive returns an empty task if the timeout expires
        /// </summary>
        /// <param name="timeout">Optional timeout in milliseconds. If provided, Receive returns an empty task</param>
        /// <returns>A Task that will return the message asynchronously</returns>
        public Task<TMessage> TryReceive(int timeout = -1)
        {
            return Task<TMessage>.Factory.StartNew(() =>
            {
                TMessage item;
                _messages.TryTake(out item, timeout, CancellationToken);
                return item;
            });
        }



        /// <summary>
        /// Start the agent
        /// </summary>
        public void Start()
        {
            Task.Factory.StartNew(() => _process(this), CancellationToken);            
        }


        /// <summary>
        /// Create and start a new agent for the specified type of message
        /// </summary>
        /// <param name="action">The message processing action</param>
        /// <returns>A started Agent</returns>
        public static Agent<TMessage> Start(Action<Agent<TMessage>> action)
        {
            var agent = new Agent<TMessage>(action);
            agent.Start();
            return agent;
        }

        /// <summary>
        /// Stops the agent 
        /// </summary>
        public void Stop()
        {
            //Stop the message queue
            _messages.CompleteAdding();
            //And signal the cancellation
            _cancelSource.Cancel();
        }

        /// <summary>
        /// Execute an action asynchronously, using the agent's cancellation source
        /// </summary>
        /// <param name="action">The action to execute</param>
        public void DoAsync(Action action)
        {
            Contract.Requires(action!=null);
            Task.Factory.StartNew(action, CancellationToken);
        }


        ~Agent()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected void Dispose(bool disposing)
        {
            if (disposing)
            {
                Stop();
                _messages.Dispose();
                _cancelSource.Dispose();
            }
        }

        public IEnumerable<TMessage> GetEnumerable()
        {
            return _messages;
        }

        /// <summary>
        /// Remove the first message that matches the predicate
        /// </summary>
        /// <param name="predicate">The condition to match</param>
        /// <remarks>Removes the first message that matches the predicate by dequeing all 
        /// messages and re-enqueing all except the first matching message</remarks>
        public void Remove(Func<TMessage,bool> predicate)
        {
            //Can this work? Dequeue all items 
            //and then enqueue everything except the filtered items

            _queue.RemoveFirst(predicate);
        }

        public Task LoopAsync(Task process, Action loop,Action<Exception> onError=null)
        {
            Contract.Requires(process!=null);
            Contract.Requires(loop!=null);

            return process.ContinueWith(t =>
            {   
             
                Task.Factory.StartNew(loop, CancellationToken);

                if (t.IsFaulted)
                {
                    var ex = t.Exception.InnerException;
                    if (ex is OperationCanceledException)
                        Stop();
                    if (onError != null)
                        onError(ex);
                }
            },CancellationToken);
        }

        public Task<T> LoopAsync<T>(Task<T> process, Action loop,Action<Exception> onError=null)
        {
            return process.ContinueWith(t =>
            {   
                //Spawn the Loop immediatelly
                Task.Factory.StartNew(loop,CancellationToken);
                //Then process possible exceptions
                if (t.IsFaulted)
                {
                    var ex = t.Exception.InnerException;
                    if (ex is OperationCanceledException)
                        Stop();
                    if (onError != null)
                        onError(ex);
                }
                return default(T);
            },CancellationToken);
        }
    }
}