using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using Tango.Core;
using Tango.Core.DI;
using Tango.Integration.Operation;
using Tango.PPC.Common.Connection;
using Tango.PPC.Common.Messages;
using Tango.PPC.Common.Models;
using Tango.PPC.Common.Navigation;
using Tango.PPC.Common.Printing;
using Tango.PPC.Jobs.Messages;

namespace Tango.PPC.UI.Printing
{
    /// <summary>
    /// Represents a printing manager capable of executing jobs, changing job statuses according to completion stage and generating sample and fine tuning jobs.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.PPC.Common.Printing.IPrintingManager" />
    public class DefaultPrintingManager : ExtendedObject, IPrintingManager
    {
        private IMachineProvider _machineProvider;

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultPrintingManager"/> class.
        /// </summary>
        /// <param name="machineProvider">The machine provider.</param>
        public DefaultPrintingManager(IMachineProvider machineProvider)
        {
            _machineProvider = machineProvider;
        }

        /// <summary>
        /// Prints the specified job.
        /// When the job is complete the job status will change according to the completion stage.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public async Task<JobHandler> Print(Job job, ObservablesContext context)
        {

#if STUBPRINT
                var handler = await _machineProvider.MachineOperator.PrintStub(job);
#else
                var handler = await _machineProvider.MachineOperator.Print(job);
#endif

            handler.Completed += async (x, e) =>
            {
                try
                {

                    job.JobStatus = BL.Enumerations.JobStatuses.Completed;
                    await context.SaveChangesAsync();
                    RaiseJobSaved(job);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after job printing completed.");
                }
            };
            handler.Canceled += async (x, e) =>
            {
                try
                {
                    //No change in status !
                    await context.SaveChangesAsync();
                    RaiseJobSaved(job);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after job printing completed.");
                }
            };
            handler.Failed += async (x, e) =>
            {
                try
                {

                    job.JobStatus = BL.Enumerations.JobStatuses.Disrupted;
                    await context.SaveChangesAsync();
                    RaiseJobSaved(job);
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after job printing completed.");
                }
            };


            return handler;
        }

        /// <summary>
        /// Creates a sample dye job from the specified job and prints it.
        /// When the sample dye job is complete, the job sample dye status will change.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public async Task<JobHandler> PrintSample(Job job, ObservablesContext context)
        {
            LogManager.Log("Cloning job...");
            Job sampleDyeJob = job.Clone();
            sampleDyeJob.Guid = job.Guid;
            sampleDyeJob.Designation = BL.Enumerations.JobDesignations.SampleDye;
            sampleDyeJob.Name = job.Name;

            if (job.JobType == BL.Enumerations.JobTypes.Embroidery)
            {
                sampleDyeJob.NumberOfUnits = job.SampleUnitsOrMeters;
            }
            else
            {
                sampleDyeJob.NumberOfUnits = 1;

                foreach (var segment in sampleDyeJob.OrderedSegments)
                {
                    segment.Length = job.SampleUnitsOrMeters;
                }
            }

            context.SaveChanges();
            RaiseJobSaved(job);

            LogManager.Log("Executing sample dye job...");

            var handler = await _machineProvider.MachineOperator.Print(sampleDyeJob);
            handler.Completed += async (x, e) =>
            {
                try
                {
                    job.JobEditingState = BL.Enumerations.EditingStates.SampleDye;
                    job.JobSampleDyeStatus = BL.Enumerations.SampleDyeStatuses.PendingApproval;
                    await context.SaveChangesAsync();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after sample dye printing completed.");
                }
            };

            return handler;
        }

        /// <summary>
        /// Creates a fine tuning job from the specified job and fine tune items.
        /// When the fine tuning job is complete, the job fine tuning status will change.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <param name="context">The context.</param>
        /// <param name="fineTuneItems">The fine tune items.</param>
        /// <returns></returns>
        public async Task<JobHandler> PrintFineTuning(Job job, ObservablesContext context, IEnumerable<FineTuneItem> fineTuneItems)
        {
            LogManager.Log("Cloning job...");
            Job fineTuneJob = job.Clone();
            fineTuneJob.NumberOfUnits = 1;
            fineTuneJob.Designation = BL.Enumerations.JobDesignations.FineTuning;
            fineTuneJob.Guid = job.Guid;
            fineTuneJob.Name = job.Name;
            fineTuneJob.Segments.Clear();

            foreach (var suggestion in fineTuneItems.Where(x => x.IsSelected).SelectMany(x => x.Suggestions))
            {
                var segment = fineTuneJob.AddSolidSegment(suggestion.Color);
            }

            var handler = await _machineProvider.MachineOperator.Print(fineTuneJob);
            handler.Completed += async (x, e) =>
            {
                try
                {
                    job.JobEditingState = BL.Enumerations.EditingStates.FineTuning;
                    job.JobFineTuningStatus = BL.Enumerations.FineTuningStatuses.PendingApproval;
                    await context.SaveChangesAsync();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error occurred after fine tunning job completed.");
                }
            };

            return handler;
        }

        /// <summary>
        /// Raises the job saved messenger message.
        /// </summary>
        /// <param name="job">The job.</param>
        private void RaiseJobSaved(Job job)
        {
            TangoMessenger.Default.Send(new JobSavedMessage() { Job = job });
        }
    }
}