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;
using Tango.PMR.ThreadLoading;
using Tango.PMR.Power;
using Tango.PMR.IFS;
using Tango.BL.Enumerations;

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 or sets the way of calculating how much liquid was spent during the job.
        /// </summary>
        JobLiquidQuantityCalculationMode JobLiquidQuantityCalculationMode { get; set; }

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

        /// <summary>
        /// Gets or sets the type of the machine.
        /// </summary>
        MachineTypes MachineType { get; set; }

        /// <summary>
        /// Gets a value indicating whether the machine is connected and status is not disconnected.
        /// </summary>
        bool IsConnected { 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 the current thread loading status.
        /// </summary>
        StartThreadLoadingResponse ThreadLoadingStatus { get; }

        /// <summary>
        /// Gets the ink filling status.
        /// </summary>
        InkFillingStatus InkFillingStatus { 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>
        /// Gets or sets the general continuous request timeout.
        /// </summary>
        TimeSpan ContinuousRequestTimeout { get; set; }

        /// <summary>
        /// Gets a value indicating whether the spool was replaced after the last job.
        /// </summary>
        bool IsSpoolReplaced { 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 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>
        /// Occurs when the machine was connected and device has reported IsAfterReset.
        /// </summary>
        event EventHandler FirmwareStarted;

        /// <summary>
        /// Occurs when the power up sequence has started.
        /// </summary>
        event EventHandler<StartPowerUpResponse> PowerUpStarted;

        /// <summary>
        /// Occurs when the power up sequence progress has changed.
        /// </summary>
        event EventHandler<StartPowerUpResponse> PowerUpProgress;

        /// <summary>
        /// Occurs when power up sequence has completed successfully.
        /// </summary>
        event EventHandler<StartPowerUpResponse> PowerUpCompleted;

        /// <summary>
        /// Occurs when power up sequence has failed.
        /// </summary>
        event EventHandler<StartPowerUpResponse> PowerUpFailed;

        /// <summary>
        /// Occurs when power up sequence has ended. Could be due to no response to the request!
        /// </summary>
        event EventHandler PowerUpEnded;

        /// <summary>
        /// Occurs when power down has started.
        /// </summary>
        event EventHandler<PowerDownStartedEventArgs> PowerDownStarted;

        /// <summary>
        /// Occurs when the thread loading status has changed.
        /// </summary>
        event EventHandler<StartThreadLoadingResponse> ThreadLoadingStatusChanged;

        /// <summary>
        /// Occurs when a thread loading confirmation is required.
        /// </summary>
        event EventHandler<ThreadLoadingConfirmationRequiredEventArgs> ThreadLoadingConfirmationRequired;

        /// <summary>
        /// Occurs when thread loading has completed.
        /// </summary>
        event EventHandler<StartThreadLoadingResponse> ThreadLoadingCompleted;

        /// <summary>
        /// Occurs when thread loading has failed.
        /// </summary>
        event EventHandler<StartThreadLoadingResponse> ThreadLoadingFailed;

        /// <summary>
        /// Occurs when a head cleaning job has ended.
        /// </summary>
        event EventHandler<HeadCleaningEndedEventArgs> HeadCleaningEnded;

        /// <summary>
        /// Occurs when the ink filling status has changed.
        /// </summary>
        event EventHandler<InkFillingStatusChangedEventArgs> InkFillingStatusChanged;

        /// <summary>
        /// Occurs when a new telemetry wire is available.
        /// </summary>
        event EventHandler<StartTelemetryWireResponse> TelemetryWireAvailable;

        /// <summary>
        /// Occurs when waste replacement is required.
        /// </summary>
        event EventHandler WasteReplacementRequired;

        /// <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 or sets a value indicating whether to enable automatic thread loading support.
        /// </summary>
        bool EnableAutomaticThreadLoading { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to enable the power sequence tracking.
        /// </summary>
        bool EnablePowerUpSequence { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to enable the ink/waste filling status channel.
        /// </summary>
        bool EnableInkFillingStatus { get; set; }

        /// <summary>
        /// Gets or set a value indicating whether to enable telemetry flow from the firmware to the cloud.
        /// </summary>
        bool EnableTelemetryWire { 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>
        /// <param name="config">Optional job configuration.</param>
        /// <returns></returns>
        Task<JobHandler> Print(Job job, AdditionalJobConfiguration config = null);

        /// <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, AdditionalJobConfiguration config = null);

        /// <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>
        /// Directs the embedded device to switch to stand-by mode.
        /// </summary>
        /// <returns></returns>
        Task StandBy();

        /// <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>
        /// <param name="isEmulated">Specify whether the connected machine is emulated and to skip the actual DFU interface.</param>
        /// <returns></returns>
        Task<FirmwareUpgradeHandler> UpgradeFirmware(Stream tfpStream, bool isEmulated = false);

        /// <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();

        /// <summary>
        /// Turns off the machine.
        /// </summary>
        /// <returns></returns>
        Task<PowerDownHandler> PowerDown();

        /// <summary>
        /// Starts a manual head cleaning process.
        /// </summary>
        /// <returns></returns>
        Task<HeadCleaningHandler> PerformHeadCleaning(bool longCleaning);

        /// <summary>
        /// Starts the automatic thread loading process.
        /// </summary>
        /// <returns></returns>
        Task StartThreadLoading();

        /// <summary>
        /// Continues the current thread loading.
        /// </summary>
        /// <param name="processParameters">The process parameters.</param>
        /// <returns></returns>
        Task ContinueThreadLoading(ProcessParametersTable processParameters);

        /// <summary>
        /// Aborts the current thread loading process.
        /// </summary>
        /// <returns></returns>
        Task AbortThreadLoading();

        /// <summary>
        /// Attempts to jog the thread in order to check whether there are no thread breaking issues.
        /// </summary>
        /// <returns></returns>
        Task AttemptThreadJogging();

        /// <summary>
        /// Emulates a hardware event that will last for the specified timeout.
        /// </summary>
        /// <param name="ev">Type of the event.</param>
        /// <param name="timeout">The timeout.</param>
        void PushEmulatedEvent(Event ev, TimeSpan timeout);

        /// <summary>
        /// Gets the last machine built-in test results.
        /// </summary>
        /// <returns></returns>
        Task<List<BitResultComposition>> GetBitResults(List<BL.Entities.BitType> bitTypes);

        /// <summary>
        /// Notifies the remote machine about spool type change.
        /// If the machine is not connected the spool type will be added to the connection request.
        /// </summary>
        /// <param name="spoolType">Type of the spool.</param>
        Task SetSpoolType(JobSpoolType spoolType);

        /// <summary>
        /// Completes the waste replacement sequence.
        /// </summary>
        /// <param name="approved">Approve or decline the sequence.</param>
        Task CompleteWasteReplacement(bool approved);

        /// <summary>
        /// Gets the list of firmware version descriptors.
        /// </summary>
        /// <returns></returns>
        Task<List<VersionFileDescriptor>> GetFirmwareVersionDescriptors();

        /// <summary>
        /// Resets the firmware card by the specified card id.
        /// </summary>
        /// <param name="cardID">The card identifier.</param>
        /// <returns></returns>
        Task ResetCard(int cardID);

        /// <summary>
        /// Sets the machine power saving mode.
        /// </summary>
        /// <param name="timeToIdleMinutes">The time to idle in minutes.</param>
        /// <param name="timeToPowerDownMinutes">The time to power down in minutes.</param>
        /// <returns></returns>
        Task SetPowerSavingMode(int timeToIdleMinutes,int timeToPowerDownMinutes);

        /// <summary>
        /// Sets the jerrican inserted liters.
        /// </summary>
        /// <param name="idsPackIndex">IDS pack index.</param>
        /// <param name="insertedLiters">The inserted liters.</param>
        /// <returns></returns>
        Task SetJerricanInsertedLiters(int idsPackIndex, double insertedLiters);

        /// <summary>
        /// Sets the machine buzzer settings.
        /// </summary>
        Task SetBuzzerSettings(bool enable, int duration);

        /// <summary>
        /// Sets the machine white thread skip settings.
        /// </summary>
        Task SetWhiteThreadSkip(bool enable);
    }
}