using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.PMR.Diagnostics;
using Tango.PMR.Printing;
using Tango.Transport;
using System.Reactive;
using Tango.PMR;
using System.Reactive.Linq;
using Tango.PMR.Debugging;
using Tango.PMR.Hardware;
using Tango.BL.Entities;
using Google.Protobuf;
using Tango.PMR.Connection;
using Tango.PMR.Stubs;
using Tango.Integration.Storage;
using System.IO;
using Tango.Integration.Upgrade;
using Tango.PMR.IO;
using Tango.PMR.FirmwareUpgrade;
using Tango.Integration.JobRuns;
using Tango.Integration.Emergency;
using Tango.PMR.MachineStatus;

namespace Tango.Integration.Operation
{
    /// <summary>
    /// Represents a Tango machine operator.
    /// </summary>
    /// <seealso cref="Tango.Transport.ITransporter" />
    public interface IMachineOperator : ITransporter
    {
        /// <summary>
        /// Gets or sets the job handling mode.
        /// </summary>
        JobHandlerModes JobHandlingMode { get; set; }

        /// <summary>
        /// Gets or sets the job upload strategy.
        /// </summary>
        JobUploadStrategy JobUploadStrategy { get; set; }

        /// <summary>
        /// Gets or sets the job number of units duplication method.
        /// </summary>
        JobUnitsMethods JobUnitsMethod { get; set; }

        /// <summary>
        /// Gets the current machine status.
        /// </summary>
        MachineStatuses Status { get; }

        /// <summary>
        /// Gets or sets a value indicating whether to enable liquid quantity validation before starting the job.
        /// The validation is done using the reported <see cref="MachineStatus"/>.
        /// </summary>
        bool EnableJobLiquidQuantityValidation { get; set; }

        /// <summary>
        /// Gets the machine embedded device status.
        /// </summary>
        MachineStatus MachineStatus { get; }

        /// <summary>
        /// Gets or sets the firmware upgrade mode.
        /// </summary>
        FirmwareUpgradeModes FirmwareUpgradeMode { get; set; }

        /// <summary>
        /// Gets the running job.
        /// </summary>
        Job RunningJob { get; }

        /// <summary>
        /// Gets the running job status.
        /// </summary>
        RunningJobStatus RunningJobStatus { get; }

        /// <summary>
        /// Gets or sets the gradients generation configuration.
        /// </summary>
        IGradientGenerationConfiguration GradientGenerationConfiguration { get; set; }

        /// <summary>
        /// Gets or sets the emergency notification provider.
        /// </summary>
        IEmergencyNotificationProvider EmergencyNotificationProvider { get; set; }

        /// <summary>
        /// Gets a value indicating whether this instance is printing.
        /// </summary>
        bool IsPrinting { get; }

        /// <summary>
        /// Gets a value indicating whether this instance can print.
        /// </summary>
        bool CanPrint { get; }

        /// <summary>
        /// Occurs when the machine <see cref="Status"/> has changed.
        /// </summary>
        event EventHandler<MachineStatuses> StatusChanged;

        /// <summary>
        /// Reports about the job printing preparation progress.
        /// </summary>
        event EventHandler<PreparingJobProgressEventArgs> PreparingJobProgress;

        /// <summary>
        /// Occurs when a printing process has started.
        /// </summary>
        event EventHandler<PrintingEventArgs> PrintingStarted;

        /// <summary>
        /// Occurs when a printing process has failed.
        /// </summary>
        event EventHandler<PrintingFailedEventArgs> PrintingFailed;

        /// <summary>
        /// Occurs when a printing process has been aborted.
        /// </summary>
        event EventHandler<PrintingEventArgs> PrintingAborted;

        /// <summary>
        /// Occurs when a printing process has completed.
        /// </summary>
        event EventHandler<PrintingEventArgs> PrintingCompleted;

        /// <summary>
        /// Occurs when a printing process has ended.
        /// </summary>
        event EventHandler<PrintingEventArgs> PrintingEnded;

        /// <summary>
        /// Occurs when the machine operator has detected that a job is in progress after connecting to the machine.
        /// </summary>
        event EventHandler<ResumingJobEventArgs> ResumingJob;

        /// <summary>
        /// Occurs when a request has been sent.
        /// </summary>
        event EventHandler<IMessage> RequestSent;

        /// <summary>
        /// Occurs when a request response has been received.
        /// </summary>
        event EventHandler<IMessage> ResponseReceived;

        /// <summary>
        /// Occurs when a response has been sent.
        /// </summary>
        event EventHandler<IMessage> ResponseSent;

        /// <summary>
        /// Occurs when a request has failed.
        /// </summary>
        event EventHandler<RequestFailedEventArgs> RequestFailed;

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

        /// <summary>
        /// Occurs when an events notification has been received from the embedded device.
        /// </summary>
        event EventHandler<StartEventsNotificationResponse> EventsNotification;

        /// <summary>
        /// Occurs when a new debug log is available.
        /// </summary>
        event EventHandler<StartDebugLogResponse> DebugLogAvailable;

        /// <summary>
        /// Occurs when machine embedded device status has changed.
        /// </summary>
        event EventHandler<MachineStatus> MachineStatusChanged;

        /// <summary>
        /// Occurs when a new cartridge validation request has been received.
        /// </summary>
        event EventHandler<CartridgeValidationEventArgs> CartridgeValidationRequestReceived;

        /// <summary>
        /// Gets or sets a value indicating whether direct the embedded device to send diagnostics messages.
        /// </summary>
        bool EnableDiagnostics { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether direct the embedded device to send events notification messages.
        /// </summary>
        bool EnableEventsNotification { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to allow incoming debugging messages.
        /// </summary>
        bool EnableEmbeddedDebugging { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to check whether a job is in progress after connection was successful.
        /// </summary>
        bool EnableJobResume { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to direct the embedded device to update about status changes.
        /// </summary>
        bool EnableMachineStatusUpdates { get; set; }

        /// <summary>
        /// Gets the last process parameters table sent to the embedded device.
        /// </summary>
        ProcessParametersTable CurrentProcessParameters { get; }

        /// <summary>
        /// Gets the last hardware configuration sent to the embedded device.
        /// </summary>
        HardwareConfiguration CurrentHardwareConfiguration { get; }

        /// <summary>
        /// Gets or sets the embedded device information.
        /// </summary>
        DeviceInformation DeviceInformation { get; }

        /// <summary>
        /// Gets or sets the machine events state provider used to get notifications about current machine events and errors.
        /// </summary>
        IMachineEventsStateProvider MachineEventsStateProvider { get; set; }

        /// <summary>
        /// Gets or sets the job runs logger.
        /// </summary>
        IJobRunsLogger JobRunsLogger { get; set; }

        /// <summary>
        /// Prints the specified job.
        /// The process parameters table will be calculated using color conversion gamut region.
        /// This method cannot accept brush stops with 'Volume' as color space.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <returns></returns>
        Task<JobHandler> Print(Job job);

        /// <summary>
        /// Executes a print stub for emulating a full job.
        /// The process parameters table will be calculated using color conversion gamut region.
        /// This method cannot accept brush stops with 'Volume' as color space.
        /// </summary>
        /// <param name="job">The job.</param>
        /// <returns></returns>
        Task<JobHandler> PrintStub(Job job);

        /// <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>
        Task<JobHandler> Print(Job job, ProcessParametersTable processParameters);

        /// <summary>
        /// Uploads the specified process parameters to the embedded device.
        /// </summary>
        /// <param name="processParameters">The process parameters.</param>
        /// <returns></returns>
        Task<UploadProcessParametersResponse> UploadProcessParameters(ProcessParametersTable processParameters);

        /// <summary>
        /// Uploads the specified hardware configuration to the embedded device.
        /// </summary>
        /// <param name="hardwareVersion">Machine version.</param>
        /// <param name="configuration">Machine configuration.</param>
        /// <returns></returns>
        Task<UploadHardwareConfigurationResponse> UploadHardwareConfiguration(HardwareVersion hardwareVersion, Configuration configuration);

        /// <summary>
        /// Starts jogging the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<MotorJoggingResponse> StartMotorJogging(MotorJoggingRequest request);

        /// <summary>
        /// Stops jogging the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<MotorAbortJoggingResponse> StopMotorJogging(MotorAbortJoggingRequest request);

        /// <summary>
        /// Starts homing the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        IObservable<MotorHomingResponse> StartMotorHoming(MotorHomingRequest request);

        /// <summary>
        /// Stops homing the specified motor.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<MotorAbortHomingResponse> StopMotorHoming(MotorAbortHomingRequest request);

        /// <summary>
        /// Starts jogging the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<DispenserJoggingResponse> StartDispenserJogging(DispenserJoggingRequest request);

        /// <summary>
        /// Stops jogging the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<DispenserAbortJoggingResponse> StopDispenserJogging(DispenserAbortJoggingRequest request);

        /// <summary>
        /// Starts homing the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        IObservable<DispenserHomingResponse> StartDispenserHoming(DispenserHomingRequest request);

        /// <summary>
        /// Stops homing the specified dispenser.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<DispenserAbortHomingResponse> StopDispenserHoming(DispenserAbortHomingRequest request);

        /// <summary>
        /// Turn on/off the specified digital output pin.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<SetDigitalOutResponse> SetDigitalOut(SetDigitalOutRequest request);

        /// <summary>
        /// Starts jogging the thread motion system.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<ThreadJoggingResponse> StartThreadJogging(ThreadJoggingRequest request);

        /// <summary>
        /// Stops jogging the thread motion system.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<ThreadAbortJoggingResponse> StopThreadJogging(ThreadAbortJoggingRequest request);

        /// <summary>
        /// Sets the specified component value.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        Task<SetComponentValueResponse> SetComponentValue(SetComponentValueRequest request);

        /// <summary>
        /// Sets the state of the specified heater type.
        /// </summary>
        /// <param name="heater">The heater.</param>
        /// <param name="setPoint">Set point temperature.</param>
        /// <returns></returns>
        Task<SetHeaterStateResponse> SetHeaterState(HeaterType heater, double setPoint);

        /// <summary>
        /// Sets the state of the specified blower.
        /// </summary>
        /// <param name="blower">The blower.</param>
        /// <param name="isActive">Blower on/off.</param>
        /// <param name="voltage">The voltage in millivolts.</param>
        /// <returns></returns>
        Task<SetBlowerStateResponse> SetBlowerState(PMR.Hardware.HardwareBlowerType blower, bool isActive, double voltage);

        /// <summary>
        /// Sets the state of the specified valve type.
        /// </summary>
        /// <param name="valve">The valve.</param>
        /// <param name="state">Valve state.</param>
        /// <returns></returns>
        Task<SetValveStateResponse> SetValveState(ValveType valve, ValveStateCode state);

        /// <summary>
        /// Resolves the specified event type.
        /// </summary>
        /// <param name="eventType">Type of the event.</param>
        /// <returns></returns>
        Task<ResolveEventResponse> ResolveEvent(PMR.Diagnostics.EventType eventType);

        /// <summary>
        /// Resets the embedded device.
        /// </summary>
        /// <returns></returns>
        Task<StubFpgaWriteRegResponse> Reset();

        /// <summary>
        /// Resets the device through the DFU channel.
        /// </summary>
        /// <returns></returns>
        Task ResetDFU();

        /// <summary>
        /// Upgrades the firmware.
        /// </summary>
        /// <param name="tfpStream">The TFP stream (Tango Firmware Package File).</param>
        /// <returns></returns>
        Task<FirmwareUpgradeHandler> UpgradeFirmware(Stream tfpStream);

        /// <summary>
        /// Directs the embedded device to validate the last uploaded firmware package.
        /// </summary>
        /// <returns></returns>
        Task ValidateFirmwareVersion(String path);

        /// <summary>
        /// Directs the embedded device to validate the last uploaded firmware package.
        /// </summary>
        /// <returns></returns>
        Task ActivateFirmwareVersion(String path);

        /// <summary>
        /// Gets the firmware update package info.
        /// </summary>
        /// <param name="tfpStream">The TFP (Tango Firmware Package File) stream.</param>
        /// <returns></returns>
        Task<VersionPackageDescriptor> GetFirmwarePackageInfo(Stream tfpStream);

        /// <summary>
        /// Creates a storage manager for managing the machine file system.
        /// </summary>
        /// <returns></returns>
        StorageManager CreateStorageManager();
    }
}