using System;
using System.Collections.Generic;
using System.Linq;

namespace Chernobyl.Threading
{
    /// <summary>
    /// Represents a job that can be done by a worker.
    /// </summary>
    public class Job
    {
        /// <summary>
        /// An interface for working with work methods.
        /// </summary>
        public delegate void WorkMethod();

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="workMethod">The method to call when requested to do work.</param>
        /// <param name="name">The name of this job.</param>
        /// <param name="estimatedJobLength">The estimated amount of time this job will take 
        /// to complete in milliseconds.</param>
        public Job(WorkMethod workMethod, string name, float estimatedJobLength)
        {
            TheWorkMethod = workMethod;
            JobLengthLog = new Queue<float>();
            JobLengthLogSize = 5;
            Name = name;
            JobLengthLog.Enqueue(estimatedJobLength);
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="name">The name of this job.</param>
        /// <param name="estimatedJobLength">The estimated amount of time this job will take 
        /// to complete in milliseconds.</param>
        public Job(string name, float estimatedJobLength) : this(DoNothingWorkMethod, name, estimatedJobLength)
        {
        }

        /// <summary>
        /// A method that does nothing. Used as placeholder so that
        /// another work method can be set later.
        /// </summary>
        static private void DoNothingWorkMethod()
        {
        }

        /// <summary>
        /// The function that is called to do this job.
        /// </summary>
        public void DoJob()
        {
            DateTime startTime = DateTime.Now;

            TheWorkMethod();

            DateTime endTime = DateTime.Now;

            // calculate the amount of time it took to complete the job
            TimeSpan jobLength = endTime - startTime;

            // remove a length if we've reached the maximum size 
            // and then add the length to the log
            if (JobLengthLog.Count == JobLengthLogSize)
                JobLengthLog.Dequeue();

            JobLengthLog.Enqueue((float)jobLength.TotalMilliseconds);
        }

        /// <summary>
        /// Gets/sets the method called when this job is asked to do work.
        /// </summary>
        public WorkMethod TheWorkMethod {get; set;}

        /// <summary>
        /// Gets the average amount of time it takes for this job to be completed.
        /// </summary>
        public float AverageJobLength
        {
            get
            {
                if (JobLengthLog.Count == 0)
                    return 1.0f;
                else
                    return JobLengthLog.Average();
            }
        }

        /// <summary>
        /// Gets/sets the length of the job length log.
        /// </summary>
        public uint JobLengthLogSize {get; set;}

        /// <summary>
        /// The name of this job.
        /// </summary>
        public string Name {get; set;}

        /// <summary>
        /// Gets the job length log. The job length log stores the
        /// recorded lengths of time of this job so that an average
        /// can be calculated. 
        /// </summary>
        Queue<float> JobLengthLog {get; set;}
    }
}