using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Integration.Operation;
using Tango.PPC.Common;
using Tango.PPC.Common.Notifications;
using Tango.PPC.Common.Notifications.NotificationItems;
using Tango.PPC.Jobs.AppBarItems;
using Tango.PPC.Jobs.Messages;
using Tango.PPC.Jobs.NavigationObjects;
using Tango.PPC.Jobs.Views;

namespace Tango.PPC.Jobs.ViewModels
{
    /// <summary>
    /// Represents the main view ViewModel.
    /// </summary>
    /// <seealso cref="Tango.PPC.Common.PPCViewModel" />
    public class MainViewVM : PPCViewModel
    {
        private NotificationItem _last_failed_job_notification;
        private JobHandler _handler;
        private bool resuming;
        private JobProgressAppBarItem _appBarItem;

        /// <summary>
        /// Called when the application has been started.
        /// </summary>
        public override void OnApplicationStarted()
        {
            MachineProvider.MachineOperator.PrintingCompleted += MachineOperator_PrintingCompleted;
            MachineProvider.MachineOperator.PrintingFailed += MachineOperator_PrintingFailed;
            MachineProvider.MachineOperator.ResumingJob += MachineOperator_ResumingJob;
            MachineProvider.MachineOperator.PrintingStarted += MachineOperator_PrintingStarted;
            MachineProvider.MachineOperator.PrintingEnded += MachineOperator_PrintingEnded;
            NavigationManager.CurrentVMChanged += NavigationManager_CurrentVMChanged;
        }

        private void MachineOperator_PrintingEnded(object sender, PrintingEventArgs e)
        {
            _appBarItem?.Close();
            _appBarItem = null;
        }

        private void NavigationManager_CurrentVMChanged(object sender, PPCViewModel vm)
        {
            if (vm.GetType() == typeof(JobProgressViewVM))
            {
                _appBarItem?.Close();
                _appBarItem = null;
            }
            else if (vm.GetType() != typeof(JobSummeryViewVM) && _appBarItem == null && MachineProvider.MachineOperator.IsPrinting && _handler != null && !_handler.IsCanceled)
            {
                _appBarItem = NotificationProvider.PushAppBarItem<JobProgressAppBarItem>();
                _appBarItem.Pressed += (_, __) =>
                {
                    _appBarItem?.Close();
                    NavigationManager.NavigateTo<JobsV2Module>(nameof(JobProgressView));
                };
            }
        }

        private void MachineOperator_PrintingStarted(object sender, PrintingEventArgs e)
        {
            _handler = e.JobHandler;

            if (resuming)
            {
                resuming = false;

                InvokeUI(() =>
                {
                    NavigationManager.NavigateTo<JobsV2Module>(nameof(JobProgressView));

                    if (_last_failed_job_notification != null)
                    {
                        _last_failed_job_notification.Close();
                        _last_failed_job_notification = null;
                    }
                });
            }
        }

        private void MachineOperator_ResumingJob(object sender, ResumingJobEventArgs e)
        {
            LogManager.Log($"Job resume request '{e.JobGuid}' approving...");

            try
            {
                e.Approve();
                resuming = true;
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "An error occurred while trying to resume the job.");
                InvokeUI(() =>
                {
                    NotificationProvider.ShowError("An error occurred while trying to resume a job in progress.");
                });
            }
        }

        /// <summary>
        /// Handles the PrintingFailed event of the MachineOperator.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Integration.Operation.PrintingFailedEventArgs"/> instance containing the event data.</param>
        private void MachineOperator_PrintingFailed(object sender, PrintingFailedEventArgs e)
        {
            String message = $"{e.Exception.FlattenMessage()}";

            _last_failed_job_notification = NotificationProvider.PushNotification(new MessageNotificationItem(
                $"'{e.Job.Name}' failed at position {e.JobHandler.Status.ProgressMinusSettingUp.ToString("0.0")} out of {e.JobHandler.Status.TotalProgressMinusSettingUp.ToString("0.0")} meters.",
                message, MessageNotificationItem.MessageNotificationItemTypes.Error, () =>
                 {
                     NavigationManager.NavigateWithObject<JobsV2Module, JobView, Job>(e.Job);
                     NavigationManager.ClearHistoryExcept<JobsView>();
                 }, NotificationItem.NotificationPriority.VeryHigh));
        }

        /// <summary>
        /// Handles the PrintingCompleted event of the MachineOperator.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="Integration.Operation.PrintingEventArgs"/> instance containing the event data.</param>
        private void MachineOperator_PrintingCompleted(object sender, PrintingEventArgs e)
        {
            LogManager.Log($"'{e.Job.Name}' printing complete. Job designation is {e.Job.Designation}.");

            if (e.Job.Designation == BL.Enumerations.JobDesignations.SampleDye)
            {
                NotificationProvider.PushNotification(new MessageNotificationItem(String.Format("'{0}' sample dye completed successfully", e.Job.Name), "Tap to approve or repeat.", MessageNotificationItempre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ConfigurationParameters.proto
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Tango.PMR.EmbeddedParameters {

  /// <summary>Holder for reflection information generated from ConfigurationParameters.proto</summary>
  public static partial class ConfigurationParametersReflection {

    #region Descriptor
    /// <summary>File descriptor for ConfigurationParameters.proto</summary>
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static ConfigurationParametersReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "Ch1Db25maWd1cmF0aW9uUGFyYW1ldGVycy5wcm90bxIcVGFuZ28uUE1SLkVt",
            "YmVkZGVkUGFyYW1ldGVycyLoBwoXQ29uZmlndXJhdGlvblBhcmFtZXRlcnMS",
            "GAoQQnJlYWtTZW5zb3JMaW1pdBgBIAEoDRIhChlEaWFnbm9zdGljQ29sbGVj",
            "dGlvbkxpbWl0GAIgASgNEhoKEk92ZXJIZWF0Q291bnRMaW1pdBgDIAEoDRIb",
            "ChNVbmRlckhlYXRDb3VudExpbWl0GAQgASgNEhkKEUNsb3NlVmFsdmVUaW1l",
            "b3V0GAUgASgNEhgKEE9wZW5WYWx2ZVRpbWVvdXQYBiABKA0SIAoYSW5pdGlh",
            "bERpc3BlbnNlclByZXNzdXJlGAcgASgBEh8KF0luaXRpYWxEaXNwZW5zZXJU",
            "aW1lb3V0GAggASgNEh8KF0luaXRpYWxEaXNwZW5zZXJUaW1lTGFnGAkgASgN",
            "EiMKG0Rpc3BlbnNlckJ1aWxkUHJlc3N1cmVTcGVlZBgKIAEoDRIjChtEaXNw",
            "ZW5zZXJCdWlsZFByZXNzdXJlTGltaXQYCyABKAESJQodRGlzcGVuc2VyQnVp",
            "bGRQcmVzc3VyZVRpbWVvdXQYDCABKA0SIQoZRGlzcGVuc2VyQnVpbGRQcmVz",
            "c3VyZUxhZxgNIAEoDRIkChxBQ0hlYXRlcnNMb3dlck9wZXJhdGlvbkxpbWl0",
            "GA4gASgNEiQKHEFDSGVhdGVyc1VwcGVyT3BlcmF0aW9uTGltaXQYDyABKA0S",
            "JAocRENIZWF0ZXJzTG93ZXJPcGVyYXRpb25MaW1pdBgQIAEoDRIkChxEQ0hl",
            "YXRlcnNVcHBlck9wZXJhdGlvbkxpbWl0GBEgASgNEiEKGU1pZFRhbmtQcmVz",
            "c3VyZUNvcnJlY3Rpb24YEiABKAESHwoXRGlzcGVuc2VyUHJlc2VnbWVudFdG",
            "Q0YYEyABKAESIgoaU3RhcnRIZWF0aW5nT25Jbml0U2VxdWVuY2UYFCABKAgS",
            "GQoRR2VuZXJhbFBhcmFtZXRlcnMYFSADKAESHAoUQ3VycmVudEFsYXJtTG93",
            "TGltaXQYFiABKAESHQoVQ3VycmVudEFsYXJtSGlnaExpbWl0GBcgASgBEiAK",
            "GElEU19TZWdtZW50UmVmaWxsVGltZW91dBgYIAEoARIhChlJRFNfUHJlU2Vn",
            "bWVudEJ1aWxkdXBUaW1lGBkgASgBEhkKEUlEU19DbGVhbmluZ1NwZWVkGBog",
            "ASgBEikKIUlEU19DbGVhbmluZ1N0b3BCZWZvcmVTZWdtZW50VGltZRgbIAEo",
            "ARIiChpJRFNfTGVmdENsZWFuaW5nTW90b3JTcGVlZBgcIAEoARIjChtJRFNf",
            "UmlnaHRDbGVhbmluZ01vdG9yU3BlZWQYHSABKAFCKAomY29tLnR3aW5lLnRh",
            "bmdvLnBtci5lbWJlZGRlZHBhcmFtZXRlcnNiBnByb3RvMw=="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Tango.PMR.EmbeddedParameters.ConfigurationParameters), global::Tango.PMR.EmbeddedParameters.ConfigurationParameters.Parser, new[]{ "BreakSensorLimit", "DiagnosticCollectionLimit", "OverHeatCountLimit", "UnderHeatCountLimit", "CloseValveTimeout", "OpenValveTimeout", "InitialDispenserPressure", "InitialDispenserTimeout", "InitialDispenserTimeLag", "DispenserBuildPressureSpeed", "DispenserBuildPressureLimit", "DispenserBuildPressureTimeout", "DispenserBuildPressureLag", "ACHeatersLowerOperationLimit", "ACHeatersUpperOperationLimit", "DCHeatersLowerOperationLimit", "DCHeatersUpperOperationLimit", "MidTankPressureCorrection", "DispenserPresegmentWFCF", "StartHeatingOnInitSequence", "GeneralParameters", "CurrentAlarmLowLimit", "CurrentAlarmHighLimit", "IDSSegmentRefillTimeout", "IDSPreSegmentBuildupTime", "IDSCleaningSpeed", "IDSCleaningStopBeforeSegmentTime", "IDSLeftCleaningMotorSpeed", "IDSRightCleaningMotorSpeed" }, null, null, null)
          }));
    }
    #endregion

  }
  #region Messages
  public sealed partial class ConfigurationParameters : pb::IMessage<ConfigurationParameters> {
    private static readonly pb::MessageParser<ConfigurationParameters> _parser = new pb::MessageParser<ConfigurationParameters>(() => new ConfigurationParameters());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ConfigurationParameters> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tango.PMR.EmbeddedParameters.ConfigurationParametersReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ConfigurationParameters() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ConfigurationParameters(ConfigurationParameters other) : this() {
      breakSensorLimit_ = other.breakSensorLimit_;
      diagnosticCollectionLimit_ = other.diagnosticCollectionLimit_;
      overHeatCountLimit_ = other.overHeatCountLimit_;
      underHeatCountLimit_ = other.underHeatCountLimit_;
      closeValveTimeout_ = other.closeValveTimeout_;
      openValveTimeout_ = other.openValveTimeout_;
      initialDispenserPressure_ = other.initialDispenserPressure_;
      initialDispenserTimeout_ = other.initialDispenserTimeout_;
      initialDispenserTimeLag_ = other.initialDispenserTimeLag_;
      dispenserBuildPressureSpeed_ = other.dispenserBuildPressureSpeed_;
      dispenserBuildPressureLimit_ = other.dispenserBuildPressureLimit_;
      dispenserBuildPressureTimeout_ = other.dispenserBuildPressureTimeout_;
      dispenserBuildPressureLag_ = other.dispenserBuildPressureLag_;
      aCHeatersLowerOperationLimit_ = other.aCHeatersLowerOperationLimit_;
      aCHeatersUpperOperationLimit_ = other.aCHeatersUpperOperationLimit_;
      dCHeatersLowerOperationLimit_ = other.dCHeatersLowerOperationLimit_;
      dCHeatersUpperOperationLimit_ = other.dCHeatersUpperOperationLimit_;
      midTankPressureCorrection_ = other.midTankPressureCorrection_;
      dispenserPresegmentWFCF_ = other.dispenserPresegmentWFCF_;
      startHeatingOnInitSequence_ = other.startHeatingOnInitSequence_;
      generalParameters_ = other.generalParameters_.Clone();
      currentAlarmLowLimit_ = other.currentAlarmLowLimit_;
      currentAlarmHighLimit_ = other.currentAlarmHighLimit_;
      iDSSegmentRefillTimeout_ = other.iDSSegmentRefillTimeout_;
      iDSPreSegmentBuildupTime_ = other.iDSPreSegmentBuildupTime_;
      iDSCleaningSpeed_ = other.iDSCleaningSpeed_;
      iDSCleaningStopBeforeSegmentTime_ = other.iDSCleaningStopBeforeSegmentTime_;
      iDSLeftCleaningMotorSpeed_ = other.iDSLeftCleaningMotorSpeed_;
      iDSRightCleaningMotorSpeed_ = other.iDSRightCleaningMotorSpeed_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ConfigurationParameters Clone() {
      return new ConfigurationParameters(this);
    }

    /// <summary>Field number for the "BreakSensorLimit" field.</summary>
    public const int BreakSensorLimitFieldNumber = 1;
    private uint breakSensorLimit_;
    /// <summary>
    ///#define BREAK_SENSOR_LIMIT 10
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint BreakSensorLimit {
      get { return breakSensorLimit_; }
      set {
        breakSensorLimit_ = value;
      }
    }

    /// <summary>Field number for the "DiagnosticCollectionLimit" field.</summary>
    public const int DiagnosticCollectionLimitFieldNumber = 2;
    private uint diagnosticCollectionLimit_;
    /// <summary>
    ///#define Diagnostics send interval in milliseconds 2
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DiagnosticCollectionLimit {
      get { return diagnosticCollectionLimit_; }
      set {
        diagnosticCollectionLimit_ = value;
      }
    }

    /// <summary>Field number for the "OverHeatCountLimit" field.</summary>
    public const int OverHeatCountLimitFieldNumber = 3;
    private uint overHeatCountLimit_;
    /// <summary>
    ///#define OVERHEAT_COUNT_LIMIT 3
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint OverHeatCountLimit {
      get { return overHeatCountLimit_; }
      set {
        overHeatCountLimit_ = value;
      }
    }

    /// <summary>Field number for the "UnderHeatCountLimit" field.</summary>
    public const int UnderHeatCountLimitFieldNumber = 4;
    private uint underHeatCountLimit_;
    /// <summary>
    ///#define UNDERHEAT_COUNT_LIMIT 3
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint UnderHeatCountLimit {
      get { return underHeatCountLimit_; }
      set {
        underHeatCountLimit_ = value;
      }
    }

    /// <summary>Field number for the "CloseValveTimeout" field.</summary>
    public const int CloseValveTimeoutFieldNumber = 5;
    private uint closeValveTimeout_;
    /// <summary>
    ///uint32_t CloseValveTimeout = 250;
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint CloseValveTimeout {
      get { return closeValveTimeout_; }
      set {
        closeValveTimeout_ = value;
      }
    }

    /// <summary>Field number for the "OpenValveTimeout" field.</summary>
    public const int OpenValveTimeoutFieldNumber = 6;
    private uint openValveTimeout_;
    /// <summary>
    ///uint32_t OpenValveTimeout = 250;
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint OpenValveTimeout {
      get { return openValveTimeout_; }
      set {
        openValveTimeout_ = value;
      }
    }

    /// <summary>Field number for the "InitialDispenserPressure" field.</summary>
    public const int InitialDispenserPressureFieldNumber = 7;
    private double initialDispenserPressure_;
    /// <summary>
    ///#define INITIAL_DISPENSER_PRESSURE 0.10
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double InitialDispenserPressure {
      get { return initialDispenserPressure_; }
      set {
        initialDispenserPressure_ = value;
      }
    }

    /// <summary>Field number for the "InitialDispenserTimeout" field.</summary>
    public const int InitialDispenserTimeoutFieldNumber = 8;
    private uint initialDispenserTimeout_;
    /// <summary>
    ///#define INITIAL_DISPENSER_TIMEOUT_LIMIT 10000
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint InitialDispenserTimeout {
      get { return initialDispenserTimeout_; }
      set {
        initialDispenserTimeout_ = value;
      }
    }

    /// <summary>Field number for the "InitialDispenserTimeLag" field.</summary>
    public const int InitialDispenserTimeLagFieldNumber = 9;
    private uint initialDispenserTimeLag_;
    /// <summary>
    ///#define INITIAL_DISPENSER_TIMEOUT 100
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint InitialDispenserTimeLag {
      get { return initialDispenserTimeLag_; }
      set {
        initialDispenserTimeLag_ = value;
      }
    }

    /// <summary>Field number for the "DispenserBuildPressureSpeed" field.</summary>
    public const int DispenserBuildPressureSpeedFieldNumber = 10;
    private uint dispenserBuildPressureSpeed_;
    /// <summary>
    ///#define DISPENSER_BUILD_PRESSURE_SPEED 500
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DispenserBuildPressureSpeed {
      get { return dispenserBuildPressureSpeed_; }
      set {
        dispenserBuildPressureSpeed_ = value;
      }
    }

    /// <summary>Field number for the "DispenserBuildPressureLimit" field.</summary>
    public const int DispenserBuildPressureLimitFieldNumber = 11;
    private double dispenserBuildPressureLimit_;
    /// <summary>
    ///#define DISPENSER_BUILD_PRESSURE_LIMIT 0.5
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double DispenserBuildPressureLimit {
      get { return dispenserBuildPressureLimit_; }
      set {
        dispenserBuildPressureLimit_ = value;
      }
    }

    /// <summary>Field number for the "DispenserBuildPressureTimeout" field.</summary>
    public const int DispenserBuildPressureTimeoutFieldNumber = 12;
    private uint dispenserBuildPressureTimeout_;
    /// <summary>
    ///#define DISPENSER_BUILD_PRESSURE_TIMEOUT 8000
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DispenserBuildPressureTimeout {
      get { return dispenserBuildPressureTimeout_; }
      set {
        dispenserBuildPressureTimeout_ = value;
      }
    }

    /// <summary>Field number for the "DispenserBuildPressureLag" field.</summary>
    public const int DispenserBuildPressureLagFieldNumber = 13;
    private uint dispenserBuildPressureLag_;
    /// <summary>
    ///#define DISPENSER_BUILD_PRESSURE_LAG 50
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DispenserBuildPressureLag {
      get { return dispenserBuildPressureLag_; }
      set {
        dispenserBuildPressureLag_ = value;
      }
    }

    /// <summary>Field number for the "ACHeatersLowerOperationLimit" field.</summary>
    public const int ACHeatersLowerOperationLimitFieldNumber = 14;
    private uint aCHeatersLowerOperationLimit_;
    /// <summary>
    ///sets the temperature frame for approving job start - in promil above and beyond target temperatures
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint ACHeatersLowerOperationLimit {
      get { return aCHeatersLowerOperationLimit_; }
      set {
        aCHeatersLowerOperationLimit_ = value;
      }
    }

    /// <summary>Field number for the "ACHeatersUpperOperationLimit" field.</summary>
    public const int ACHeatersUpperOperationLimitFieldNumber = 15;
    private uint aCHeatersUpperOperationLimit_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint ACHeatersUpperOperationLimit {
      get { return aCHeatersUpperOperationLimit_; }
      set {
        aCHeatersUpperOperationLimit_ = value;
      }
    }

    /// <summary>Field number for the "DCHeatersLowerOperationLimit" field.</summary>
    public const int DCHeatersLowerOperationLimitFieldNumber = 16;
    private uint dCHeatersLowerOperationLimit_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DCHeatersLowerOperationLimit {
      get { return dCHeatersLowerOperationLimit_; }
      set {
        dCHeatersLowerOperationLimit_ = value;
      }
    }

    /// <summary>Field number for the "DCHeatersUpperOperationLimit" field.</summary>
    public const int DCHeatersUpperOperationLimitFieldNumber = 17;
    private uint dCHeatersUpperOperationLimit_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint DCHeatersUpperOperationLimit {
      get { return dCHeatersUpperOperationLimit_; }
      set {
        dCHeatersUpperOperationLimit_ = value;
      }
    }

    /// <summary>Field number for the "MidTankPressureCorrection" field.</summary>
    public const int MidTankPressureCorrectionFieldNumber = 18;
    private double midTankPressureCorrection_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double MidTankPressureCorrection {
      get { return midTankPressureCorrection_; }
      set {
        midTankPressureCorrection_ = value;
      }
    }

    /// <summary>Field number for the "DispenserPresegmentWFCF" field.</summary>
    public const int DispenserPresegmentWFCFFieldNumber = 19;
    private double dispenserPresegmentWFCF_;
    /// <summary>
    ///Waste Flow Correction Factor
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double DispenserPresegmentWFCF {
      get { return dispenserPresegmentWFCF_; }
      set {
        dispenserPresegmentWFCF_ = value;
      }
    }

    /// <summary>Field number for the "StartHeatingOnInitSequence" field.</summary>
    public const int StartHeatingOnInitSequenceFieldNumber = 20;
    private bool startHeatingOnInitSequence_;
    /// <summary>
    ///disable heating start on init
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool StartHeatingOnInitSequence {
      get { return startHeatingOnInitSequence_; }
      set {
        startHeatingOnInitSequence_ = value;
      }
    }

    /// <summary>Field number for the "GeneralParameters" field.</summary>
    public const int GeneralParametersFieldNumber = 21;
    private static readonly pb::FieldCodec<double> _repeated_generalParameters_codec
        = pb::FieldCodec.ForDouble(170);
    private readonly pbc::RepeatedField<double> generalParameters_ = new pbc::RepeatedField<double>();
    /// <summary>
    /// general storage for parameters that do not have a specific name updated
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<double> GeneralParameters {
      get { return generalParameters_; }
    }

    /// <summary>Field number for the "CurrentAlarmLowLimit" field.</summary>
    public const int CurrentAlarmLowLimitFieldNumber = 22;
    private double currentAlarmLowLimit_;
    /// <summary>
    /// a limit percentage for current deviation below predefined level
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double CurrentAlarmLowLimit {
      get { return currentAlarmLowLimit_; }
      set {
        currentAlarmLowLimit_ = value;
      }
    }

    /// <summary>Field number for the "CurrentAlarmHighLimit" field.</summary>
    public const int CurrentAlarmHighLimitFieldNumber = 23;
    private double currentAlarmHighLimit_;
    /// <summary>
    /// a limit percentage for current deviation  predefined level
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double CurrentAlarmHighLimit {
      get { return currentAlarmHighLimit_; }
      set {
        currentAlarmHighLimit_ = value;
      }
    }

    /// <summary>Field number for the "IDS_SegmentRefillTimeout" field.</summary>
    public const int IDSSegmentRefillTimeoutFieldNumber = 24;
    private double iDSSegmentRefillTimeout_;
    /// <summary>
    ///how much time before next segment the automatic refill should stop
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSSegmentRefillTimeout {
      get { return iDSSegmentRefillTimeout_; }
      set {
        iDSSegmentRefillTimeout_ = value;
      }
    }

    /// <summary>Field number for the "IDS_PreSegmentBuildupTime" field.</summary>
    public const int IDSPreSegmentBuildupTimeFieldNumber = 25;
    private double iDSPreSegmentBuildupTime_;
    /// <summary>
    /// how much running to waste time during presegment
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSPreSegmentBuildupTime {
      get { return iDSPreSegmentBuildupTime_; }
      set {
        iDSPreSegmentBuildupTime_ = value;
      }
    }

    /// <summary>Field number for the "IDS_CleaningSpeed" field.</summary>
    public const int IDSCleaningSpeedFieldNumber = 26;
    private double iDSCleaningSpeed_;
    /// <summary>
    ///cleaning dispenser motorspeed
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSCleaningSpeed {
      get { return iDSCleaningSpeed_; }
      set {
        iDSCleaningSpeed_ = value;
      }
    }

    /// <summary>Field number for the "IDS_CleaningStopBeforeSegmentTime" field.</summary>
    public const int IDSCleaningStopBeforeSegmentTimeFieldNumber = 27;
    private double iDSCleaningStopBeforeSegmentTime_;
    /// <summary>
    ///cleaning dispenser stop before segment  start
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSCleaningStopBeforeSegmentTime {
      get { return iDSCleaningStopBeforeSegmentTime_; }
      set {
        iDSCleaningStopBeforeSegmentTime_ = value;
      }
    }

    /// <summary>Field number for the "IDS_LeftCleaningMotorSpeed" field.</summary>
    public const int IDSLeftCleaningMotorSpeedFieldNumber = 28;
    private double iDSLeftCleaningMotorSpeed_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSLeftCleaningMotorSpeed {
      get { return iDSLeftCleaningMotorSpeed_; }
      set {
        iDSLeftCleaningMotorSpeed_ = value;
      }
    }

    /// <summary>Field number for the "IDS_RightCleaningMotorSpeed" field.</summary>
    public const int IDSRightCleaningMotorSpeedFieldNumber = 29;
    private double iDSRightCleaningMotorSpeed_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public double IDSRightCleaningMotorSpeed {
      get { return iDSRightCleaningMotorSpeed_; }
      set {
        iDSRightCleaningMotorSpeed_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ConfigurationParameters);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ConfigurationParameters other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (BreakSensorLimit != other.BreakSensorLimit) return false;
      if (DiagnosticCollectionLimit != other.DiagnosticCollectionLimit) return false;
      if (OverHeatCountLimit != other.OverHeatCountLimit) return false;
      if (UnderHeatCountLimit != other.UnderHeatCountLimit) return false;
      if (CloseValveTimeout != other.CloseValveTimeout) return false;
      if (OpenValveTimeout != other.OpenValveTimeout) return false;
      if (InitialDispenserPressure != other.InitialDispenserPressure) return false;
      if (InitialDispenserTimeout != other.InitialDispenserTimeout) return false;
      if (InitialDispenserTimeLag != other.InitialDispenserTimeLag) return false;
      if (DispenserBuildPressureSpeed != other.DispenserBuildPressureSpeed) return false;
      if (DispenserBuildPressureLimit != other.DispenserBuildPressureLimit) return false;
      if (DispenserBuildPressureTimeout != other.DispenserBuildPressureTimeout) return false;
      if (DispenserBuildPressureLag != other.DispenserBuildPressureLag) return false;
      if (ACHeatersLowerOperationLimit != other.ACHeatersLowerOperationLimit) return false;
      if (ACHeatersUpperOperationLimit != other.ACHeatersUpperOperationLimit) return false;
      if (DCHeatersLowerOperationLimit != other.DCHeatersLowerOperationLimit) return false;
      if (DCHeatersUpperOperationLimit != other.DCHeatersUpperOperationLimit) return false;
      if (MidTankPressureCorrection != other.MidTankPressureCorrection) return false;
      if (DispenserPresegmentWFCF != other.DispenserPresegmentWFCF) return false;
      if (StartHeatingOnInitSequence != other.StartHeatingOnInitSequence) return false;
      if(!generalParameters_.Equals(other.generalParameters_)) return false;
      if (CurrentAlarmLowLimit != other.CurrentAlarmLowLimit) return false;
      if (CurrentAlarmHighLimit != other.CurrentAlarmHighLimit) return false;
      if (IDSSegmentRefillTimeout != other.IDSSegmentRefillTimeout) return false;
      if (IDSPreSegmentBuildupTime != other.IDSPreSegmentBuildupTime) return false;
      if (IDSCleaningSpeed != other.IDSCleaningSpeed) return false;
      if (IDSCleaningStopBeforeSegmentTime != other.IDSCleaningStopBeforeSegmentTime) return false;
      if (IDSLeftCleaningMotorSpeed != other.IDSLeftCleaningMotorSpeed) return false;
      if (IDSRightCleaningMotorSpeed != other.IDSRightCleaningMotorSpeed) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (BreakSensorLimit != 0) hash ^= BreakSensorLimit.GetHashCode();
      if (DiagnosticCollectionLimit != 0) hash ^= DiagnosticCollectionLimit.GetHashCode();
      if (OverHeatCountLimit != 0) hash ^= OverHeatCountLimit.GetHashCode();
      if (UnderHeatCountLimit != 0) hash ^= UnderHeatCountLimit.GetHashCode();
      if (CloseValveTimeout != 0) hash ^= CloseValveTimeout.GetHashCode();
      if (OpenValveTimeout != 0) hash ^= OpenValveTimeout.GetHashCode();
      if (InitialDispenserPressure != 0D) hash ^= InitialDispenserPressure.GetHashCode();
      if (InitialDispenserTimeout != 0) hash ^= InitialDispenserTimeout.GetHashCode();
      if (InitialDispenserTimeLag != 0) hash ^= InitialDispenserTimeLag.GetHashCode();
      if (DispenserBuildPressureSpeed != 0) hash ^= DispenserBuildPressureSpeed.GetHashCode();
      if (DispenserBuildPressureLimit != 0D) hash ^= DispenserBuildPressureLimit.GetHashCode();
      if (DispenserBuildPressureTimeout != 0) hash ^= DispenserBuildPressureTimeout.GetHashCode();
      if (DispenserBuildPressureLag != 0) hash ^= DispenserBuildPressureLag.GetHashCode();
      if (ACHeatersLowerOperationLimit != 0) hash ^= ACHeatersLowerOperationLimit.GetHashCode();
      if (ACHeatersUpperOperationLimit != 0) hash ^= ACHeatersUpperOperationLimit.GetHashCode();
      if (DCHeatersLowerOperationLimit != 0) hash ^= DCHeatersLowerOperationLimit.GetHashCode();
      if (DCHeatersUpperOperationLimit != 0) hash ^= DCHeatersUpperOperationLimit.GetHashCode();
      if (MidTankPressureCorrection != 0D) hash ^= MidTankPressureCorrection.GetHashCode();
      if (DispenserPresegmentWFCF != 0D) hash ^= DispenserPresegmentWFCF.GetHashCode();
      if (StartHeatingOnInitSequence != false) hash ^= StartHeatingOnInitSequence.GetHashCode();
      hash ^= generalParameters_.GetHashCode();
      if (CurrentAlarmLowLimit != 0D) hash ^= CurrentAlarmLowLimit.GetHashCode();
      if (CurrentAlarmHighLimit != 0D) hash ^= CurrentAlarmHighLimit.GetHashCode();
      if (IDSSegmentRefillTimeout != 0D) hash ^= IDSSegmentRefillTimeout.GetHashCode();
      if (IDSPreSegmentBuildupTime != 0D) hash ^= IDSPreSegmentBuildupTime.GetHashCode();
      if (IDSCleaningSpeed != 0D) hash ^= IDSCleaningSpeed.GetHashCode();
      if (IDSCleaningStopBeforeSegmentTime != 0D) hash ^= IDSCleaningStopBeforeSegmentTime.GetHashCode();
      if (IDSLeftCleaningMotorSpeed != 0D) hash ^= IDSLeftCleaningMotorSpeed.GetHashCode();
      if (IDSRightCleaningMotorSpeed != 0D) hash ^= IDSRightCleaningMotorSpeed.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (BreakSensorLimit != 0) {
        output.WriteRawTag(8);
        output.WriteUInt32(BreakSensorLimit);
      }
      if (DiagnosticCollectionLimit != 0) {
        output.WriteRawTag(16);
        output.WriteUInt32(DiagnosticCollectionLimit);
      }
      if (OverHeatCountLimit != 0) {
        output.WriteRawTag(24);
        output.WriteUInt32(OverHeatCountLimit);
      }
      if (UnderHeatCountLimit != 0) {
        output.WriteRawTag(32);
        output.WriteUInt32(UnderHeatCountLimit);
      }
      if (CloseValveTimeout != 0) {
        output.WriteRawTag(40);
        output.WriteUInt32(CloseValveTimeout);
      }
      if (OpenValveTimeout != 0) {
        output.WriteRawTag(48);
        output.WriteUInt32(OpenValveTimeout);
      }
      if (InitialDispenserPressure != 0D) {
        output.WriteRawTag(57);
        output.WriteDouble(InitialDispenserPressure);
      }
      if (InitialDispenserTimeout != 0) {
        output.WriteRawTag(64);
        output.WriteUInt32(InitialDispenserTimeout);
      }
      if (InitialDispenserTimeLag != 0) {
        output.WriteRawTag(72);
        output.WriteUInt32(InitialDispenserTimeLag);
      }
      if (DispenserBuildPressureSpeed != 0) {
        output.WriteRawTag(80);
        output.WriteUInt32(DispenserBuildPressureSpeed);
      }
      if (DispenserBuildPressureLimit != 0D) {
        output.WriteRawTag(89);
        output.WriteDouble(DispenserBuildPressureLimit);
      }
      if (DispenserBuildPressureTimeout != 0) {
        output.WriteRawTag(96);
        output.WriteUInt32(DispenserBuildPressureTimeout);
      }
      if (DispenserBuildPressureLag != 0) {
        output.WriteRawTag(104);
        output.WriteUInt32(DispenserBuildPressureLag);
      }
      if (ACHeatersLowerOperationLimit != 0) {
        output.WriteRawTag(112);
        output.WriteUInt32(ACHeatersLowerOperationLimit);
      }
      if (ACHeatersUpperOperationLimit != 0) {
        output.WriteRawTag(120);
        output.WriteUInt32(ACHeatersUpperOperationLimit);
      }
      if (DCHeatersLowerOperationLimit != 0) {
        output.WriteRawTag(128, 1);
        output.WriteUInt32(DCHeatersLowerOperationLimit);
      }
      if (DCHeatersUpperOperationLimit != 0) {
        output.WriteRawTag(136, 1);
        output.WriteUInt32(DCHeatersUpperOperationLimit);
      }
      if (MidTankPressureCorrection != 0D) {
        output.WriteRawTag(145, 1);
        output.WriteDouble(MidTankPressureCorrection);
      }
      if (DispenserPresegmentWFCF != 0D) {
        output.WriteRawTag(153, 1);
        output.WriteDouble(DispenserPresegmentWFCF);
      }
      if (StartHeatingOnInitSequence != false) {
        output.WriteRawTag(160, 1);
        output.WriteBool(StartHeatingOnInitSequence);
      }
      generalParameters_.WriteTo(output, _repeated_generalParameters_codec);
      if (CurrentAlarmLowLimit != 0D) {
        output.WriteRawTag(177, 1);
        output.WriteDouble(CurrentAlarmLowLimit);
      }
      if (CurrentAlarmHighLimit != 0D) {
        output.WriteRawTag(185, 1);
        output.WriteDouble(CurrentAlarmHighLimit);
      }
      if (IDSSegmentRefillTimeout != 0D) {
        output.WriteRawTag(193, 1);
        output.WriteDouble(IDSSegmentRefillTimeout);
      }
      if (IDSPreSegmentBuildupTime != 0D) {
        output.WriteRawTag(201, 1);
        output.WriteDouble(IDSPreSegmentBuildupTime);
      }
      if (IDSCleaningSpeed != 0D) {
        output.WriteRawTag(209, 1);
        output.WriteDouble(IDSCleaningSpeed);
      }
      if (IDSCleaningStopBeforeSegmentTime != 0D) {
        output.WriteRawTag(217, 1);
        output.WriteDouble(IDSCleaningStopBeforeSegmentTime);
      }
      if (IDSLeftCleaningMotorSpeed != 0D) {
        output.WriteRawTag(225, 1);
        output.WriteDouble(IDSLeftCleaningMotorSpeed);
      }
      if (IDSRightCleaningMotorSpeed != 0D) {
        output.WriteRawTag(233, 1);
        output.WriteDouble(IDSRightCleaningMotorSpeed);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (BreakSensorLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BreakSensorLimit);
      }
      if (DiagnosticCollectionLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DiagnosticCollectionLimit);
      }
      if (OverHeatCountLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(OverHeatCountLimit);
      }
      if (UnderHeatCountLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(UnderHeatCountLimit);
      }
      if (CloseValveTimeout != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(CloseValveTimeout);
      }
      if (OpenValveTimeout != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(OpenValveTimeout);
      }
      if (InitialDispenserPressure != 0D) {
        size += 1 + 8;
      }
      if (InitialDispenserTimeout != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(InitialDispenserTimeout);
      }
      if (InitialDispenserTimeLag != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(InitialDispenserTimeLag);
      }
      if (DispenserBuildPressureSpeed != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DispenserBuildPressureSpeed);
      }
      if (DispenserBuildPressureLimit != 0D) {
        size += 1 + 8;
      }
      if (DispenserBuildPressureTimeout != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DispenserBuildPressureTimeout);
      }
      if (DispenserBuildPressureLag != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(DispenserBuildPressureLag);
      }
      if (ACHeatersLowerOperationLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ACHeatersLowerOperationLimit);
      }
      if (ACHeatersUpperOperationLimit != 0) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ACHeatersUpperOperationLimit);
      }
      if (DCHeatersLowerOperationLimit != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(DCHeatersLowerOperationLimit);
      }
      if (DCHeatersUpperOperationLimit != 0) {
        size += 2 + pb::CodedOutputStream.ComputeUInt32Size(DCHeatersUpperOperationLimit);
      }
      if (MidTankPressureCorrection != 0D) {
        size += 2 + 8;
      }
      if (DispenserPresegmentWFCF != 0D) {
        size += 2 + 8;
      }
      if (StartHeatingOnInitSequence != false) {
        size += 2 + 1;
      }
      size += generalParameters_.CalculateSize(_repeated_generalParameters_codec);
      if (CurrentAlarmLowLimit != 0D) {
        size += 2 + 8;
      }
      if (CurrentAlarmHighLimit != 0D) {
        size += 2 + 8;
      }
      if (IDSSegmentRefillTimeout != 0D) {
        size += 2 + 8;
      }
      if (IDSPreSegmentBuildupTime != 0D) {
        size += 2 + 8;
      }
      if (IDSCleaningSpeed != 0D) {
        size += 2 + 8;
      }
      if (IDSCleaningStopBeforeSegmentTime != 0D) {
        size += 2 + 8;
      }
      if (IDSLeftCleaningMotorSpeed != 0D) {
        size += 2 + 8;
      }
      if (IDSRightCleaningMotorSpeed != 0D) {
        size += 2 + 8;
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ConfigurationParameters other) {
      if (other == null) {
        return;
      }
      if (other.BreakSensorLimit != 0) {
        BreakSensorLimit = other.BreakSensorLimit;
      }
      if (other.DiagnosticCollectionLimit != 0) {
        DiagnosticCollectionLimit = other.DiagnosticCollectionLimit;
      }
      if (other.OverHeatCountLimit != 0) {
        OverHeatCountLimit = other.OverHeatCountLimit;
      }
      if (other.UnderHeatCountLimit != 0) {
        UnderHeatCountLimit = other.UnderHeatCountLimit;
      }
      if (other.CloseValveTimeout != 0) {
        CloseValveTimeout = other.CloseValveTimeout;
      }
      if (other.OpenValveTimeout != 0) {
        OpenValveTimeout = other.OpenValveTimeout;
      }
      if (other.InitialDispenserPressure != 0D) {
        InitialDispenserPressure = other.InitialDispenserPressure;
      }
      if (other.InitialDispenserTimeout != 0) {
        InitialDispenserTimeout = other.InitialDispenserTimeout;
      }
      if (other.InitialDispenserTimeLag != 0) {
        InitialDispenserTimeLag = other.InitialDispenserTimeLag;
      }
      if (other.DispenserBuildPressureSpeed != 0) {
        DispenserBuildPressureSpeed = other.DispenserBuildPressureSpeed;
      }
      if (other.DispenserBuildPressureLimit != 0D) {
        DispenserBuildPressureLimit = other.DispenserBuildPressureLimit;
      }
      if (other.DispenserBuildPressureTimeout != 0) {
        DispenserBuildPressureTimeout = other.DispenserBuildPressureTimeout;
      }
      if (other.DispenserBuildPressureLag != 0) {
        DispenserBuildPressureLag = other.DispenserBuildPressureLag;
      }
      if (other.ACHeatersLowerOperationLimit != 0) {
        ACHeatersLowerOperationLimit = other.ACHeatersLowerOperationLimit;
      }
      if (other.ACHeatersUpperOperationLimit != 0) {
        ACHeatersUpperOperationLimit = other.ACHeatersUpperOperationLimit;
      }
      if (other.DCHeatersLowerOperationLimit != 0) {
        DCHeatersLowerOperationLimit = other.DCHeatersLowerOperationLimit;
      }
      if (other.DCHeatersUpperOperationLimit != 0) {
        DCHeatersUpperOperationLimit = other.DCHeatersUpperOperationLimit;
      }
      if (other.MidTankPressureCorrection != 0D) {
        MidTankPressureCorrection = other.MidTankPressureCorrection;
      }
      if (other.DispenserPresegmentWFCF != 0D) {
        DispenserPresegmentWFCF = other.DispenserPresegmentWFCF;
      }
      if (other.StartHeatingOnInitSequence != false) {
        StartHeatingOnInitSequence = other.StartHeatingOnInitSequence;
      }
      generalParameters_.Add(other.generalParameters_);
      if (other.CurrentAlarmLowLimit != 0D) {
        CurrentAlarmLowLimit = other.CurrentAlarmLowLimit;
      }
      if (other.CurrentAlarmHighLimit != 0D) {
        CurrentAlarmHighLimit = other.CurrentAlarmHighLimit;
      }
      if (other.IDSSegmentRefillTimeout != 0D) {
        IDSSegmentRefillTimeout = other.IDSSegmentRefillTimeout;
      }
      if (other.IDSPreSegmentBuildupTime != 0D) {
        IDSPreSegmentBuildupTime = other.IDSPreSegmentBuildupTime;
      }
      if (other.IDSCleaningSpeed != 0D) {
        IDSCleaningSpeed = other.IDSCleaningSpeed;
      }
      if (other.IDSCleaningStopBeforeSegmentTime != 0D) {
        IDSCleaningStopBeforeSegmentTime = other.IDSCleaningStopBeforeSegmentTime;
      }
      if (other.IDSLeftCleaningMotorSpeed != 0D) {
        IDSLeftCleaningMotorSpeed = other.IDSLeftCleaningMotorSpeed;
      }
      if (other.IDSRightCleaningMotorSpeed != 0D) {
        IDSRightCleaningMotorSpeed = other.IDSRightCleaningMotorSpeed;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            BreakSensorLimit = input.ReadUInt32();
            break;
          }
          case 16: {
            DiagnosticCollectionLimit = input.ReadUInt32();
            break;
          }
          case 24: {
            OverHeatCountLimit = input.ReadUInt32();
            break;
          }
          case 32: {
            UnderHeatCountLimit = input.ReadUInt32();
            break;
          }
          case 40: {
            CloseValveTimeout = input.ReadUInt32();
            break;
          }
          case 48: {
            OpenValveTimeout = input.ReadUInt32();
            break;
          }
          case 57: {
            InitialDispenserPressure = input.ReadDouble();
            break;
          }
          case 64: {
            InitialDispenserTimeout = input.ReadUInt32();
            break;
          }
          case 72: {
            InitialDispenserTimeLag = input.ReadUInt32();
            break;
          }
          case 80: {
            DispenserBuildPressureSpeed = input.ReadUInt32();
            break;
          }
          case 89: {
            DispenserBuildPressureLimit = input.ReadDouble();
            break;
          }
          case 96: {
            DispenserBuildPressureTimeout = input.ReadUInt32();
            break;
          }
          case 104: {
            DispenserBuildPressureLag = input.ReadUInt32();
            break;
          }
          case 112: {
            ACHeatersLowerOperationLimit = input.ReadUInt32();
            break;
          }
          case 120: {
            ACHeatersUpperOperationLimit = input.ReadUInt32();
            break;
          }
          case 128: {
            DCHeatersLowerOperationLimit = input.ReadUInt32();
            break;
          }
          case 136: {
            DCHeatersUpperOperationLimit = input.ReadUInt32();
            break;
          }
          case 145: {
            MidTankPressureCorrection = input.ReadDouble();
            break;
          }
          case 153: {
            DispenserPresegmentWFCF = input.ReadDouble();
            break;
          }
          case 160: {
            StartHeatingOnInitSequence = input.ReadBool();
            break;
          }
          case 170:
          case 169: {
            generalParameters_.AddEntriesFrom(input, _repeated_generalParameters_codec);
            break;
          }
          case 177: {
            CurrentAlarmLowLimit = input.ReadDouble();
            break;
          }
          case 185: {
            CurrentAlarmHighLimit = input.ReadDouble();
            break;
          }
          case 193: {
            IDSSegmentRefillTimeout = input.ReadDouble();
            break;
          }
          case 201: {
            IDSPreSegmentBuildupTime = input.ReadDouble();
            break;
          }
          case 209: {
            IDSCleaningSpeed = input.ReadDouble();
            break;
          }
          case 217: {
            IDSCleaningStopBeforeSegmentTime = input.ReadDouble();
            break;
          }
          case 225: {
            IDSLeftCleaningMotorSpeed = input.ReadDouble();
            break;
          }
          case 233: {
            IDSRightCleaningMotorSpeed = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code