using Google.Protobuf;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.Transport.Servers;
using Tango.Logging;
using Tango.PMR;
using Tango.PMR.Common;
using Tango.PMR.Stubs;
using Tango.Core.Commands;
using Tango.Transport;
using Tango.PMR.Integration;
using Tango.PMR.Diagnostics;
using System.Windows.Forms;
using Google.Protobuf.Collections;
using Tango.PMR.Printing;
using Tango.BL.Entities;
using Tango.PMR.Debugging;
using Tango.BL.Enumerations;
using Tango.BL;
using Tango.PMR.Connection;
using Tango.PMR.Hardware;
using System.Runtime.InteropServices;
using Tango.PMR.IO;
using System.IO;
using Tango.Integration.Operation;
using Tango.PMR.FirmwareUpgrade;
using System.Diagnostics;
using Tango.Core.ExtensionMethods;
using Tango.PMR.MachineStatus;

namespace Tango.Emulations.Emulators
{
    /// <summary>
    /// Represents a Tango machine emulator.
    /// </summary>
    /// <seealso cref="Tango.Emulations.EmulatorBase" />
    public class MachineEmulator : EmulatorBase
    {
        [DllImport("Tango.Emulations.Native.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "ProcessMessage")]
        public static extern int ProcessMessageNative(IntPtr data, int size, ref IntPtr output);

        private class ContinousResponseToken
        {
            public bool Canceled { get; set; }
        }

        private const int MAX_CHUNK_LENGTH = 4000;
        private StartDiagnosticsRequest _diagnosticsRequest;
        private bool _cancelJob;
        private List<PMR.Hardware.HardwareMotorType> _motorJoggingRequestTypes;
        private List<PMR.Hardware.HardwareMotorType> _motorHomingRequestCodes;
        private List<int> _dispenserJoggingRequestCodes;
        private List<int> _dispenserHomingRequestCodes;
        private double _graphAmplitude;
        private double _graphFrequency;
        private List<DigitalInterfaceState> _digitalOutputPinsStates;
        private List<DigitalInterfaceState> _digitalInputPinsStates;
        private List<ValueComponentState> _componentsStates;
        private List<HeaterState> _heater_states;
        private List<ContinousResponseToken> _continousResponseTokens;
        public List<MachineEventState> EventsStates { get; set; }
        private bool _diagnostics_enabled;
        private bool _debug_logs_enabled;
        private bool _events_enabled;
        private bool _machine_updates_enabled;
        private List<SetBlowerStateRequest> _blower_states;
        private List<ValveState> _valveStates;
        private JobTicket _current_job_ticket;
        private String _current_job_resume_token;
        private FileUploadRequest _lastFileUploadRequest;

        #region Properties

        private bool _performNativeRoundTrip;
        /// <summary>
        /// Gets or sets a value indicating whether [perform native round trip].
        /// </summary>
        public bool PerformNativeRoundTrip
        {
            get { return _performNativeRoundTrip; }
            set { _performNativeRoundTrip = value; RaisePropertyChangedAuto(); }
        }

        private bool _emulateCorruption;
        /// <summary>
        /// Gets or sets a value indicating whether emulate corruption in keep alive and job response.
        /// </summary>
        public bool EmulateCorruption
        {
            get { return _emulateCorruption; }
            set
            {
                _emulateCorruption = value;
                RaisePropertyChangedAuto();
                Transporter.EnableKeepAliveAutoResponse = !_emulateCorruption;
            }
        }

        public MachineStatus MachineStatus { get; set; }

        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="MachineEmulator"/> class.
        /// </summary>
        public MachineEmulator() : base()
        {
            Init();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MachineEmulator"/> class.
        /// </summary>
        /// <param name="transporter">The transporter.</param>
        public MachineEmulator(ITransporter transporter) : base(transporter)
        {
            LogManager.Log("Machine emulator initialized using transporter " + transporter.ToString());
            Init();
        }

        #endregion

        #region Private Methods

        private ContinousResponseToken CreateCancelToken()
        {
            ContinousResponseToken t = new ContinousResponseToken();
            _continousResponseTokens.Add(t);
            return t;
        }

        private void Init()
        {
            MachineStatus = new MachineStatus();
            MachineStatus.State = MachineState.Ready;

            for (int i = 0; i < 8; i++)
            {
                MachineStatus.IDSPacksLevels.Add(new IDSPackLevel()
                {
                    Index = i,
                    DispenserLevel = 130000000,
                    MidTankLevel = 2500,
                });
            }

            EventsStates = MachineEventState.GetAllEventsStates();

            _valveStates = new List<ValveState>();
            _blower_states = new List<SetBlowerStateRequest>();
            _heater_states = new List<HeaterState>();
            _continousResponseTokens = new List<ContinousResponseToken>();
            _motorJoggingRequestTypes = new List<PMR.Hardware.HardwareMotorType>();
            _motorHomingRequestCodes = new List<PMR.Hardware.HardwareMotorType>();
            _dispenserJoggingRequestCodes = new List<int>();
            _dispenserHomingRequestCodes = new List<int>();
            _digitalOutputPinsStates = new List<DigitalInterfaceState>();
            _componentsStates = new List<ValueComponentState>();

            ObservablesStaticCollections adapter = ObservablesStaticCollections.Instance;
            adapter.Initialize();

            _digitalOutputPinsStates = adapter.TechIos.Where(x => x.Type == IOType.DigitalOutput.ToInt32()).Select(x => new DigitalInterfaceState()
            {
                InterfaceIO = (InterfaceIOs)x.Code,
            }).ToList();

            _digitalInputPinsStates = adapter.TechIos.Where(x => x.Type == IOType.DigitalInput.ToInt32()).Select(x => new DigitalInterfaceState()
            {
                InterfaceIO = (InterfaceIOs)x.Code,
            }).ToList();

            foreach (var item in adapter.TechControllers)
            {
                _componentsStates.Add(new ValueComponentState()
                {
                    Component = (ValueComponent)item.Code,
                    Value = item.Min
                });
            }

            foreach (var item in adapter.TechHeaters)
            {
                _heater_states.Add(new HeaterState()
                {
                    HeaterType = (HeaterType)item.Code,
                });
            }

            foreach (var item in adapter.HardwareBlowerTypes)
            {
                _blower_states.Add(new SetBlowerStateRequest()
                {
                    BlowerType = (PMR.Hardware.HardwareBlowerType)item.Code,
                });
            }

            foreach (var item in adapter.TechValves)
            {
                _valveStates.Add(new ValveState()
                {
                    ValveType = (ValveType)item.Code,
                    State = (ValveStateCode)Enum.Parse(typeof(ValveStateCode), item.State1.Replace(" ", ""), true),
                });
            }

            ResetGraphFactors();
        }

        private void ResetGraphFactors()
        {
            _graphAmplitude = 75;
            _graphFrequency = 1;
        }

        #endregion

        #region Override Methods

        /// <summary>
        /// Called on new request message.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="container">The container.</param>
        protected override void OnTransporterRequestReceived(object sender, MessageContainer container)
        {
            if (container.Type != MessageType.FileChunkUploadRequest && container.Type != MessageType.FileChunkDownloadRequest)
            {
                LogManager.Log(container.Type.ToString().ToWords() + " received." + Environment.NewLine + MessageFactory.ExtractMessageFromContainer(container).ToJsonString());
            }

            if (PerformNativeRoundTrip)
            {
                NativePMR<MessageContainer, MessageContainer> nativePMR = new NativePMR<MessageContainer, MessageContainer>(ProcessMessageNative);
                var response = nativePMR.Invoke(container);

                if (response != null)
                {
                    container = response;
                }
                else
                {
                    LogManager.Log("Native RoundTrip is not available for " + container.Type.ToString() + ".");
                }
            }

            switch (container.Type)
            {
                case MessageType.CalculateRequest:
                    HandleCalculateRequest(MessageFactory.ParseTangoMessageFromContainer<CalculateRequest>(container));
                    break;
                case MessageType.ProgressRequest:
                    HandleProgressRequest(MessageFactory.ParseTangoMessageFromContainer<ProgressRequest>(container));
                    break;
                case MessageType.StartDiagnosticsRequest:
                    HandleStartDiagnosticsRequest(MessageFactory.ParseTangoMessageFromContainer<StartDiagnosticsRequest>(container));
                    break;
                case MessageType.StopDiagnosticsRequest:
                    HandleStopDiagnosticsRequest(MessageFactory.ParseTangoMessageFromContainer<StopDiagnosticsRequest>(container));
                    break;
                case MessageType.StartEventsNotificationRequest:
                    HandleStartEventsNotificationRequest(MessageFactory.ParseTangoMessageFromContainer<StartEventsNotificationRequest>(container));
                    break;
                case MessageType.StopEventsNotificationRequest:
                    HandleStopEventsNotificationRequest(MessageFactory.ParseTangoMessageFromContainer<StopEventsNotificationRequest>(container));
                    break;
                case MessageType.StartMachineStatusUpdateRequest:
                    HandleStartMachineStatusUpdateRequest(MessageFactory.ParseTangoMessageFromContainer<StartMachineStatusUpdateRequest>(container));
                    break;
                case MessageType.StopMachineStatusUpdateRequest:
                    HandleStopMachineStatusUpdateRequest(MessageFactory.ParseTangoMessageFromContainer<StopMachineStatusUpdateRequest>(container));
                    break;
                case MessageType.JobRequest:
                    HandleJobRequest(MessageFactory.ParseTangoMessageFromContainer<JobRequest>(container));
                    break;
                case MessageType.AbortJobRequest:
                    HandleAbortJobRequest(MessageFactory.ParseTangoMessageFromContainer<AbortJobRequest>(container));
                    break;
                case MessageType.MotorJoggingRequest:
                    HandleMotorJoggingRequest(MessageFactory.ParseTangoMessageFromContainer<MotorJoggingRequest>(container));
                    break;
                case MessageType.MotorAbortJoggingRequest:
                    HandleAbortMotorJoggingRequest(MessageFactory.ParseTangoMessageFromContainer<MotorAbortJoggingRequest>(container));
                    break;
                case MessageType.MotorHomingRequest:
                    HandleMotorHomingRequest(MessageFactory.ParseTangoMessageFromContainer<MotorHomingRequest>(container));
                    break;
                case MessageType.MotorAbortHomingRequest:
                    HandleAbortMotorHomingRequest(MessageFactory.ParseTangoMessageFromContainer<MotorAbortHomingRequest>(container));
                    break;
                case MessageType.DispenserJoggingRequest:
                    HandleDispenserJoggingRequest(MessageFactory.ParseTangoMessageFromContainer<DispenserJoggingRequest>(container));
                    break;
                case MessageType.DispenserAbortJoggingRequest:
                    HandleAbortDispenserJoggingRequest(MessageFactory.ParseTangoMessageFromContainer<DispenserAbortJoggingRequest>(container));
                    break;
                case MessageType.DispenserHomingRequest:
                    HandleDispenserHomingRequest(MessageFactory.ParseTangoMessageFromContainer<DispenserHomingRequest>(container));
                    break;
                case MessageType.DispenserAbortHomingRequest:
                    HandleAbortDispenserHomingRequest(MessageFactory.ParseTangoMessageFromContainer<DispenserAbortHomingRequest>(container));
                    break;
                case MessageType.SetDigitalOutRequest:
                    HandleSetDigitalOutRequest(MessageFactory.ParseTangoMessageFromContainer<SetDigitalOutRequest>(container));
                    break;
                case MessageType.ThreadJoggingRequest:
                    HandleThreadJoggingRequest(MessageFactory.ParseTangoMessageFromContainer<ThreadJoggingRequest>(container));
                    break;
                case MessageType.ThreadAbortJoggingRequest:
                    HandleThreadAbortJoggingRequest(MessageFactory.ParseTangoMessageFromContainer<ThreadAbortJoggingRequest>(container));
                    break;
                case MessageType.StartDebugLogRequest:
                    HandleStartDebugLogRequest(MessageFactory.ParseTangoMessageFromContainer<StartDebugLogRequest>(container));
                    break;
                case MessageType.StopDebugLogRequest:
                    HandleStopDebugLogRequest(MessageFactory.ParseTangoMessageFromContainer<StopDebugLogRequest>(container));
                    break;
                case MessageType.UploadProcessParametersRequest:
                    HandleUploadProcessParametersRequest(MessageFactory.ParseTangoMessageFromContainer<UploadProcessParametersRequest>(container));
                    break;
                case MessageType.SetComponentValueRequest:
                    HandleSetComponentValueRequest(MessageFactory.ParseTangoMessageFromContainer<SetComponentValueRequest>(container));
                    break;
                case MessageType.ResolveEventRequest:
                    HandleResolveEventRequest(MessageFactory.ParseTangoMessageFromContainer<ResolveEventRequest>(container));
                    break;
                case MessageType.DisconnectRequest:
                    HandleDisconnectRequest(MessageFactory.ParseTangoMessageFromContainer<DisconnectRequest>(container));
                    break;
                case MessageType.ConnectRequest:
                    HandleConnectRequest(MessageFactory.ParseTangoMessageFromContainer<ConnectRequest>(container));
                    break;
                case MessageType.UploadHardwareConfigurationRequest:
                    HandleUploadHardwareConfigurationRequest(MessageFactory.ParseTangoMessageFromContainer<UploadHardwareConfigurationRequest>(container));
                    break;
                case MessageType.StubFpgaWriteRegRequest:
                    HandleResetRequest(MessageFactory.ParseTangoMessageFromContainer<StubFpgaWriteRegRequest>(container));
                    break;
                case MessageType.SetHeaterStateRequest:
                    HandleSetHeaterStateRequest(MessageFactory.ParseTangoMessageFromContainer<SetHeaterStateRequest>(container));
                    break;
                case MessageType.SetBlowerStateRequest:
                    HandleSetBlowerStateRequest(MessageFactory.ParseTangoMessageFromContainer<SetBlowerStateRequest>(container));
                    break;
                case MessageType.SetValveStateRequest:
                    HandleSetValveStateRequest(MessageFactory.ParseTangoMessageFromContainer<SetValveStateRequest>(container));
                    break;
                case MessageType.CurrentJobRequest:
                    HandleCurrentJobRequest(MessageFactory.ParseTangoMessageFromContainer<CurrentJobRequest>(container));
                    break;
                case MessageType.ResumeCurrentJobRequest:
                    HandleResumeCurrentJobRequest(MessageFactory.ParseTangoMessageFromContainer<ResumeCurrentJobRequest>(container));
                    break;
                case MessageType.GetStorageInfoRequest:
                    HandleGetStorageInfoRequest(MessageFactory.ParseTangoMessageFromContainer<GetStorageInfoRequest>(container));
                    break;
                case MessageType.GetFilesRequest:
                    HandleGetFilesRequest(MessageFactory.ParseTangoMessageFromContainer<GetFilesRequest>(container));
                    break;
                case MessageType.FileDownloadRequest:
                    HandleFileDownloadRequest(MessageFactory.ParseTangoMessageFromContainer<FileDownloadRequest>(container));
                    break;
                case MessageType.FileChunkDownloadRequest:
                    HandleFileChunkDownloadRequest(MessageFactory.ParseTangoMessageFromContainer<FileChunkDownloadRequest>(container));
                    break;
                case MessageType.CreateRequest:
                    HandleCreateRequest(MessageFactory.ParseTangoMessageFromContainer<CreateRequest>(container));
                    break;
                case MessageType.DeleteRequest:
                    HandleDeleteRequest(MessageFactory.ParseTangoMessageFromContainer<DeleteRequest>(container));
                    break;
                case MessageType.FileUploadRequest:
                    HandleFileUploadRequest(MessageFactory.ParseTangoMessageFromContainer<FileUploadRequest>(container));
                    break;
                case MessageType.FileChunkUploadRequest:
                    HandleFileChunkUploadRequest(MessageFactory.ParseTangoMessageFromContainer<FileChunkUploadRequest>(container));
                    break;
                case MessageType.ValidateVersionRequest:
                    HandleValidateVersionRequest(MessageFactory.ParseTangoMessageFromContainer<ValidateVersionRequest>(container));
                    break;
                case MessageType.ActivateVersionRequest:
                    HandleActivateVersionRequest(MessageFactory.ParseTangoMessageFromContainer<ActivateVersionRequest>(container));
                    break;
            }
        }

        #endregion

        #region Request Handlers

        private void HandleCalculateRequest(TangoMessage<CalculateRequest> request)
        {
            Task.Factory.StartNew(() =>
            {
                var response = MessageFactory.CreateTangoMessage<CalculateResponse>(request.Container.Token);
                response.Message.Sum = request.Message.A + request.Message.B;
                Transporter.SendResponse(response);
            });
        }

        private void HandleProgressRequest(TangoMessage<ProgressRequest> request)
        {
            Task.Factory.StartNew(() =>
            {
                for (int i = 0; i < request.Message.Amount; i++)
                {
                    Thread.Sleep(request.Message.Delay * 10);
                    var res = MessageFactory.CreateTangoMessage<ProgressResponse>(request.Container.Token);
                    res.Message.Progress = i;

                    if (i == request.Message.Amount - 1) res.Container.Completed = true;

                    Transporter.SendResponse(res);
                }
            });
        }

        private void HandleStartDiagnosticsRequest(TangoMessage<StartDiagnosticsRequest> request)
        {
            _diagnostics_enabled = true;

            _diagnosticsRequest = request.Message;

            int value = 0;
            Random rnd = new Random();

            var cancelToken = CreateCancelToken();

            Task.Factory.StartNew(() =>
            {
                while (_diagnostics_enabled && Transporter.State == TransportComponentState.Connected && !cancelToken.Canceled)
                {
                    StartDiagnosticsResponse res = new StartDiagnosticsResponse();
                    DiagnosticsMonitors monitors = new DiagnosticsMonitors();
                    res.Monitors = monitors;

                    for (int i = 0; i < 10; i++)
                    {
                        value++;
                        monitors.Dancer1Angle.Add((int)(150 + _graphAmplitude * Math.Sin(2 * 3.14 * ((int)_graphFrequency) * value)));
                    }

                    var blower_state = _blower_states.FirstOrDefault();

                    if (blower_state != null)
                    {
                        monitors.BlowerVoltage.Add(blower_state.IsActive ? blower_state.Voltage : 0);
                    }

                    int y = Cursor.Position.Y;

                    for (int i = 0; i < 1; i++)
                    {
                        monitors.Dancer2Angle.Add(y);
                    }

                    for (int i = 0; i < 30; i++)
                    {
                        monitors.Dancer3Angle.Add(y);
                    }

                    for (int i = 0; i < MachineStatus.IDSPacksLevels.Count; i++)
                    {
                        var dispensers = new DoubleArray();
                        dispensers.Data.Add(MachineStatus.IDSPacksLevels[i].DispenserLevel);
                        monitors.DispensersInkLevel.Add(dispensers);

                        var midTanks = new DoubleArray();
                        midTanks.Data.Add(MachineStatus.IDSPacksLevels[i].MidTankLevel);
                        monitors.MidTanksInkLevel.Add(midTanks);
                    }

                    var dispenserFrequencies = new RepeatedField<DoubleArray>();

                    double cPosition = Cursor.Position.Y;

                    for (int i = 0; i < 8; i++)
                    {
                        DoubleArray singleDispenser = new DoubleArray();

                        for (int j = 0; j < 10; j++)
                        {
                            singleDispenser.Data.Add(cPosition + (i * 50));
                        }

                        dispenserFrequencies.Add(singleDispenser);
                    }

                    monitors.DispensersMotorsFrequency.AddRange(dispenserFrequencies);

                    monitors.Dispenser1MotorFrequency.AddRange(dispenserFrequencies[0].Data);
                    monitors.Dispenser2MotorFrequency.AddRange(dispenserFrequencies[1].Data);
                    monitors.Dispenser3MotorFrequency.AddRange(dispenserFrequencies[2].Data);
                    monitors.Dispenser4MotorFrequency.AddRange(dispenserFrequencies[3].Data);
                    monitors.Dispenser5MotorFrequency.AddRange(dispenserFrequencies[4].Data);
                    monitors.Dispenser6MotorFrequency.AddRange(dispenserFrequencies[5].Data);
                    monitors.Dispenser7MotorFrequency.AddRange(dispenserFrequencies[6].Data);
                    monitors.Dispenser8MotorFrequency.AddRange(dispenserFrequencies[7].Data);

                    res.DigitalInterfaceStates.AddRange(_digitalOutputPinsStates.Concat(_digitalInputPinsStates));
                    res.ComponentsStates.AddRange(_componentsStates);
                    res.HeatersStates.AddRange(_heater_states);
                    res.ValvesStates.AddRange(_valveStates);

                    if (!EmulateCorruption)
                    {
                        Transporter.SendResponse<StartDiagnosticsResponse>(res, request.Container.Token);
                    }

                    Thread.Sleep(300);
                }
            });

        }

        private void HandleStopDiagnosticsRequest(TangoMessage<StopDiagnosticsRequest> request)
        {
            _diagnostics_enabled = false;
            Transporter.SendResponse<StopDiagnosticsResponse>(new StopDiagnosticsResponse(), request.Container.Token);
        }

        private void HandleStartEventsNotificationRequest(TangoMessage<StartEventsNotificationRequest> request)
        {
            _events_enabled = true;

            var cancelToken = CreateCancelToken();

            Task.Factory.StartNew(() =>
            {
                while (_events_enabled && Transporter.State == TransportComponentState.Connected && !cancelToken.Canceled)
                {
                    var res = new StartEventsNotificationResponse();
                    res.Events.AddRange(EventsStates.Where(x => x.IsActive).Select(x => new Event() { Type = x.EventType, Message = "Generated by Tango Embedded Emulator" }));

                    if (!EmulateCorruption)
                    {
                        Transporter.SendResponse<StartEventsNotificationResponse>(res, request.Container.Token);
                    }

                    Thread.Sleep(1000);
                }
            });
        }

        private void HandleStopEventsNotificationRequest(TangoMessage<StopEventsNotificationRequest> request)
        {
            _events_enabled = false;
            Transporter.SendResponse<StopEventsNotificationResponse>(new StopEventsNotificationResponse(), request.Container.Token);
        }

        private void HandleStartMachineStatusUpdateRequest(TangoMessage<StartMachineStatusUpdateRequest> request)
        {
            _machine_updates_enabled = true;

            var cancelToken = CreateCancelToken();

            Task.Factory.StartNew(() =>
            {
                while (_machine_updates_enabled && Transporter.State == TransportComponentState.Connected && !cancelToken.Canceled)
                {
                    var res = new StartMachineStatusUpdateResponse();
                    res.Status = MachineStatus;

                    if (!EmulateCorruption)
                    {
                        Transporter.SendResponse<StartMachineStatusUpdateResponse>(res, request.Container.Token);
                    }

                    Thread.Sleep(1000);
                }
            });
        }

        private void HandleStopMachineStatusUpdateRequest(TangoMessage<StopMachineStatusUpdateRequest> request)
        {
            _machine_updates_enabled = false;
            Transporter.SendResponse<StopMachineStatusUpdateResponse>(new StopMachineStatusUpdateResponse(), request.Container.Token);
        }

        private void HandleStartDebugLogRequest(TangoMessage<StartDebugLogRequest> request)
        {
            _debug_logs_enabled = true;

            int counter = 1;
            int counter_message = 0;

            var cancelToken = CreateCancelToken();

            Task.Factory.StartNew(() =>
            {
                while (_debug_logs_enabled && Transporter.State == TransportComponentState.Connected && !cancelToken.Canceled)
                {
                    StartDebugLogResponse res = new StartDebugLogResponse();

                    res.FileName = "C:\\demoFile.c";
                    res.LineNumber = 100;
                    res.Filter = 1;
                    res.Message = "This is a false message " + counter;
                    res.Category = DebugLogCategory.Info;

                    if (!EmulateCorruption)
                    {
                        Transporter.SendResponse<StartDebugLogResponse>(res, request.Container.Token);
                    }

                    Thread.Sleep(10);

                    counter_message++;

                    if (counter_message > 10)
                    {
                        counter_message = 0;
                        counter++;
                    }
                }
            });
        }

        private void HandleJobRequest(TangoMessage<JobRequest> request)
        {
            MachineStatus.State = MachineState.PreparingJob;

            JobTicket job = request.Message.JobTicket;
            _current_job_ticket = job;
            _current_job_resume_token = null;

            if (_current_job_ticket.UploadStrategy == JobUploadStrategy.JobDescriptionFile)
            {
                using (FileStream fs = new FileStream(_current_job_ticket.JobDescriptionFile, FileMode.Open))
                {
                    var segments = JobDescriptionFile.ReadJobDescriptionFile(fs);
                    _current_job_ticket.Segments.AddRange(segments);
                }

                var logedTicket = _current_job_ticket.Clone();
                foreach (var segment in logedTicket.Segments)
                {
                    if (segment.BrushStops.Count > 2)
                    {
                        var first = segment.BrushStops.First();
                        var last = segment.BrushStops.Last();
                        segment.BrushStops.Clear();
                        segment.BrushStops.Add(first);
                        segment.BrushStops.Add(last);
                    }
                }

                LogManager.Log("Parsed Job Upload File (Showing first and last brush stop for segment):\n" + logedTicket.ToJsonString());
            }

            double centimeter_per_second = request.Message.JobTicket.ProcessParameters.DyeingSpeed;

            double progress = 0;
            _cancelJob = false;
            bool message_sent = false;
            double length = job.Segments.Sum(x => x.Length) * (Math.Max(job.NumberOfUnits, 1));

            Task.Factory.StartNew(() =>
            {
                MachineStatus.State = MachineState.RunningJob;

                while (progress < length + job.ProcessParameters.DryerBufferLength * ProcessParametersTable.DRYER_METERS_PER_CYCLE && !_cancelJob)
                {
                    var status = new PMR.Printing.JobStatus();
                    status.Progress = progress;

                    if (!message_sent)
                    {
                        message_sent = true;
                        status.Message = "Demo Message From Emulator...";
                    }

                    if (!EmulateCorruption)
                    {
                        if (_current_job_resume_token == null)
                        {
                            Transporter.SendResponse<JobResponse>(new JobResponse()
                            {
                                Status = status,

                            }, request.Container.Token);
                        }
                        else
                        {
                            Transporter.SendResponse<ResumeCurrentJobResponse>(new ResumeCurrentJobResponse()
                            {
                                Status = status,

                            }, _current_job_resume_token);
                        }
                    }

                    progress += Math.Min((centimeter_per_second / 1000d), (length + job.ProcessParameters.DryerBufferLength * ProcessParametersTable.DRYER_METERS_PER_CYCLE) - progress);

                    Thread.Sleep(100);
                }

                _current_job_ticket = null;

                if (_cancelJob)
                {
                    if (_current_job_resume_token == null)
                    {
                        Transporter.SendResponse<JobResponse>(new JobResponse()
                        {

                        }, request.Container.Token, false, ErrorCode.ContinuousResponseAborted);
                    }
                    else
                    {
                        Transporter.SendResponse<ResumeCurrentJobResponse>(new ResumeCurrentJobResponse()
                        {

                        }, _current_job_resume_token, false, ErrorCode.ContinuousResponseAborted);
                    }
                }
                else
                {
                    if (_current_job_resume_token == null)
                    {
                        Transporter.SendResponse<JobResponse>(new JobResponse()
                        {
                            Status = new PMR.Printing.JobStatus()
                            {
                                Progress = length + job.ProcessParameters.DryerBufferLength * ProcessParametersTable.DRYER_METERS_PER_CYCLE,
                            }

                        }, request.Container.Token, !_cancelJob);
                    }
                    else
                    {
                        Transporter.SendResponse<ResumeCurrentJobResponse>(new ResumeCurrentJobResponse()
                        {
                            Status = new PMR.Printing.JobStatus()
                            {
                                Progress = length + job.ProcessParameters.DryerBufferLength * ProcessParametersTable.DRYER_METERS_PER_CYCLE,
                            }

                        }, _current_job_resume_token, !_cancelJob);
                    }
                }

                MachineStatus.State = MachineState.Ready;
            });
        }

        private void HandleAbortJobRequest(TangoMessage<AbortJobRequest> request)
        {
            _cancelJob = true;
            Transporter.SendResponse<AbortJobResponse>(new AbortJobResponse(), request.Container.Token);
        }

        private void HandleMotorJoggingRequest(TangoMessage<MotorJoggingRequest> request)
        {
            var jogRequest = request.Message;

            _motorJoggingRequestTypes.Add(jogRequest.MotorType);


            Task.Factory.StartNew(() =>
            {
                while (_motorJoggingRequestTypes.Contains(jogRequest.MotorType))
                {
                    if (jogRequest.Direction == MotorDirection.Forward)
                    {
                        _graphFrequency = 10;
                    }
                    else
                    {
                        _graphFrequency = 18;
                    }

                    Thread.Sleep(30);
                }

                ResetGraphFactors();
            });

            Transporter.SendResponse<MotorJoggingResponse>(new MotorJoggingResponse(), request.Container.Token);
        }

        private void HandleAbortMotorJoggingRequest(TangoMessage<MotorAbortJoggingRequest> request)
        {
            _motorJoggingRequestTypes.RemoveAll(x => x == request.Message.MotorType);
            ResetGraphFactors();
            Transporter.SendResponse<MotorAbortJoggingResponse>(new MotorAbortJoggingResponse(), request.Container.Token);
        }

        private void HandleMotorHomingRequest(TangoMessage<MotorHomingRequest> request)
        {
            var homeRequest = request.Message;

            _motorHomingRequestCodes.Add(homeRequest.MotorType);

            Task.Factory.StartNew(() =>
            {
                _graphFrequency = 10;

                var inputPin = _digitalInputPinsStates.FirstOrDefault();

                for (int i = 0; i < 100; i++)
                {
                    if (inputPin != null)
                    {
                        inputPin.Value = !inputPin.Value;
                    }

                    Transporter.SendResponse<MotorHomingResponse>(new MotorHomingResponse() { MaxProgress = 100, Progress = i }, request.Container.Token);

                    if (!_motorHomingRequestCodes.Contains(homeRequest.MotorType))
                    {
                        ResetGraphFactors();
                        return;
                    }

                    Thread.Sleep(30);
                }

                Transporter.SendResponse<MotorHomingResponse>(new MotorHomingResponse() { MaxProgress = 100, Progress = 100 }, request.Container.Token, true);
                _motorHomingRequestCodes.Remove(homeRequest.MotorType);
                ResetGraphFactors();
            });
        }

        private void HandleAbortMotorHomingRequest(TangoMessage<MotorAbortHomingRequest> request)
        {
            _motorHomingRequestCodes.RemoveAll(x => x == request.Message.MotorType);
            ResetGraphFactors();
            Transporter.SendResponse<MotorAbortHomingResponse>(new MotorAbortHomingResponse(), request.Container.Token);
        }

        private void HandleDispenserJoggingRequest(TangoMessage<DispenserJoggingRequest> request)
        {
            var jogRequest = request.Message;

            _dispenserJoggingRequestCodes.Add(jogRequest.Index);

            Task.Factory.StartNew(() =>
            {
                while (_dispenserJoggingRequestCodes.Contains(jogRequest.Index))
                {
                    if (jogRequest.Direction == MotorDirection.Forward)
                    {
                        _graphFrequency = 10;
                    }
                    else
                    {
                        _graphFrequency = 18;
                    }

                    Thread.Sleep(30);
                }

                ResetGraphFactors();
            });

            Transporter.SendResponse<DispenserJoggingResponse>(new DispenserJoggingResponse(), request.Container.Token);
        }

        private void HandleAbortDispenserJoggingRequest(TangoMessage<DispenserAbortJoggingRequest> request)
        {
            _dispenserJoggingRequestCodes.RemoveAll(x => x == request.Message.Index);
            ResetGraphFactors();
            Transporter.SendResponse<DispenserAbortJoggingResponse>(new DispenserAbortJoggingResponse(), request.Container.Token);
        }

        private void HandleDispenserHomingRequest(TangoMessage<DispenserHomingRequest> request)
        {
            var homeRequest = request.Message;

            _dispenserHomingRequestCodes.Add(homeRequest.Index);

            Task.Factory.StartNew(() =>
            {
                _graphFrequency = 10;

                for (int i = 0; i < 100; i++)
                {
                    Transporter.SendResponse<DispenserHomingResponse>(new DispenserHomingResponse() { MaxProgress = 100, Progress = i }, request.Container.Token);

                    if (!_dispenserHomingRequestCodes.Contains(homeRequest.Index))
                    {
                        ResetGraphFactors();
                        return;
                    }

                    Thread.Sleep(30);
                }

                Transporter.SendResponse<DispenserHomingResponse>(new DispenserHomingResponse() { MaxProgress = 100, Progress = 100 }, request.Container.Token, true);
                _dispenserHomingRequestCodes.Remove(homeRequest.Index);
                ResetGraphFactors();
            });
        }

        private void HandleAbortDispenserHomingRequest(TangoMessage<DispenserAbortHomingRequest> request)
        {
            _dispenserHomingRequestCodes.RemoveAll(x => x == request.Message.Index);
            ResetGraphFactors();
            Transporter.SendResponse<DispenserAbortHomingResponse>(new DispenserAbortHomingResponse(), request.Container.Token);
        }

        private void HandleSetDigitalOutRequest(TangoMessage<SetDigitalOutRequest> request)
        {
            var pinState = _digitalOutputPinsStates.SingleOrDefault(x => x.InterfaceIO == request.Message.InterfaceIO);
            if (pinState != null)
            {
                pinState.Value = request.Message.Value;
                Transporter.SendResponse<SetDigitalOutResponse>(new SetDigitalOutResponse(), request.Container.Token);
            }
            else
            {
                Transporter.SendResponse<SetDigitalOutResponse>(new SetDigitalOutResponse(), request.Container.Token, null, ErrorCode.InvalidDigitalPinNumber);
            }
        }

        private void HandleThreadJoggingRequest(TangoMessage<ThreadJoggingRequest> request)
        {
            Transporter.SendResponse<ThreadJoggingResponse>(new ThreadJoggingResponse(), request.Container.Token);
        }

        private void HandleThreadAbortJoggingRequest(TangoMessage<ThreadAbortJoggingRequest> request)
        {
            Transporter.SendResponse<ThreadAbortJoggingResponse>(new ThreadAbortJoggingResponse(), request.Container.Token);
        }

        private void HandleUploadProcessParametersRequest(TangoMessage<UploadProcessParametersRequest> request)
        {
            Task.Factory.StartNew(() =>
            {

                Thread.Sleep(1000);
                Transporter.SendResponse<UploadProcessParametersResponse>(new UploadProcessParametersResponse(), request.Container.Token);

            });
        }

        private void HandleSetComponentValueRequest(TangoMessage<SetComponentValueRequest> request)
        {
            var componentState = _componentsStates.SingleOrDefault(x => x.Component == request.Message.Component);

            double startValue = componentState.Value;
            double targetValue = request.Message.Value;

            Transporter.SendResponse<SetComponentValueResponse>(new SetComponentValueResponse(), request.Container.Token);

            Task.Factory.StartNew(() =>
            {
                if (targetValue > startValue)
                {
                    while (componentState.Value < targetValue)
                    {
                        componentState.Value++;
                        Thread.Sleep(30);
                    }
                }
                else
                {
                    while (componentState.Value > targetValue)
                    {
                        componentState.Value--;
                        Thread.Sleep(30);
                    }
                }
            });
        }

        private void HandleResolveEventRequest(TangoMessage<ResolveEventRequest> request)
        {
            EventsStates.Where(x => x.EventType == request.Message.Type).ToList().ForEach(x => x.IsActive = false);
            Transporter.SendResponse<ResolveEventResponse>(new ResolveEventResponse(), request.Container.Token);
        }

        private void HandleDisconnectRequest(TangoMessage<DisconnectRequest> request)
        {
            foreach (var cancelToken in _continousResponseTokens)
            {
                cancelToken.Canceled = true;
            }

            _continousResponseTokens.Clear();
            try
            {
                Transporter.SendResponse<DisconnectResponse>(new DisconnectResponse(), request.Container.Token);
            }
            catch { }
        }

        private void HandleConnectRequest(TangoMessage<ConnectRequest> request)
        {
            if (!EmulateCorruption)
            {
                foreach (var cancelToken in _continousResponseTokens)
                {
                    cancelToken.Canceled = true;
                }

                _continousResponseTokens.Clear();

                Transporter.SendResponse<ConnectResponse>(new ConnectResponse()
                {
                    DeviceInformation = new DeviceInformation()
                    {
                        Version = "1.0.0.0",
                        BuildDate = DateTime.Now.ToString(),
                        Name = "Machine Emulator",
                        FPGA1Version = "1.1",
                        FPGA2Version = "2.2",
                        FPGA3Version = "3.3"
                    },
                }, request.Container.Token, null, request.Message.Password == "1234" ? ErrorCode.None : ErrorCode.UnauthorizedConnection);
            }
        }

        private void HandleStopDebugLogRequest(TangoMessage<StopDebugLogRequest> request)
        {
            _debug_logs_enabled = false;
            Transporter.SendResponse<StopDebugLogResponse>(new StopDebugLogResponse(), request.Container.Token);

        }

        private void HandleUploadHardwareConfigurationRequest(TangoMessage<UploadHardwareConfigurationRequest> request)
        {
            Transporter.SendResponse<UploadHardwareConfigurationResponse>(new UploadHardwareConfigurationResponse(), request.Container.Token);
        }

        private void HandleResetRequest(TangoMessage<StubFpgaWriteRegRequest> request)
        {
            Transporter.SendResponse<StubFpgaWriteRegResponse>(new StubFpgaWriteRegResponse(), request.Container.Token);
        }

        private void HandleSetHeaterStateRequest(TangoMessage<SetHeaterStateRequest> request)
        {
            var heater = _heater_states.SingleOrDefault(x => x.HeaterType == request.Message.HeaterType);

            if (heater != null)
            {
                double startValue = heater.CurrentValue;
                double targetValue = request.Message.SetPoint;

                Task.Factory.StartNew(() =>
                {
                    heater.IsRampingUp = true;
                    heater.IsActive = true;
                    heater.IsInSetPoint = false;
                    heater.SetPoint = targetValue;

                    if (targetValue > startValue)
                    {
                        while (heater.CurrentValue < targetValue)
                        {
                            heater.CurrentValue++;
                            Thread.Sleep(30);
                        }
                    }
                    else
                    {
                        while (heater.CurrentValue > targetValue)
                        {
                            heater.CurrentValue--;
                            Thread.Sleep(30);
                        }
                    }

                    heater.IsRampingUp = false;
                    heater.IsActive = false;
                    heater.IsInSetPoint = true;
                });
            }

            Transporter.SendResponse<SetHeaterStateResponse>(new SetHeaterStateResponse(), request.Container.Token);
        }

        private void HandleSetBlowerStateRequest(TangoMessage<SetBlowerStateRequest> request)
        {
            var blower_state = _blower_states.FirstOrDefault();

            if (blower_state != null)
            {
                blower_state.Voltage = request.Message.Voltage;
                blower_state.IsActive = request.Message.IsActive;
            }

            Transporter.SendResponse<SetBlowerStateResponse>(new SetBlowerStateResponse(), request.Container.Token);
        }

        private void HandleSetValveStateRequest(TangoMessage<SetValveStateRequest> request)
        {
            var valve_state = _valveStates.SingleOrDefault(x => x.ValveType == request.Message.ValveType);

            if (valve_state != null)
            {
                valve_state.State = request.Message.State;
            }

            Transporter.SendResponse<SetValveStateResponse>(new SetValveStateResponse(), request.Container.Token);
        }

        private void HandleCurrentJobRequest(TangoMessage<CurrentJobRequest> request)
        {
            Transporter.SendResponse<CurrentJobResponse>(new CurrentJobResponse()
            {
                IsJobInProgress = _current_job_ticket != null,
                JobTicket = _current_job_ticket,
            }, request.Container.Token);
        }

        private void HandleResumeCurrentJobRequest(TangoMessage<ResumeCurrentJobRequest> request)
        {
            if (_current_job_ticket != null)
            {
                _current_job_resume_token = request.Container.Token;
            }
            else
            {
                Transporter.SendResponse<ResumeCurrentJobResponse>(new ResumeCurrentJobResponse(), request.Container.Token, true, ErrorCode.NoJobInProgress);
            }
        }

        private void HandleGetStorageInfoRequest(TangoMessage<GetStorageInfoRequest> request)
        {
            var d = new DriveInfo("C");

            Directory.CreateDirectory("C:\\EmulatorStorage");

            Transporter.SendResponse<GetStorageInfoResponse>(new GetStorageInfoResponse()
            {
                Capacity = d.TotalSize,
                FreeSpace = d.TotalFreeSpace,
                Root = "/"
            }, request.Container.Token);
        }

        private void HandleGetFilesRequest(TangoMessage<GetFilesRequest> request)
        {
            GetFilesResponse response = new GetFilesResponse();

            bool failed = false;
            String msg = null;

            try
            {
                String path = request.Message.Path;

                bool replaceSlash = path.Contains("/");

                foreach (var dir in Directory.GetDirectories(path))
                {
                    DirectoryInfo dirInfo = new DirectoryInfo(dir);

                    response.Items.Add(new PMR.IO.FileInfo()
                    {
                        Attribute = FileAttribute.Directory,
                        FullPath = replaceSlash ? dir.Replace("\\", "/") : dir,
                        LastModifiedDate = dirInfo.LastWriteTime.DayOfYear,
                        LastModifiedTime = dirInfo.LastWriteTime.Hour,
                        Name = Path.GetFileName(dir),
                    });
                }

                foreach (var file in Directory.GetFiles(path))
                {
                    System.IO.FileInfo fileInfo = new System.IO.FileInfo(file);

                    response.Items.Add(new PMR.IO.FileInfo()
                    {
                        Attribute = FileAttribute.Unspecified,
                        FullPath = replaceSlash ? file.Replace("\\", "/") : file,
                        LastModifiedDate = fileInfo.LastWriteTime.DayOfYear,
                        LastModifiedTime = fileInfo.LastWriteTime.Hour,
                        Name = Path.GetFileName(file),
                        Length = (int)fileInfo.Length,
                    });
                }
            }
            catch (Exception ex)
            {
                failed = true;
                msg = ex.Message;
            }

            Transporter.SendResponse<GetFilesResponse>(response, request.Container.Token, false, failed ? ErrorCode.GeneralError : ErrorCode.None, msg);
        }

        private void HandleFileDownloadRequest(TangoMessage<FileDownloadRequest> request)
        {
            long length = File.Exists(request.Message.FileName) ? new System.IO.FileInfo(request.Message.FileName).Length : 0;

            Transporter.SendResponse<FileDownloadResponse>(new FileDownloadResponse()
            {
                DownloadID = Guid.NewGuid().ToString(),
                MaxChunkLength = Math.Min(MAX_CHUNK_LENGTH, length),
            }, request.Container.Token, null, File.Exists(request.Message.FileName) ? ErrorCode.None : ErrorCode.FileNotFound);
        }

        private void HandleFileChunkDownloadRequest(TangoMessage<FileChunkDownloadRequest> request)
        {
            var message = request.Message;

            try
            {
                using (FileStream fs = new FileStream(message.FileName, FileMode.Open))
                {
                    fs.Position = message.Position;
                    byte[] buffer = new byte[Math.Min(MAX_CHUNK_LENGTH, fs.Length - fs.Position)];
                    fs.Read(buffer, 0, buffer.Length);
                    Transporter.SendResponse<FileChunkDownloadResponse>(new FileChunkDownloadResponse()
                    {
                        Buffer = ByteString.CopyFrom(buffer),
                    }, request.Container.Token);
                }
            }
            catch (Exception ex)
            {
                Transporter.SendResponse<FileChunkDownloadResponse>(new FileChunkDownloadResponse()
                {

                }, request.Container.Token, null, ErrorCode.FileRequestDenied, ex.Message);
            }
        }

        private void HandleCreateRequest(TangoMessage<CreateRequest> request)
        {
            try
            {
                Directory.CreateDirectory(request.Message.Path);
                Transporter.SendResponse<CreateResponse>(new CreateResponse(), request.Container.Token);
            }
            catch (Exception ex)
            {
                Transporter.SendResponse<CreateResponse>(new CreateResponse(), request.Container.Token, null, ErrorCode.FileRequestInvalidParameter, ex.Message);
            }
        }

        private void HandleDeleteRequest(TangoMessage<DeleteRequest> request)
        {
            try
            {
                if (request.Message.Attribute == FileAttribute.Directory)
                {
                    Directory.Delete(request.Message.Path, true);
                }
                else
                {
                    File.Delete(request.Message.Path);
                }

                Transporter.SendResponse<DeleteResponse>(new DeleteResponse(), request.Container.Token);
            }
            catch (Exception ex)
            {
                Transporter.SendResponse<DeleteResponse>(new DeleteResponse(), request.Container.Token, null, ErrorCode.FileRequestInvalidParameter, ex.Message);
            }
        }

        private void HandleFileUploadRequest(TangoMessage<FileUploadRequest> request)
        {
            var message = request.Message;
            _lastFileUploadRequest = message;
            Transporter.SendResponse<FileUploadResponse>(new FileUploadResponse()
            {
                MaxChunkLength = MAX_CHUNK_LENGTH,
                UploadID = Guid.NewGuid().ToString(),
            }, request.Container.Token);
        }

        private void HandleFileChunkUploadRequest(TangoMessage<FileChunkUploadRequest> request)
        {
            var message = request.Message;

            try
            {
                using (FileStream fs = new FileStream(message.Path, FileMode.Append))
                {
                    byte[] buffer = message.Buffer.ToByteArray();
                    fs.Write(buffer, 0, buffer.Length);

                    Debug.WriteLine($"Emulator file upload '{_lastFileUploadRequest.Path}' {fs.Length}/{_lastFileUploadRequest.Length} ...");
                }

                Transporter.SendResponse<FileChunkUploadResponse>(new FileChunkUploadResponse(), request.Container.Token);
            }
            catch (Exception ex)
            {
                Transporter.SendResponse<FileChunkUploadResponse>(new FileChunkUploadResponse(), request.Container.Token, null, ErrorCode.GeneralError, ex.Message);
            }
        }

        private void HandleValidateVersionRequest(TangoMessage<ValidateVersionRequest> request)
        {
            Task.Factory.StartNew(() =>
            {
                Thread.Sleep(3000);

                try
                {
                    using (FileStream fs = new FileStream(Path.Combine(request.Message.Path, MachineOperator.FIRMWARE_UPGRADE_CONFIG_FILE_NAME), FileMode.Open))
                    {
                        VersionPackageDescriptor package = VersionPackageDescriptor.Parser.ParseFrom(fs);
                    }

                    Transporter.SendResponse<ValidateVersionResponse>(new ValidateVersionResponse(), request.Container.Token);
                }
                catch (Exception ex)
                {
                    Transporter.SendResponse<ValidateVersionResponse>(new ValidateVersionResponse(), request.Container.Token, null, ErrorCode.GeneralError, ex.Message);
                }
            });
        }

        private void HandleActivateVersionRequest(TangoMessage<ActivateVersionRequest> request)
        {
            Task.Factory.StartNew(() =>
            {
                Thread.Sleep(3000);

                try
                {
                    using (FileStream fs = new FileStream(Path.Combine(request.Message.Path, MachineOperator.FIRMWARE_UPGRADE_CONFIG_FILE_NAME), FileMode.Open))
                    {
                        VersionPackageDescriptor package = VersionPackageDescriptor.Parser.ParseFrom(fs);
                    }

                    Transporter.SendResponse<ActivateVersionResponse>(new ActivateVersionResponse(), request.Container.Token);
                }
                catch (Exception ex)
                {
                    Transporter.SendResponse<ActivateVersionResponse>(new ActivateVersionResponse(), request.Container.Token, null, ErrorCode.GeneralError, ex.Message);
                }
            });
        }

        #endregion

        #region Public Methods

        public async Task<int> ValidateCartridge()
        {
            var response = await Transporter.SendRequest<CartridgeValidationRequest, CartridgeValidationResponse>(new CartridgeValidationRequest()
            {
                Action = CartridgeAction.Inserted,

            }, TimeSpan.FromSeconds(10));

            return response.Message.Index;
        }

        #endregion
    }
}