using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.PMR;
using Tango.PMR.Diagnostics;
using Tango.Transport;
using Tango.Transport.Transporters;
using System.Reactive.Linq;
using System.Reactive.Concurrency;
using System.Reactive.Threading;
using Tango.PMR.Common;
using Tango.PMR.Printing;
using Tango.Integration.Observables;
using System.Reactive.Subjects;
using Tango.Integration.Printing;

namespace Tango.Integration.Operators
{
    /// <summary>
    /// Represents the Tango machine operator default implementation.
    /// </summary>
    /// <seealso cref="Tango.Transport.Transporters.BasicTransporter" />
    /// <seealso cref="Tango.Integration.Operators.IMachineOperator" />
    public class MachineOperator : BasicTransporter, IMachineOperator
    {
        #region Events

        /// <summary>
        /// Occurs when there is new diagnostics data available.
        /// </summary>
        public event EventHandler<PushDiagnosticsResponse> DiagnosticsDataAvailable;

        #endregion

        #region Properties

        private bool _enableDiagnostics;
        /// <summary>
        /// Gets or sets a value indicating whether direct the embedded device to send diagnostics messages.
        /// </summary>
        public bool EnableDiagnostics
        {
            get { return _enableDiagnostics; }
            set
            {
                if (_enableDiagnostics != value)
                {
                    _enableDiagnostics = value;
                    RaisePropertyChangedAuto();
                    OnEnableDiagnosticsChanged(value);
                }
            }
        }

        #endregion

        #region Virtual Methods

        /// <summary>
        /// Called when the enable sensors update property has been changed
        /// </summary>
        /// <param name="value">if set to <c>true</c> [value].</param>
        protected virtual void OnEnableDiagnosticsChanged(bool value)
        {
            if (value && State == TransportComponentState.Connected)
            {
                SendContinuousRequest<PushDiagnosticsRequest, PushDiagnosticsResponse>(new TangoMessage<PushDiagnosticsRequest>(new PushDiagnosticsRequest()
                {
                    PushMotors = true,
                    PushSensors = true,

                }, MessageType.PushDiagnosticsRequest)).ObserveOn(new NewThreadScheduler()).Subscribe(
                    (response) =>
                    {
                        OnDiagnosticsDataAvailable(response);
                    },
                    (ex) =>
                    {
                        //Do I need separate event for each one ??
                    },
                    () =>
                    {
                        //What to do now ??
                    });
            }
        }

        /// <summary>
        /// Invokes the <see cref="DiagnosticsDataAvailable"/> event.
        /// </summary>
        /// <param name="data">The sensors data.</param>
        protected virtual void OnDiagnosticsDataAvailable(PushDiagnosticsResponse data)
        {
            DiagnosticsDataAvailable?.Invoke(this, data);
        }

        #endregion

        #region Protected Methods

        /// <summary>
        /// Called when the component state has changed.
        /// </summary>
        /// <param name="state">The state.</param>
        protected override void OnStateChanged(TransportComponentState state)
        {
            base.OnStateChanged(state);

            OnEnableDiagnosticsChanged(EnableDiagnostics);
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Prints the specified job using the specified job parameters.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <param name="processParameters">Process parameters table</param>
        /// <returns></returns>
        public JobHandler Print(Job job, ProcessParametersTable processParameters)
        {
            JobRequest request = new JobRequest();

            JobTicket ticket = new JobTicket();
            ticket.EnableInterSegment = job.EnableInterSegment;
            ticket.InterSegmentLength = job.InterSegmentLength;
            ticket.Length = job.Length;
            ticket.WindingMethod = (JobWindingMethod)job.WindingMethod.Code;

            ProcessParameters process = new ProcessParameters();
            process.DyeingSpeed = processParameters.DyeingSpeed;
            process.MinInkUptake = processParameters.MinInkUptake;
            process.MixerTemp = processParameters.MixerTemp;
            process.HeadZone1Temp = processParameters.HeadZone1Temp;
            process.HeadZone2Temp = processParameters.HeadZone2Temp;
            process.HeadZone3Temp = processParameters.HeadZone3Temp;
            process.HeadAirFlow = processParameters.HeadAirFlow;
            process.FeederTension = processParameters.FeederTension;
            process.PullerTension = processParameters.PullerTension;
            process.DryerBufferLength = processParameters.DryerBufferLength;
            process.DryerZone1Temp = processParameters.DryerZone1Temp;
            process.DryerZone2Temp = processParameters.DryerZone2Temp;
            process.DryerZone3Temp = processParameters.DryerZone3Temp;
            process.DryerAirFlow = processParameters.DryerAirFlow;
            process.WinderTension = processParameters.WinderTension;

            ticket.ProcessParameters = process;

            request.JobTicket = ticket;

            JobHandler handler = null;

            handler = new JobHandler(async () =>
            {
                try
                {
                    var result = await SendRequest<AbortJobRequest, AbortJobResponse>(new AbortJobRequest());
                    handler.RaiseCanceled();
                }
                catch (Exception)
                {
                    //TODO: What to do in case job failed to cancel ??
                }
            });

            SendContinuousRequest<JobRequest, JobResponse>(request).Subscribe((response) =>
            {
                handler.RaiseStatusReceived(response.Message.Status);
            }, (ex) =>
             {
                 if (!handler.IsCanceled)
                 {
                     handler.RaiseFailed(ex);
                 }
             }, () =>
             {
                 handler.RaiseCompleted();
             });

            return handler;
        }

        /// <summary>
        /// Starts jogging the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<MotorJoggingResponse>> StartMotorJogging(MotorJoggingRequest request)
        {
            return SendRequest<MotorJoggingRequest, MotorJoggingResponse>(request);
        }

        /// <summary>
        /// Stops jogging the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<MotorAbortJoggingResponse>> StopMotorJogging(MotorAbortJoggingRequest request)
        {
            return SendRequest<MotorAbortJoggingRequest, MotorAbortJoggingResponse>(request);
        }

        /// <summary>
        /// Starts homing the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public IObservable<TangoMessage<MotorHomingResponse>> StartMotorHoming(MotorHomingRequest request)
        {
            return SendContinuousRequest<MotorHomingRequest, MotorHomingResponse>(request);
        }

        /// <summary>
        /// Stops homing the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<MotorAbortHomingResponse>> StopMotorHoming(MotorAbortHomingRequest request)
        {
            return SendRequest<MotorAbortHomingRequest, MotorAbortHomingResponse>(request);
        }

        /// <summary>
        /// Starts jogging the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<DispenserJoggingResponse>> StartDispenserJogging(DispenserJoggingRequest request)
        {
            return SendRequest<DispenserJoggingRequest, DispenserJoggingResponse>(request);
        }

        /// <summary>
        /// Stops jogging the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<DispenserAbortJoggingResponse>> StopDispenserJogging(DispenserAbortJoggingRequest request)
        {
            return SendRequest<DispenserAbortJoggingRequest, DispenserAbortJoggingResponse>(request);
        }

        /// <summary>
        /// Starts homing the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public IObservable<TangoMessage<DispenserHomingResponse>> StartDispenserHoming(DispenserHomingRequest request)
        {
            return SendContinuousRequest<DispenserHomingRequest, DispenserHomingResponse>(request);
        }

        /// <summary>
        /// Stops homing the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<DispenserAbortHomingResponse>> StopDispenserHoming(DispenserAbortHomingRequest request)
        {
            return SendRequest<DispenserAbortHomingRequest, DispenserAbortHomingResponse>(request);
        }

        /// <summary>
        /// Turn on/off the specified digital output pin.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<SetDigitalOutResponse>> SetDigitalOut(SetDigitalOutRequest request)
        {
            return SendRequest<SetDigitalOutRequest, SetDigitalOutResponse>(request);   
        }

        /// <summary>
        /// Starts jogging the thread motion system.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<ThreadJoggingResponse>> StartThreadJogging(ThreadJoggingRequest request)
        {
            return SendRequest<ThreadJoggingRequest, ThreadJoggingResponse>(request);
        }

        /// <summary>
        /// Stops jogging the thread motion system.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        public Task<TangoMessage<ThreadAbortJoggingResponse>> StopThreadJogging(ThreadAbortJoggingRequest request)
        {
            return SendRequest<ThreadAbortJoggingRequest, ThreadAbortJoggingResponse>(request);
        }


        #endregion
    }
}