using System;
using System.Threading;
using Chernobyl.DesignPatterns.Pool;
using Chernobyl.Utility;
using System.Diagnostics;

namespace Chernobyl.Threading.Workers
{
    /// <summary>
    /// Worker is both a helper class for implementing new IWorkers and
    /// a default worker implementation.
    /// </summary>
    public class Worker : IWorker
    {
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="name">The name of this worker.</param>
        /// <param name="jobPool">The pool to pull jobs off of to
        /// work on.</param>
        public Worker(string name, IPool<Job> jobPool)
        {
            WorkersThread = new Thread(Work);
            IsWorking = false;
            Name = name;
        }

        /// <summary>
        /// Tells the worker to begin working on the jobs assigned
        /// to him.
        /// </summary>
        virtual public void Start()
        {
            ThreadingPlugin.Trace.TraceEvent(TraceEventType.Start, 0,
                "The Worker \"" + this.Name + "\" is starting." + this.Name);

            lock (_isWorkingLocker)
            {
                if (IsWorking == true)
                    return;

                IsWorking = true;
            }

            // begin executing
            WorkersThread.Start();
        }

        /// <summary>
        /// Tells the worker to stop working on his jobs.
        /// </summary>
        virtual public void Stop()
        {
            ThreadingPlugin.Trace.TraceEvent(TraceEventType.Start, 0,
                "The Worker \"" + this.Name + "\" is stopping." + this.Name);

            lock (_isWorkingLocker)
            {
                if (IsWorking == false)
                    return;

                IsWorking = false;
            }
        }

        /// <summary>
        /// True if this worker is working, i.e. <see cref="Start()"/> was called
        /// and <see cref="Stop()"/> hasn't been called yet.
        /// </summary>
        public bool IsWorking { get; protected set; }

        /// <summary>
        /// Gets and sets the name of this worker.
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// When this worker starts his workday this event is invoked.
        /// </summary>
        public event EventHandler OnWorkStart;

        /// <summary>
        /// When this worker ends his workday this event is invoked.
        /// </summary>
        public event EventHandler OnWorkEnd;

        /// <summary>
        /// The actual method that runs on the workers thread.
        /// Goes through the workers list of jobs and does them.
        /// </summary>
        virtual public void Work()
        {
            // check if someone is asking us to stop working
            while (IsWorking == true)
            {
                // inform listeners that work is starting
                if (OnWorkStart != null)
                    OnWorkStart(this, EventArgs.Empty);

                Job job;
                lock (_jobPool)
                {
                    JobPool.Take(out job);
                }

                // check if someone is asking us to stop working             
                if (IsWorking == false)
                    break;

                // otherwise do the next job
                job.DoJob();

                // inform listeners that work has finished
                if (OnWorkEnd != null)
                    OnWorkEnd(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// Gets/sets the thread that this worker runs his jobs on.
        /// </summary>
        public Thread WorkersThread { get; protected set; }

        /// <summary>
        /// The pool that the worker will pull jobs off
        /// of to work on. The worker is responsible for
        /// pulling getting jobs from the pool, working on 
        /// those jobs, and then giving those jobs back.
        /// </summary>
        public IPool<Job> JobPool
        {
            get { return _jobPool; }
            set { lock (_jobPool) _jobPool = value; }
        }

        /// <summary>
        /// The backing field for <see cref="JobPool"/>.
        /// </summary>
        IPool<Job> _jobPool;

        /// <summary>
        /// An object that can be locked when access to <see cref="IsWorking"/> is needed.
        /// </summary>
        readonly object _isWorkingLocker = new object();
    }
}