using System;
using Wayne.ForecourtControl.OptBridge;
using Wayne.Lib;
using Wayne.FDCPOSLibrary;
using System.Text;
using System.Threading;
using System.Globalization;


namespace Wayne.ForecourtControl.Fusion
{
    public class Heartbeat
    {
        private Timer heartbeatTimer = null;
        private Timer disconnectionTimer = null;
        public event EventHandler OnHeartbeatTimeout;
        public event EventHandler OnHeartbeatInterval;
        public long heartbeatTimeout = 30000;
        public long heartbeatInterval = 10000;

        public bool tryingConnect = false;
        public bool connecting = false;

        public IFSFManager ifsfManager;

        public Heartbeat(IFSFManager _ifsfManager, long _heartbeatInterval, long _heartbeatTimeout)
        {
            ifsfManager = _ifsfManager;
            heartbeatInterval = _heartbeatInterval;
            heartbeatTimeout = _heartbeatTimeout;
        }

        private void HeartbeatTimeout(Object state)
        {
            lock (ifsfManager.SyncObject)
            {
                Trace.WriteLine(string.Format("Heartbeat Timeout - Id={0}", this.ifsfManager.clientSocket.Id));
                if (OnHeartbeatTimeout != null)
                    OnHeartbeatTimeout.Invoke(this, null);
                if (disconnectionTimer != null)
                    disconnectionTimer.Dispose();
                if (heartbeatTimeout > 0)
                    disconnectionTimer = new System.Threading.Timer(new System.Threading.TimerCallback(HeartbeatTimeout), this, heartbeatTimeout, System.Threading.Timeout.Infinite);
            }
        }

        private void HeartbeatInterval(Object state)
        {
            lock (ifsfManager.SyncObject)
            {
                if (OnHeartbeatInterval != null)
                    OnHeartbeatInterval.Invoke(this, null);
            }
        }

        public void ResetDisconnectionTimeout()
        {
            if (disconnectionTimer != null)
                disconnectionTimer.Dispose();
            if (heartbeatTimeout > 0)
                disconnectionTimer = new System.Threading.Timer(new System.Threading.TimerCallback(HeartbeatTimeout), this, heartbeatTimeout, System.Threading.Timeout.Infinite);
        }

        public void Restart()
        {
            lock (ifsfManager.SyncObject)
            {
                // start sending heartbeat when receive logon and send 
                if (heartbeatTimer != null)
                {
                    heartbeatTimer.Dispose();
                    heartbeatTimer = null;
                }
                if (heartbeatInterval > 0)
                    heartbeatTimer = new System.Threading.Timer(new System.Threading.TimerCallback(HeartbeatInterval), this, heartbeatInterval, System.Threading.Timeout.Infinite);
            }
        }

        public void NotifyDisconnection()
        {
            lock (ifsfManager.SyncObject)
            {
                tryingConnect = true;
                //if (disconnectionTimer != null)
                //    disconnectionTimer.Dispose();
                Restart();
            }
        }
    }

    #region Event Args
    public class DeviceStateChangedEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public LogicalDeviceState state;
        public LogicalDeviceState substate;
        public string lockingAS;
        public int nozzleUp;

        public DeviceStateChangedEventArgs(string _deviceType, int _deviceId, LogicalDeviceState _state, LogicalDeviceState _substate, string _lockingAS, int _nozzleUp)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            state = _state;
            substate = _substate;
            lockingAS = _lockingAS;
            nozzleUp = _nozzleUp;
        }
    }

    public class VIRStateChangedEventArgs : EventArgs
    {
        public int deviceId;
        public string virId;
        public DeviceConnectionState state;

        public VIRStateChangedEventArgs(int _deviceId, string _virId, DeviceConnectionState _state)
        {
            deviceId = _deviceId;
            virId = _virId;
            state = _state;
        }
    }

    public class FuelModeChangedEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public int mode;

        public FuelModeChangedEventArgs(string _deviceType, int _deviceId, int _mode)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            mode = _mode;
        }
    }

    public class CurrentFuellingStatusEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public int nozzleId;
        public decimal volume;
        public decimal amount;
        public decimal price;
        public string authAS;

        public CurrentFuellingStatusEventArgs(string _deviceType, int _deviceId, int _nozzleId, decimal _volume, decimal _amount, decimal _price, string _authAS)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            nozzleId = _nozzleId;
            volume = _volume;
            amount = _amount;
            price = _price;
            authAS = _authAS;
        }
    }

    public class FuelPointTotalsEventArgs : EventArgs
    {
        public int requestId;
        public bool overallResult;
        public string deviceType;
        public int deviceId;
        public int nozzleId;
        public decimal volume;
        public decimal amount;
        public decimal price;

        public FuelPointTotalsEventArgs(int _requestId, bool _overallResult, string _deviceType, int _deviceId, int _nozzleId, decimal _volume, decimal _amount, decimal _price)
        {
            requestId = _requestId;
            overallResult = _overallResult;
            deviceType = _deviceType;
            deviceId = _deviceId;
            nozzleId = _nozzleId;
            volume = _volume;
            amount = _amount;
            price = _price;
        }
    }

    public class FuelSaleTrxEventArgs : EventArgs
    {
        public int transactionId;
        public Wayne.FDCPOSLibrary.FuellingState transactionStatus;
        public int completionReason;
        public string deviceType;
        public int deviceId;
        public int nozzleId;
        public decimal volume;
        public decimal amount;
        public decimal price;
        public int fuelMode;
        public DateTime trxStartDateTime;
        public DateTime trxEndDateTime;
        public string lockingAS;
        public string authAS;
        //public byte[] DSPFields;
        //public byte[] CRCMode;
        public string DSPFields;
        public string CRCMode;
        public string MIDLinesNarrow;
        public string MIDLinesWide;
        public int releaseToken;
        public byte reservingDeviceId;
        public FuellingType fuellingType;

        public FuelSaleTrxEventArgs(int _transactionId, Wayne.FDCPOSLibrary.FuellingState _transactionStatus, int _completionReason, string _deviceType, int _deviceId, int _nozzleId, decimal _volume, decimal _amount, decimal _price, int _fuelMode, DateTime _trxStartDateTime, DateTime _trxEndDateTime, string _lockingAS, string _authAS, string /*byte[]*/ _DSPFields, string /*byte[]*/ _CRCMode, string _MIDLinesNarrow, string _MIDLinesWide, int _releaseToken, byte _reservingDeviceId, FuellingType _fuellingType)
        {
            transactionId = _transactionId;
            transactionStatus = _transactionStatus;
            completionReason = _completionReason;
            deviceType = _deviceType;
            deviceId = _deviceId;
            nozzleId = _nozzleId;
            volume = _volume;
            amount = _amount;
            price = _price;
            fuelMode = _fuelMode;
            trxStartDateTime = _trxStartDateTime;
            trxEndDateTime = _trxEndDateTime;
            lockingAS = _lockingAS;
            authAS = _authAS;
            DSPFields = _DSPFields;
            CRCMode = _CRCMode;
            MIDLinesNarrow = _MIDLinesNarrow;
            MIDLinesWide = _MIDLinesWide;
            releaseToken = _releaseToken;
            reservingDeviceId = _reservingDeviceId;
            fuellingType = _fuellingType;
        }
    }

    public class ChangeFuelPriceEventArgs : EventArgs
    {
        public int productId;
        public int mode;
        public decimal oldPrice;
        public decimal newPrice;

        public ChangeFuelPriceEventArgs(int _productId, int _mode, decimal _oldPrice, decimal _newPrice)
        {
            productId = _productId;
            mode = _mode;
            oldPrice = _oldPrice;
            newPrice = _newPrice;
        }
    }

    public class DeviceAlarmEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public int alarmId;
        public string alarmDescr;

        public DeviceAlarmEventArgs(string _deviceType, int _deviceId, int _alarmId, string _alarmDescr)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            alarmId = _alarmId;
            alarmDescr = _alarmDescr;
        }
    }

    public class VersionInfoEventArgs : EventArgs
    {
        public string release;
        public string version;
        public string hotfix;

        public VersionInfoEventArgs(string _release, string _version, string _hotfix)
        {
            version = _version;
            release = _release;
            hotfix = _hotfix;
        }
    }

    public class TankDataEventArgs : EventArgs
    {
        int DeviceID;
        int TankNo;
        string Type;
        int ManualMode;
        decimal AverageTemp;
        decimal GrossStandardVolume;
        decimal ObservedDensity;
        decimal ProductLevel;
        decimal TotalObservedVolume;
        decimal WaterLevel;
        int TPStatus;

        public TankDataEventArgs(int _DeviceID, int _TankNo, string _Type, int _ManualMode,
            decimal _AverageTemp, decimal _GrossStandardVolume, decimal _ObservedDensity,
            decimal _ProductLevel, decimal _TotalObservedVolume, decimal _WaterLevel, int _TPStatus)
        {
            DeviceID = _DeviceID;
            TankNo = _TankNo;
            Type = _Type;
            ManualMode = _ManualMode;
            AverageTemp = _AverageTemp;
            GrossStandardVolume = _GrossStandardVolume;
            ObservedDensity = _ObservedDensity;
            ProductLevel = _ProductLevel;
            TotalObservedVolume = _TotalObservedVolume;
            WaterLevel = _WaterLevel;
            TPStatus = _TPStatus;
        }
    }

    public class GetConfigurationRespEventArgs : EventArgs
    {
        public ServiceResponseGetConfiguration sr = null;
        public EventHandler<AsyncCompletedEventArgs> getConfigurationRequestCompleted = null;
        public object getConfigurationUserToken = null;
        public int requestId;
        public bool result;
        public GetConfigurationRespEventArgs(int _requestId, bool _result, ServiceResponseGetConfiguration _sr, EventHandler<AsyncCompletedEventArgs> _getConfigurationRequestCompleted, object _getConfigurationUserToken)
        {
            sr = _sr;
            getConfigurationRequestCompleted = _getConfigurationRequestCompleted;
            getConfigurationUserToken = _getConfigurationUserToken;
            requestId = _requestId;
            result = _result;
        }
    }
    public class GetConfigurationEventArgs : EventArgs
    {
        public ServiceResponseGetConfiguration sr = null;
        public GetConfigurationEventArgs(ServiceResponseGetConfiguration _sr)
        {
            sr = _sr;
        }
    }

    public class GetProductTableEventArgs : EventArgs
    {
        public ServiceResponseGetProductTable sr;
        public GetProductTableEventArgs(ServiceResponseGetProductTable _sr)
        {
            sr = _sr;
        }
    }

    public class OptReadEventArgs : EventArgs
    {
        public string deviceType;
        public int deviceId;
        public byte[] message;

        public OptReadEventArgs(string _deviceType, int _deviceId, byte[] _message)
        {
            deviceType = _deviceType;
            deviceId = _deviceId;
            message = _message;
        }
    }

    #endregion

    public class IFSFManager
    {
        public bool isConfigRead = false;
        public bool isForcedToDisconnect = false;
        public int count = 0;
        public ServiceRequestSetConfiguration serviceRequestSetConfiguration;
        public ServiceRequest serviceRequestLogOn;
        private IFSFSockets _clientSocket;
        public IFSFSockets clientSocket
        {
            get { return _clientSocket; }
        }

        private Heartbeat _heartbeat;
        public Heartbeat heartbeat
        {
            get { return _heartbeat; }
        }

        private object _syncObject = new object();
        internal object SyncObject
        {
            get { return _syncObject; }
        }
        public bool authentificationErrorRetry;

        public event EventHandler<DeviceStateChangedEventArgs> OnDeviceStateChange;
        public event EventHandler<VIRStateChangedEventArgs> OnVirStateChange;
        public event EventHandler<FuelModeChangedEventArgs> OnFuelModeChange;
        public event EventHandler<CurrentFuellingStatusEventArgs> OnCurrentFuellingStatus;
        public event EventHandler<FuelPointTotalsEventArgs> OnFuelPointTotals;
        public event EventHandler<FuelSaleTrxEventArgs> OnFuelSaleTrx;
        public event EventHandler<DeviceAlarmEventArgs> OnDeviceAlarm;
        public event EventHandler<VersionInfoEventArgs> OnVersionInfo;
        public event EventHandler<ChangeFuelPriceEventArgs> OnChangeFuelPrice;
        public event EventHandler<FuelSaleTrxEventArgs> OnLockFuelSaleTrx;
        public event EventHandler<FuelSaleTrxEventArgs> OnUnlockFuelSaleTrx;
        public event EventHandler<FuelSaleTrxEventArgs> OnClearFuelSaleTrx;
        public event EventHandler<FuelSaleTrxEventArgs> OnGetAvailableFuelSaleTrx;
        public event EventHandler<FuelSaleTrxEventArgs> OnGetFuelSaleTrxDetails;
        public event EventHandler<GetConfigurationEventArgs> OnGetConfiguration;
        public event EventHandler<GetProductTableEventArgs> OnGetProductTable;
        public event EventHandler<OptReadEventArgs> OnOptRead;
        public event EventHandler<TankDataEventArgs> OnTankData;
        public event EventHandler<EventArgs> OnConfigurationChange;
        public event EventHandler<EventArgs> OnTwinMasterReady;
        public readonly ConfigurationParams ConfigParam;

        public IFSFManager(int id, ConfigurationParams configParam)
        {
            ConfigParam = configParam;
            this._clientSocket = new IFSFSockets(id, this);
            this._clientSocket.OnResponseTimeout += new EventHandler(_clientSocket_OnResponseTimeout);

            this._heartbeat = new Heartbeat(this, this._clientSocket.heartbeatInterval, this._clientSocket.heartbeatTimeout);
            heartbeat.OnHeartbeatInterval += new EventHandler(heartbeat_OnHeartbeatInterval);
            heartbeat.OnHeartbeatTimeout += new EventHandler(heartbeat_OnHeartbeatTimeout);
            serviceRequestSetConfiguration = null;

            authentificationErrorRetry = true;
        }

        public static void ArrayResize<T>(ref T[] array, int newSize)
        {
            int oldSize = (array == null) ? 0 : array.Length;
            T[] newArray = new T[newSize];
            int preserveLength = System.Math.Min(oldSize, newSize);
            for (int i = 0; i < preserveLength; i++)
                newArray[i] = array[i];
            array = newArray;
        }

        public LogicalDeviceState convertLogicalDeviceState(string state)
        {
            var logicalDeviceState = EnumSupport.ParseDefaultNull<LogicalDeviceState>(state, true);
            return logicalDeviceState ?? 0;
        }

        public Wayne.FDCPOSLibrary.FuellingState convertFuellingState(string state)
        {
            if (state == Wayne.FDCPOSLibrary.FuellingState.Locked.ToString())
                return Wayne.FDCPOSLibrary.FuellingState.Locked;
            else if (state == Wayne.FDCPOSLibrary.FuellingState.Payable.ToString())
                return Wayne.FDCPOSLibrary.FuellingState.Payable;
            else if (state == Wayne.FDCPOSLibrary.FuellingState.Paid.ToString() || state == Wayne.FDCPOSLibrary.FuellingState.Cleared.ToString())
                return Wayne.FDCPOSLibrary.FuellingState.Paid;
            return 0;
        }

        public static string getClientID(string workstationID, string applicationSender)
        {
            return workstationID + "-" + applicationSender;
        }

        public void Disconnect()
        {
            isForcedToDisconnect = false; // reset value
            Trace.WriteLine("IFSFManager - Disconnect() before locking - Id=" + clientSocket.Id);
            lock (SyncObject)
            {
                Trace.WriteLine("IFSFManager - Disconnect()-calling clientSocket.Disconnect() - Id=" + clientSocket.Id);
                clientSocket.Disconnect();
                clientSocket.mainConnectionState = DeviceConnectionState.Disconnected;
            }
            if (heartbeat != null)
                heartbeat.NotifyDisconnection();
        }

        private void _clientSocket_OnResponseTimeout(object sender, EventArgs e)
        {
            //FG, MAR-15-2011, bug fix #28041; trigger to GetConfiguration again if there's no pump on FM.
            if (!isConfigRead && ((Wayne.Lib.EventArgs<string>)(e)).Argument == "GetConfiguration")
            {
                Trace.WriteLine("GetConfiguration() timedout!");
                //this.GetConfiguration(null, null, null);
            }
            if (this.OnDeviceAlarm != null)
            {
                //AsyncResponseOperation aro = (AsyncResponseOperation)sender;
                //string deviceType = "";
                //int deviceId = 0;
                //int alarmId = 0;
                //string alarmmsg = string.Format("Timeout nella risposta - requestId: '{0}', requestType: '{1}'", aro.requestId, aro.requestType);
                //OnDeviceAlarm.Invoke(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg));
            }
        }

        private void heartbeat_OnHeartbeatTimeout(object sender, EventArgs e)
        {
            Trace.WriteLine("Heartbeat Timeout - disconnecting");
            //if (clientSocket.mainConnectionState != DeviceConnectionState.Disconnected || this.heartbeat.tryingConnect)
            {
                //clientSocket.Disconnect();
                isForcedToDisconnect = true;  // forcing Disconnect because this is a heartbeat disconnection
                Disconnect();
                clientSocket.mainConnectionState = DeviceConnectionState.Disconnected;
            }
        }

        private void heartbeat_OnHeartbeatInterval(object sender, EventArgs e)
        {
            Heartbeat();
        }

        public string ReadResponse(string myString, int msglength, ref OverallResult result) //StreamReader networkStream)
        {
            string requestType = "";
            int requestId = 0;
            try
            {
                requestType = GetRequestType("RequestType", myString);
                requestId = GetRequestID("RequestID", myString);
            }
            catch (Exception ex)
            {
                Trace.WriteLine(string.Format("Unable to get request type or id - Exception! {0}", ex.Message));
                //result = OverallResult.Failure;
            }
            if (result != OverallResult.Success)
            {
                Trace.WriteLine(string.Format("ReadResponse ERROR result='{0}'", result));
            }
            else
            {

                if (requestType == "")
                {
                    Trace.WriteLine(string.Format("ReadResponse INVALID requestType='{0}', requestId={1}", requestType, requestId));
                    result = OverallResult.FormatError;
                    //return requestType;
                }
                //int headerlength = getMsgLength(myString.Substring(0, Define.HeaderLength));
                //myString = myString.Substring(Define.HeaderLength + Define.EncriptionLength);
                int UTFlength = System.Text.Encoding.UTF8.GetBytes(myString).Length;
                if (result == OverallResult.Success && UTFlength != msglength)
                {
                    Trace.WriteLine(string.Format("ReadResponse header='{0}' != msgLength={1}, requestType='{2}', requestId={3}", msglength, UTFlength, requestType, requestId));
                    result = OverallResult.FormatError;
                    //return requestType;
                }
                else
                {
                    try
                    {
                        //string myString = networkStream.ReadToEnd();

                        Trace.WriteLine(string.Format("ReadResponse init: requestType='{0}', requestId={1}", requestType, requestId));
                        switch (requestType)
                        {
                            case "LogOn":
                                {
                                    ServiceResponseLogOn sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLogOn>(myString, ref result);
                                    LogOnResp(sr.OverallResult, sr.Value, sr.FDCdata[0].FDCTimeStamp);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "LogOff":
                                {
                                    ServiceResponseLogOff sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLogOff>(myString, ref result);
                                    LogOffResp(sr.OverallResult);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "VersionInfo":
                                {
                                    ServiceResponseVersionInfo sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseVersionInfo>(myString, ref result);
                                    VersionInfoResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "StartForecourt":
                                {
                                    ServiceResponseStartForecourt sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseStartForecourt>(myString, ref result);
                                    string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].ErrorCode;
                                    StartForecourtResp(sr.RequestIDNumber, sr.OverallResult, errorCode);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "TwinOpenMaster":
                                {
                                    ServiceResponseTwinOpenMaster sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseTwinOpenMaster>(myString, ref result);
                                    string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].ErrorCode;
                                    TwinOpenMasterResp(sr.RequestIDNumber, sr.OverallResult, errorCode);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "StopForecourt":
                                {
                                    ServiceResponseStopForecourt sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseStopForecourt>(myString, ref result);
                                    string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].ErrorCode;
                                    StopForecourtResp(sr.RequestIDNumber, sr.OverallResult, errorCode);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetCurrentFuellingStatus":
                                {
                                    ServiceResponseGetCurrentFuellingStatus sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetCurrentFuellingStatus>(myString, ref result);
                                    GetCurrentFuellingStatusResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetFuelPointTotals":
                                {
                                    ServiceResponseGetFuelPointTotals sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelPointTotals>(myString, ref result);
                                    GetFuelPointTotalsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetDeviceState":
                                {
                                    ServiceResponseGetDeviceState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetDeviceState>(myString, ref result);
                                    GetDeviceStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetFPState":
                                {
                                    ServiceResponseGetFPState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFPState>(myString, ref result);
                                    GetFPStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetTPState":
                                {
                                    ServiceResponseGetTPState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetTPState>(myString, ref result);
                                    GetTPStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetPPState":
                                {
                                    ServiceResponseGetPPState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetPPState>(myString, ref result);
                                    GetPPStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetVIRState":
                                {
                                    ServiceResponseGetVIRState sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetVIRState>(myString, ref result);
                                    GetVIRStateResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "TerminateFuelling":
                                {
                                    ServiceResponseTerminateFuelling sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseTerminateFuelling>(myString, ref result);
                                    TerminateFuellingResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "AuthoriseFuelPoint":
                                {
                                    ServiceResponseAuthoriseFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseAuthoriseFuelPoint>(myString, ref result);
                                    AuthoriseFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "ChangeFuelMode":
                                {
                                    ServiceResponseChangeFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseChangeFuelMode>(myString, ref result);
                                    ChangeFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "ChangeFPFuelMode":
                                {
                                    ServiceResponseChangeFPFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseChangeFPFuelMode>(myString, ref result);
                                    ChangeFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "ChangeFuelPrice":
                                {
                                    ServiceResponseChangeFuelPrice sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseChangeFuelPrice>(myString, ref result);
                                    ChangeFuelPriceResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "LockFuelSaleTrx":
                                {
                                    ServiceResponseLockFuelSaleTrx sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLockFuelSaleTrx>(myString, ref result);
                                    LockFuelSaleTrxResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "UnlockFuelSaleTrx":
                                {
                                    ServiceResponseUnlockFuelSaleTrx sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseUnlockFuelSaleTrx>(myString, ref result);
                                    UnlockFuelSaleTrxResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "ClearFuelSaleTrx":
                                {
                                    ServiceResponseClearFuelSaleTrx sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseClearFuelSaleTrx>(myString, ref result);
                                    ClearFuelSaleTrxResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetAvailableFuelSaleTrxs":
                                {
                                    ServiceResponseGetAvailableFuelSaleTrxs sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetAvailableFuelSaleTrxs>(myString, ref result);
                                    GetAvailableFuelSaleTrxsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetFuelSaleTrxDetails":
                                {
                                    string res = "";
                                    if (FDCGlobal.ProtocolVersion == FDCVersion.V0003)
                                    {
                                        ServiceResponseGetFuelSaleTrxDetailsV03 sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelSaleTrxDetailsV03>(myString, ref result);
                                        GetFuelSaleTrxDetailsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                        res = sr.OverallResult;
                                    }
                                    else
                                    {
                                        ServiceResponseGetFuelSaleTrxDetails sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelSaleTrxDetails>(myString, ref result);
                                        GetFuelSaleTrxDetailsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                        res = sr.OverallResult;
                                    }
                                    result = FDCConvert.OverallResultToInt(res);
                                }
                                break;
                            case "GetProductTable":
                                {
                                    ServiceResponseGetProductTable sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetProductTable>(myString, ref result);
                                    GetProductTableResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetModeTable":
                                {
                                    ServiceResponseGetModeTable sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetModeTable>(myString, ref result);
                                    GetModeTableResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetFuelMode":
                                {
                                    ServiceResponseGetFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFuelMode>(myString, ref result);
                                    GetFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetFPFuelMode":
                                {
                                    ServiceResponseGetFPFuelMode sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetFPFuelMode>(myString, ref result);
                                    GetFuelModeResp(sr.RequestIDNumber, sr.OverallResult, sr.FDCdata);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetConfiguration":
                                {
                                    ServiceResponseGetConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetConfiguration>(myString, ref result);
                                    GetConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetDSPConfiguration":
                                {
                                    ServiceResponseGetDSPConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetDSPConfiguration>(myString, ref result);
                                    GetDSPConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetTLGConfiguration":
                                {
                                    ServiceResponseGetTLGConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetTLGConfiguration>(myString, ref result);
                                    GetTLGConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetPPConfiguration":
                                {
                                    ServiceResponseGetPPConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetPPConfiguration>(myString, ref result);
                                    //GetPPConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "SetConfiguration":
                                {
                                    ServiceResponseSetConfiguration sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseSetConfiguration>(myString, ref result);
                                    SetConfigurationResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "LockNozzle":
                                {
                                    ServiceResponseLockNozzle sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLockNozzle>(myString, ref result);
                                    LockNozzleResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "UnlockNozzle":
                                {
                                    ServiceResponseUnlockNozzle sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseUnlockNozzle>(myString, ref result);
                                    UnlockNozzleResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetCountrySettings":
                                {
                                    ServiceResponseGetCountrySettings sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetCountrySettings>(myString, ref result);
                                    GetCountrySettingsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetDSPLimits":
                                {
                                    ServiceResponseGetDSPLimits sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetDSPLimits>(myString, ref result);
                                    GetDSPLimitsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "ChangeDSPLimits":
                                {
                                    ServiceResponseChangeDSPLimits sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseChangeDSPLimits>(myString, ref result);
                                    ChangeDSPLimitsResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "SuspendFuelling":
                                {
                                    ServiceResponseSuspendFuelling sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseSuspendFuelling>(myString, ref result);
                                    SuspendFuellingResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "ResumeFuelling":
                                {
                                    ServiceResponseResumeFuelling sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseResumeFuelling>(myString, ref result);
                                    ResumeFuellingResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "LockTank":
                                {
                                    ServiceResponseLockTank sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseLockTank>(myString, ref result);
                                    LockTankResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "UnlockTank":
                                {
                                    ServiceResponseUnlockTank sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseUnlockTank>(myString, ref result);
                                    UnlockTankResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "GetTankData":
                                {
                                    ServiceResponseGetTankData sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseGetTankData>(myString, ref result);
                                    GetTankDataResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "ReserveFuelPoint":
                                {
                                    ServiceResponseReserveFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseReserveFuelPoint>(myString, ref result);
                                    ReserveFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "FreeFuelPoint":
                                {
                                    ServiceResponseFreeFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseFreeFuelPoint>(myString, ref result);
                                    FreeFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "StartFuelPointTest":
                                {
                                    ServiceResponseStartFuelPointTest sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseStartFuelPointTest>(myString, ref result);
                                    StartFuelPointTestResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "EndFuelPointTest":
                                {
                                    ServiceResponseEndFuelPointTest sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseEndFuelPointTest>(myString, ref result);
                                    EndFuelPointTestResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "OpenFuelPoint":
                                {
                                    ServiceResponseOpenFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOpenFuelPoint>(myString, ref result);
                                    OpenFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "CloseFuelPoint":
                                {
                                    ServiceResponseCloseFuelPoint sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseCloseFuelPoint>(myString, ref result);
                                    CloseFuelPointResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "OpenDevice":
                                {
                                    ServiceResponseOpenDevice sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOpenDevice>(myString, ref result);
                                    OpenDeviceResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "CloseDevice":
                                {
                                    ServiceResponseCloseDevice sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseCloseDevice>(myString, ref result);
                                    CloseDeviceResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "SetDeviceAlarm":
                                {
                                    ServiceResponseSetDeviceAlarm sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseSetDeviceAlarm>(myString, ref result);
                                    SetDeviceAlarmResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "OPTAdd":
                                {
                                    ServiceResponseOPTAdd sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOPTAdd>(myString, ref result);
                                    OptAddResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "OPTRemove":
                                {
                                    ServiceResponseOPTRemove sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOPTRemove>(myString, ref result);
                                    OptRemoveResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            case "OPTWrite":
                                {
                                    ServiceResponseOPTWrite sr = clientSocket.ifsfMessages.Deserialize<ServiceResponseOPTWrite>(myString, ref result);
                                    OptWriteResp(sr.RequestIDNumber, sr.OverallResult, sr);
                                    result = FDCConvert.OverallResultToInt(sr.OverallResult);
                                }
                                break;
                            default:
                                break;
                        }
                        Trace.WriteLine(string.Format("ReadResponse end: requestType={0}, requestId={1}", requestType, requestId));
                    }
                    catch (Exception ex)
                    {
                        Trace.WriteLine(string.Format("ReadResponse RequestType='{0}', requestId={1} Exception! {2} - {3}", requestType, requestId, ex.Message, ex.StackTrace));
                        result = OverallResult.Failure;
                    }
                }

            }
            if (result != OverallResult.Success)
            {
                if (result != OverallResult.NoData)
                {
                    //AsyncResponseOperation aro = (AsyncResponseOperation)sender;
                    string deviceType = "";
                    int deviceId = 0;
                    int alarmId = 0;
                    string alarmmsg = string.Format("Error '{0}' receiving Response for requestId:'{1}', requestType:'{2}'", result.ToString(), requestId, requestType);
                    OnDeviceAlarm.BeginInvoke(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg), null, null);
                }
            }
            return requestType;
        }

        public string ReadMessage(string myString, int msglength, ref OverallResult result) //StreamReader networkStream)
        {
            if (result != OverallResult.Success)
            {
                Trace.WriteLine(string.Format("ReadMessage ERROR result='{0}'", result));
            }
            string requestType = GetRequestType("MessageType", myString);
            int requestId = GetRequestID("MessageID", myString);
            Trace.WriteLine(string.Format("ReadMessage init: MessageType='{0}', requestId={1}", requestType, requestId));
            if (requestType == "")
            {
                Trace.WriteLine(string.Format("ReadMessage INVALID requestType='{0}', requestId={1}", requestType, requestId));
                return requestType;
            }
            //int headerlength = getHeaderLength(myString.Substring(0, Define.HeaderLength));
            //myString = myString.Substring(Define.HeaderLength + Define.EncriptionLength);
            int UTFlength = System.Text.Encoding.UTF8.GetBytes(myString).Length;
            if (UTFlength != msglength)
            {
                Trace.WriteLine(string.Format("ReadMessage header='{0}' != msgLength={1}", msglength, UTFlength));
                result = OverallResult.FormatError;
                return requestType;
            }
            try
            {
                //string myString = networkStream.ReadToEnd();

                switch (requestType)
                {
                    case "FDCHeartBeat":
                        {
                            FDCMessageFDCHeartbeat msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFDCHeartbeat>(myString, ref result);
                            HeartbeatMsg();
                        }
                        break;
                    case "FDCStarted":
                        {
                            FDCMessageStarted msg = clientSocket.ifsfMessages.Deserialize<FDCMessageStarted>(myString, ref result);
                            FDCStartedMsg(msg);
                        }
                        break;
                    case "FDCStopped":
                        {
                            FDCMessageStopped msg = clientSocket.ifsfMessages.Deserialize<FDCMessageStopped>(myString, ref result);
                            FDCStoppedMsg(msg);
                        }
                        break;
                    case "DeviceStateChange":
                        {
                            FDCMessageDeviceStateChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageDeviceStateChange>(myString, ref result);
                            DeviceStateChangeMsg(msg);
                        }
                        break;
                    case "FPStateChange":
                        {
                            FDCMessageFPStateChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFPStateChange>(myString, ref result);
                            FPStateChangeMsg(msg);
                        }
                        break;
                    case "CurrentFuellingStatus":
                        {
                            FDCMessageCurrentFuellingStatus msg = clientSocket.ifsfMessages.Deserialize<FDCMessageCurrentFuellingStatus>(myString, ref result);
                            CurrentFuellingStatusMsg(msg);
                        }
                        break;
                    case "DeviceAlarm":
                        {
                            FDCMessageDeviceAlarm msg = clientSocket.ifsfMessages.Deserialize<FDCMessageDeviceAlarm>(myString, ref result);
                            DeviceAlarmMsg(msg);
                        }
                        break;
                    case "FuelSaleTrx":
                        {
                            FDCMessageFuelSaleTrx msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFuelSaleTrx>(myString, ref result);
                            FuelSaleTrxMsg(msg);
                        }
                        break;
                    case "FuelPriceChange":
                        {
                            FDCMessageFuelPriceChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFuelPriceChange>(myString, ref result);
                            FuelPriceChangeMsg(msg);
                        }
                        break;
                    case "FuelModeChange":
                        {
                            FDCMessageFDCdataFuelModeChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFDCdataFuelModeChange>(myString, ref result);
                            FuelModeChangeMsg(msg);
                        }
                        break;
                    case "FDCExceptionMsg":
                        {
                            FDCMessageFDCExceptionMsg msg = clientSocket.ifsfMessages.Deserialize<FDCMessageFDCExceptionMsg>(myString, ref result);
                            FDCExceptionMsg(msg);
                        }
                        break;
                    case "ConfigurationChange":
                        {
                            FDCMessageConfigurationChange msg = clientSocket.ifsfMessages.Deserialize<FDCMessageConfigurationChange>(myString, ref result);
                            FDCMessageConfigurationChangeMsg(msg);
                        }
                        break;
                    case "OPTRead":
                        {
                            if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                            {
                                FDCMessageOPTReadV07 msg = clientSocket.ifsfMessages.Deserialize<FDCMessageOPTReadV07>(myString, ref result);
                                OptReadMsg(msg);
                            }
                            else
                            {
                                FDCMessageOPTRead msg = clientSocket.ifsfMessages.Deserialize<FDCMessageOPTRead>(myString, ref result);
                                OptReadMsg(msg);
                            }
                        }
                        break;
                }
                Trace.WriteLine(string.Format("ReadMessage end: ", requestType, requestId));
            }
            catch (Exception ex)
            {
                Trace.WriteLine(string.Format("ReadMessage MessageType='{0}', requestId={1} Exception! {2} - {3}", requestType, requestId, ex.Message, ex.StackTrace));
            }
            return requestType;
        }

        private string GetRequestType(string typeField, string myString)
        {
            string requestType = "";
            try
            {
                if (myString.IndexOf(typeField) >= 0)
                {
                    myString = myString.Substring(myString.IndexOf(typeField));
                    myString = myString.Substring(myString.IndexOf('\"') + 1);
                    requestType = myString.Substring(0, myString.IndexOf('\"'));
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            return requestType;
        }

        private int GetRequestID(string typeField, string myString)
        {
            int requestID = 0;
            try
            {
                if (myString.IndexOf(typeField) >= 0)
                {
                    myString = myString.Substring(myString.IndexOf(typeField));
                    myString = myString.Substring(myString.IndexOf('\"') + 1);
                    requestID = Convert.ToInt32(myString.Substring(0, myString.IndexOf('\"')));
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
            return requestID;
        }

        public void LogOn(string posInfo, string sFDCDateTime)
        {
            // POS open channel A and send LogOn command
            // FDC open channel B and C and send LogOn response

            try
            {
                Trace.WriteLine("LogOn init");
                LogOn(null, posInfo, sFDCDateTime);
                Trace.WriteLine("LogOn end");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("LogOn Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LogOn(byte[][] validationInfoArray, string posInfo, string sFDCDateTime)
        {
            // POS open channel A and send LogOn command
            // FDC open channel B and C and send LogOn response

            try
            {
                Trace.WriteLine(string.Format("LogOn2 init version={0}", FDCGlobal.ProtocolVersion));
                ServiceRequest logOn;
                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                {
                    // create XML ServiceRequest object
                    logOn = new ServiceRequestLogOnV07();
                    logOn.ApplicationSender = clientSocket.applicationSender;
                    logOn.WorkstationID = clientSocket.workstationID;

                    var posDataElem = new ServiceRequestPOSdataLogOnV07();
                    posDataElem.POSName = "";
                    if (sFDCDateTime == "")
                        posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                    else
                        posDataElem.POSTimeStamp = sFDCDateTime;
                    posDataElem.ResponsePort = clientSocket.iIPPortB.ToString();
                    posDataElem.UnsolicitedPort = clientSocket.iIPPortC.ToString();

                    posDataElem.interfaceVersion = FDCGlobal.VersionToString();
                    //posDataElem.InterfaceVersion = FDCGlobal.VersionToString(); // wont work for older versions

                    if (posInfo != "")
                    {
                        posDataElem.posInfo = UTF8Encoding.UTF8.GetBytes(posInfo);
                    }
                    if (validationInfoArray != null)
                    {
                        posDataElem.ValidationInfo = validationInfoArray;
                    }

                    ServiceRequestPOSdataLogOnV07[] posDataArray = { posDataElem };
                    ((ServiceRequestLogOnV07)logOn).POSdata = posDataArray;
                }
                else
                {
                    // create XML ServiceRequest object
                    logOn = new ServiceRequestLogOn();
                    logOn.ApplicationSender = clientSocket.applicationSender;
                    logOn.WorkstationID = clientSocket.workstationID;
                    //logOn.requestId = "";
                    //logOn.RequestType = "LogOn";

                    ServiceRequestPOSdataLogOn posDataElem = new ServiceRequestPOSdataLogOn();
                    posDataElem.POSName = "";
                    if (sFDCDateTime == "")
                        posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                    else
                        posDataElem.POSTimeStamp = sFDCDateTime;
                    posDataElem.ResponsePort = clientSocket.iIPPortB.ToString();
                    posDataElem.UnsolicitedPort = clientSocket.iIPPortC.ToString();
                    //posDataElem.interfaceVersion = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "FDCPOSInterfaceVersion");
                    posDataElem.interfaceVersion = FDCGlobal.VersionToString();
                    if (posInfo != "")
                    {
                        // Get UTF16 bytes and convert UTF16 bytes to UTF8 bytes
                        Trace.WriteLine(string.Format("EnqueueMessage logOn2 posInfo='{0}'", posInfo));
                        posDataElem.posInfo = posInfo;
                    }
                    if (validationInfoArray != null)
                    {
                        posDataElem.ValidationInfo = validationInfoArray;
                    }

                    // calculate posValidation string
                    string posValidationSourceString = logOn.ApplicationSender + logOn.WorkstationID + posDataElem.POSTimeStamp;
                    MD5Crypter crypter = new MD5Crypter();
                    byte[] posValidationSource = new byte[posValidationSourceString.Length + crypter.getPassphrase().GetLength(0)];
                    Array.Copy(System.Text.Encoding.ASCII.GetBytes(posValidationSourceString), posValidationSource, (int)posValidationSourceString.Length);
                    Array.Copy(crypter.getPassphrase(), 0, posValidationSource, (int)posValidationSourceString.Length, (int)crypter.getPassphrase().Length);
                    Trace.WriteLine(string.Format("EnqueueMessage logOn2 posValidationSource='{0}'", System.Text.Encoding.ASCII.GetString(posValidationSource, 0, posValidationSource.Length)));
                    byte[] posValidation = crypter.ComputeHash(posValidationSource);
                    posDataElem.posValidation = "";

                    StringBuilder sb = new StringBuilder(posValidation.Length * 2);
                    foreach (byte b in posValidation)
                        sb.Append(Convert.ToString(b, 16).PadLeft(2, '0'));
                    posDataElem.posValidation = sb.ToString().ToUpper();

                    Trace.WriteLine(string.Format("EnqueueMessage logOn2 posValidationSource='{0}',posValidation='{1}'", posValidationSource, posDataElem.posValidation));
                    ServiceRequestPOSdataLogOn[] posDataArray = { posDataElem };

                    ((ServiceRequestLogOn)logOn).POSdata = posDataArray;
                }

                Trace.WriteLine("EnqueueMessage logOn2");
                clientSocket.ifsfMessages.EnqueueMessage(logOn, null, null, null, true);
                Trace.WriteLine("LogOn2 end");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("LogOn2 Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LogOnAddValidationInfo(byte[] validationInfo)
        {
            // POS open channel A and send LogOn command
            // FDC open channel B and C and send LogOn response

            try
            {
                if (validationInfo == null)
                {
                    Trace.WriteLine("LogOnAddValidationInfo: null validationInfo");
                    return;
                }
                Trace.WriteLine("LogOnAddValidationInfo init");
                if (this._clientSocket.logOnSendCalled && this._clientSocket.validationInfo != null)
                {
                    this._clientSocket.validationInfo = null;
                    this._clientSocket.logOnSendCalled = false;
                    Trace.WriteLine("LogOnAddValidationInfo logOnSendCalled=false");
                }

                byte[][] ValidationInfo = this._clientSocket.validationInfo;
                IFSFManager.ArrayResize<byte[]>(ref ValidationInfo, (ValidationInfo != null) ? ValidationInfo.Length + 1 : 1);
                this._clientSocket.validationInfo = ValidationInfo;
                this._clientSocket.validationInfo[this._clientSocket.validationInfo.Length - 1] = new byte[validationInfo.Length];
                this._clientSocket.validationInfo[this._clientSocket.validationInfo.Length - 1] = validationInfo;

                Trace.WriteLine("LogOnAddValidationInfo end");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("LogOnAddValidationInfo Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LogOnSend(string posInfo)
        {
            // POS open channel A and send LogOn command
            // FDC open channel B and C and send LogOn response

            try
            {
                Trace.WriteLine("LogOnSend init");

                // create XML ServiceRequest object
                if (serviceRequestLogOn == null)
                {
                    LogOn(posInfo, "");
                }
                else
                {
                    Trace.WriteLine("EnqueueMessage logOn");
                    ServiceRequest logOn;
                    if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                        logOn = new ServiceRequestLogOnV07();
                    else
                        logOn = new ServiceRequestLogOn();
                    logOn = serviceRequestLogOn;
                    serviceRequestLogOn = null;
                    clientSocket.ifsfMessages.EnqueueMessage(logOn, (EventHandler<AsyncCompletedEventArgs>)null, null, null, true);
                }
                this._clientSocket.logOnSendCalled = true;
                Trace.WriteLine("LogOnSend logOnSendCalled=true");
                Trace.WriteLine("LogOnSend end");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("LogOnSend Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LogOnResp(string sOverallResult, string seal, string sFDCTimeStamp)
        {
            try
            {
                if (sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString())
                {
                    // must be called after LogOn successful because the server must register the client before receiving messages
                    heartbeat.Restart();

                    GetCountrySettings(null, null, null);

                    // check if != Connected becose FDCStart (that set state to Connected) could became before LogOnResp
                    if (clientSocket.mainConnectionState != DeviceConnectionState.Connected)
                        clientSocket.mainConnectionState = DeviceConnectionState.Connecting;

                    if (seal != "" && OnDeviceAlarm != null)
                    {
                        string deviceType = "";
                        int deviceId = 0;
                        int alarmId = 2020; // FUSION_IMSG_SEAL
                        string alarmmsg = seal;
                        OnDeviceAlarm.BeginInvoke(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg), null, null);
                    }
                }
                else if (sOverallResult == FDCPOSLibrary.OverallResult.AuthentificationError.ToString())
                {
                    Trace.WriteLine(string.Format("authentificationErrorRetry={0}, sFDCTimeStamp={1}", authentificationErrorRetry, sFDCTimeStamp));
                    if (authentificationErrorRetry)
                    {
                        authentificationErrorRetry = false;
                        this.LogOn(clientSocket.validationInfo, clientSocket.posInfo, sFDCTimeStamp);
                    }
                    else if (OnDeviceAlarm != null)
                    {
                        authentificationErrorRetry = true;
                        string deviceType = "";
                        int deviceId = 0;
                        int alarmId = 1001; //FUSION_E_AUTHENTIFICATION_FAILED
                        string alarmmsg = "";
                        OnDeviceAlarm.BeginInvoke(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg), null, null);
                    }
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LogOff()
        {
            // POS send LogOff command and close channel A
            // FDC send LogOff response and close channel B and C

            try
            {
                Trace.WriteLine("init");

                // create XML ServiceRequest object
                ServiceRequestLogOff logOff = new ServiceRequestLogOff();
                logOff.ApplicationSender = clientSocket.applicationSender;
                logOff.WorkstationID = clientSocket.workstationID;

                ServiceRequestPOSdataLogOff posDataElem = new ServiceRequestPOSdataLogOff();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataLogOff[] posDataArray = { posDataElem };

                logOff.POSdata = posDataArray;

                Trace.WriteLine("EnqueueMessage logOn");
                clientSocket.ifsfMessages.EnqueueMessage(logOff, (EventHandler<AsyncCompletedEventArgs>)null, null, null, true);
                Trace.WriteLine("end");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LogOffResp(string sOverallResult)
        {
            try
            {
                if (sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString())
                {
                    if (clientSocket.mainConnectionState != DeviceConnectionState.Connected || clientSocket.mainConnectionState != DeviceConnectionState.Connecting)
                        clientSocket.mainConnectionState = DeviceConnectionState.Disconnecting;
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void Heartbeat()
        {
            try
            {
                //if (!heartbeat.tryingConnect)
                if (clientSocket.ConnectionState == DeviceConnectionState.Connected) // sometimes tryingConnect messed up
                {
                    ServiceRequestHeartbeat heartbeatmsg = new ServiceRequestHeartbeat();
                    heartbeatmsg.ApplicationSender = this.clientSocket.applicationSender;
                    heartbeatmsg.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSReady srPosready = new ServiceRequestPOSReady();
                    srPosready.ApplicationSender = this.clientSocket.applicationSender;
                    srPosready.WorkstationID = this.clientSocket.workstationID;

                    POSMessagePOSReady msgPOSReady = new POSMessagePOSReady();
                    msgPOSReady.ApplicationSender = this.clientSocket.applicationSender;
                    msgPOSReady.WorkstationID = this.clientSocket.workstationID;
                    Trace.WriteLine(string.Format("new POSReady: type={0},id={1}, counter={2}", msgPOSReady.MessageType, msgPOSReady.MessageID, FDCMessage.requestIDConter));

                    ServiceRequestPOSdataHeartbeat posDataElem = new ServiceRequestPOSdataHeartbeat();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                    ServiceRequestPOSdataHeartbeat[] posDataArray = { posDataElem };

                    heartbeatmsg.POSdata = posDataArray;
                    srPosready.POSdata = posDataArray;
                    msgPOSReady.POSdata = posDataArray;

                    heartbeat.Restart();

                    bool useSRPOSReady = false;
                    if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                        clientSocket.ifsfMessages.EnqueueMessage(heartbeatmsg, (EventHandler<AsyncCompletedEventArgs>)null, null, null, false);
                    else if (useSRPOSReady)
                        clientSocket.ifsfMessages.EnqueueMessage(srPosready, (EventHandler<AsyncCompletedEventArgs>)null, null, null, false);
                    else
                        clientSocket.ifsfMessages.EnqueueMessage(msgPOSReady, (EventHandler<AsyncCompletedEventArgs>)null, null, null, false);
                }
                else
                {
                    //if (!heartbeat.connecting)
                    {
                        //heartbeat.connecting = true;
                        if (this.clientSocket.respChannelBThreadObj != null && !this.clientSocket.respChannelBThreadObj.bRunning)
                        {
                            if (this.clientSocket.ConnectionState == DeviceConnectionState.Connecting)
                            {
                                // we need to disconnect first. Otherwise Connect() will ignore because it's in Connecting state.
                                // It can stuck in Connecting state forever if GetCountrySetting lost (timeout)
                                if (count > 5) // 60 seconds already
                                {
                                    Disconnect();
                                    count = 0;
                                }
                                count++;
                            }
                            else if (this.clientSocket.Connect(""))
                            {
                                //heartbeat.connecting = false;
                                heartbeat.tryingConnect = false;
                                // WJU - restart heartbeat
                                heartbeat.Restart();
                            }
                        }
                        else // either null or running, we need to restart even it's connecting because connecting could have been timed out
                        {
                            //Disconnect running ChannelB thread
                            Disconnect();
                            // WJU - 11/1/12, let next heartbeat handle reconnect
                        }
                        // Restart Timeout timer because NotifyDisconnection disposed it!!!
                        heartbeat.ResetDisconnectionTimeout();

                    }
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void VersionInfo(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestVersionInfo sr = new ServiceRequestVersionInfo();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataVersionInfo posDataElem = new ServiceRequestPOSdataVersionInfo();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataVersionInfo[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void VersionInfoResp(int requestId, string sOverallResult, ServiceResponseVersionInfo sr)
        {
            try
            {
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());

                if (OnVersionInfo != null)
                {
                    OnVersionInfo.BeginInvoke(this, new VersionInfoEventArgs(sr.FDCdata[0].FDCversion, sr.FDCdata[0].FDCrelease, sr.FDCdata[0].FDChotfix), null, null);
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void StartForecourt(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestStartForecourt sr = new ServiceRequestStartForecourt();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataStartForecourt posDataElem = new ServiceRequestPOSdataStartForecourt();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataStartForecourt[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void TwinOpenMaster(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestTwinOpenMaster sr = new ServiceRequestTwinOpenMaster();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataTwinOpenMaster posDataElem = new ServiceRequestPOSdataTwinOpenMaster();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataTwinOpenMaster[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void StartForecourtResp(int requestId, string sOverallResult, string errorCode)
        {
            try
            {
                //QQ-this.clientSocket.mainConnectionState = DeviceConnectionState.Connected;

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void TwinOpenMasterResp(int requestId, string sOverallResult, string errorCode)
        {
            try
            {
                //QQ-this.clientSocket.mainConnectionState = DeviceConnectionState.Connected;

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void StopForecourt(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestStopForecourt sr = new ServiceRequestStopForecourt();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataStopForecourt posDataElem = new ServiceRequestPOSdataStopForecourt();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                posDataElem.EmergencyStop = "false";
                ServiceRequestPOSdataStopForecourt[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void StopForecourtResp(int requestId, string sOverallResult, string errorCode)
        {
            try
            {
                // TODO
                // ....
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }


        public void GetCurrentFuellingStatus(int pumpId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetCurrentFuellingStatus sr = new ServiceRequestGetCurrentFuellingStatus();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetCurrentFuellingStatus posDataElem = new ServiceRequestPOSdataGetCurrentFuellingStatus();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetCurrentFuellingStatus[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetFuelPointTotals(int pumpId, int nozzleId, EventHandler<AsyncCompletedEventArgs<PumpAccumulatorReading>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetFuelPointTotals sr = new ServiceRequestGetFuelPointTotals();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetFuelPointTotals posDataElem = new ServiceRequestPOSdataGetFuelPointTotals();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassGetFuelPointTotals deviceClass = new ServiceRequestDeviceClassGetFuelPointTotals();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.NozzleNo = (nozzleId == -1) ? "*" : Convert.ToString(nozzleId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetFuelPointTotals[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, null);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetCurrentFuellingStatusResp(int requestId, string sOverallResult, ServiceResponseGetCurrentFuellingStatus sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetCurrentFuellingStatusResp"));
                if (OnCurrentFuellingStatus != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("type={0}, id={1}, volume={2}, amount={3}", sr.FDCdata[0].DeviceClass[i].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].CurrentVolume, sr.FDCdata[0].DeviceClass[i].CurrentAmount));
                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        int nozzleId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].CurrentNozzle);
                        Decimal volume = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].CurrentVolume);
                        Decimal amount = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].CurrentAmount);
                        Decimal price = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].CurrentUnitPrice);
                        string authAS = sr.FDCdata[0].DeviceClass[i].AuthorisationApplicationSender;
                        OnCurrentFuellingStatus.BeginInvoke(this, new CurrentFuellingStatusEventArgs(deviceType, deviceId, nozzleId, volume, amount, price, authAS), null, null);
                    }
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetCurrentFuellingStatusResp"));

                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetFuelPointTotalsResp(int requestId, string sOverallResult, ServiceResponseGetFuelPointTotals sr)
        {
            // TODO
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetFuelPointTotalsResp"));
                if (OnFuelPointTotals != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        Trace.WriteLine(string.Format("type={0}, id={1}, volume={2}, amount={3}", sr.FDCdata[0].DeviceClass[i].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].Volume, sr.FDCdata[0].DeviceClass[i].Amount));
                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        int nozzleId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].NozzleNo);
                        Decimal volume = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Volume);
                        Decimal amount = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Amount);
                        Decimal price = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].UnitPrice);
                        OnFuelPointTotals.BeginInvoke(this, new FuelPointTotalsEventArgs(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString(),
                                                                                        deviceType, deviceId, nozzleId, volume, amount, price), null, null);
                    }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetFuelPointTotalsResp"));
                //PumpAccumulatorReading pumpAccumulatorReading = new PumpAccumulatorReading(this.pump, nozzle, 0, PumpAccumulatorReadingType.RequestedReading,
                //                                        FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Volume), FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Amount));
                //clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString(), pumpAccumulatorReading);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetDeviceState(string deviceType, int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                Trace.WriteLine(string.Format("GetDeviceState init: deviceId={0}, deviceType={1}", deviceId, deviceType));
                // create XML ServiceRequest object

                if (deviceType == Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint && !ConfigParam.IsEMSGVersion)
                {
                    ServiceRequestGetFPState sr = new ServiceRequestGetFPState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
                }
                else if (deviceType == Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe || deviceType == Wayne.FDCPOSLibrary.DeviceType.DT_TankLevelGauge)
                {
                    ServiceRequestGetTPState sr = new ServiceRequestGetTPState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
                }
                else if (deviceType == Wayne.FDCPOSLibrary.DeviceType.DT_Vir)
                {
                    ServiceRequestGetVIRState sr = new ServiceRequestGetVIRState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
                }
                else if (deviceType == Wayne.FDCPOSLibrary.DeviceType.DT_PricePole || deviceType == Wayne.FDCPOSLibrary.DeviceType.DT_PricePolePoint)
                {
                    ServiceRequestGetPPState sr = new ServiceRequestGetPPState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
                }
                else
                {
                    ServiceRequestGetDeviceState sr = new ServiceRequestGetDeviceState();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataGetDeviceState posDataElem = new ServiceRequestPOSdataGetDeviceState();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                    deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                    deviceClass.Type = deviceType;

                    posDataElem.DeviceClass = deviceClass;
                    ServiceRequestPOSdataGetDeviceState[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
                }
                Trace.WriteLine(string.Format("GetDeviceState end: deviceId={0}, deviceType={1}", deviceId, deviceType));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetDeviceStateResp(int requestId, string sOverallResult, ServiceResponseGetDeviceState sr)
        {
            try
            {
                if (OnDeviceStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        Trace.WriteLine(string.Format("type={0}, id={1}, state={2}, substate={3}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].LogicalState, sr.FDCdata[0].DeviceClass[i].LogicalSubState));

                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        LogicalDeviceState state = this.convertLogicalDeviceState((sr.FDCdata[0].DeviceClass[i].LogicalState != null && sr.FDCdata[0].DeviceClass[i].LogicalState != "") ? sr.FDCdata[0].DeviceClass[i].LogicalState : sr.FDCdata[0].DeviceClass[i].DeviceState);
                        LogicalDeviceState substate = convertLogicalDeviceState((sr.FDCdata[0].DeviceClass[i].LogicalSubState != null && sr.FDCdata[0].DeviceClass[i].LogicalSubState != "") ? sr.FDCdata[0].DeviceClass[i].LogicalSubState : sr.FDCdata[0].DeviceClass[i].DeviceSubState);
                        int nozzleUp = 0;
                        if (sr.FDCdata[0].DeviceClass[i].Nozzle != null)
                        {
                            foreach (NozzleStateClass nozzleState in sr.FDCdata[0].DeviceClass[i].Nozzle)
                            {
                                if (nozzleState.LogicalNozzle == "NozzleUp")
                                    nozzleUp = Convert.ToInt32(nozzleState.NozzleNo);
                            }
                        }
                        OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, "", nozzleUp));
                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                }
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetFPStateResp(int requestId, string sOverallResult, ServiceResponseGetFPState sr)
        {
            try
            {
                if (OnDeviceStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    if (sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString())
                    {
                        for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                        {
                            Trace.WriteLine(string.Format("type={0}, id={1}, state={2}, substate={3}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].DeviceState, sr.FDCdata[0].DeviceClass[i].DeviceSubState));

                            string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                            int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                            LogicalDeviceState state = this.convertLogicalDeviceState(sr.FDCdata[0].DeviceClass[i].DeviceState);
                            LogicalDeviceState substate = convertLogicalDeviceState(sr.FDCdata[0].DeviceClass[i].DeviceSubState);
                            string lockingAS = sr.FDCdata[0].DeviceClass[i].LockingApplicationSender;
                            int nozzleUp = 0;
                            if (sr.FDCdata[0].DeviceClass[i].Nozzle != null)
                            {
                                foreach (NozzleStateClass nozzleState in sr.FDCdata[0].DeviceClass[i].Nozzle)
                                {
                                    if (nozzleState.LogicalNozzle == "NozzleUp")
                                        nozzleUp = Convert.ToInt32(nozzleState.NozzleNo);
                                }
                            }
                            OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, lockingAS, nozzleUp));
                        }
                    }
                    else
                        Trace.WriteLine(string.Format("overallResult={0}", sOverallResult));
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                }
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetTPStateResp(int requestId, string sOverallResult, ServiceResponseGetTPState sr)
        {
            try
            {
                if (OnDeviceStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        Trace.WriteLine(string.Format("type={0}, id={1}, state={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].DeviceState));

                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        LogicalDeviceState state = this.convertLogicalDeviceState(sr.FDCdata[0].DeviceClass[i].DeviceState);
                        LogicalDeviceState substate = convertLogicalDeviceState(sr.FDCdata[0].DeviceClass[i].DeviceSubState);
                        string lockingAS = sr.FDCdata[0].DeviceClass[i].LockingApplicationSender;
                        OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, lockingAS, 0));
                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                }
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetPPStateResp(int requestId, string sOverallResult, ServiceResponseGetPPState sr)
        {
            try
            {
                if (OnDeviceStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        Trace.WriteLine(string.Format("type={0}, id={1}, state={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].DeviceState));

                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        LogicalDeviceState state = this.convertLogicalDeviceState(sr.FDCdata[0].DeviceClass[i].DeviceState);
                        //OnDeviceStateChange.BeginInvoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, lockingAS, nozzleUp), null, null);
                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                }
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetVIRStateResp(int requestId, string sOverallResult, ServiceResponseGetVIRState sr)
        {
            try
            {
                if (OnVirStateChange != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        DeviceConnectionState deviceState = DeviceConnectionState.Unknown;
                        if (sr.FDCdata[0].DeviceClass[i].Vir != null)
                        {
                            foreach (VIRStateClass virState in sr.FDCdata[0].DeviceClass[i].Vir)
                            {
                                Trace.WriteLine(string.Format("type={0}, id={1}, virId={2}, state={3}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID, virState.VirID, virState.DeviceState));
                                LogicalDeviceState state = this.convertLogicalDeviceState(virState.DeviceState);
                                if (state == LogicalDeviceState.FDC_READY)
                                    deviceState = DeviceConnectionState.Connected;
                                else if (state == LogicalDeviceState.FDC_OFFLINE)
                                    deviceState = DeviceConnectionState.Disconnected;
                                else
                                    deviceState = DeviceConnectionState.Unknown;
                                OnVirStateChange.BeginInvoke(this, new VIRStateChangedEventArgs(deviceId, virState.VirID, deviceState), null, null);
                            }
                        }
                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                }
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void TerminateFuelling(int pumpId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestTerminateFuelling sr = new ServiceRequestTerminateFuelling();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataTerminateFuelling posDataElem = new ServiceRequestPOSdataTerminateFuelling();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataTerminateFuelling[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void TerminateFuellingResp(int requestId, string sOverallResult, ServiceResponseTerminateFuelling sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass[0].ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void AuthoriseFuelPoint(int pumpId, int transactionId, FuellingType fuellingType, byte reservingDeviceId, IAuthorizeParameters authParams, EventHandler<AsyncCompletedEventArgs<long>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestAuthoriseFuelPoint sr = new ServiceRequestAuthoriseFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataAuthoriseFuelPoint posDataElem = new ServiceRequestPOSdataAuthoriseFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassAuthoriseFuelPoint authFP = new ServiceRequestDeviceClassAuthoriseFuelPoint();
                authFP.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                authFP.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                if (authParams.PresetType == PresetType.Amount)
                {
                    authFP.MaxTrxVolume = FDCConvert.ToString((Decimal)0);
                    authFP.MaxTrxAmount = FDCConvert.ToString(authParams.PresetValue);
                }
                else
                {
                    authFP.MaxTrxVolume = FDCConvert.ToString(authParams.PresetValue);
                    authFP.MaxTrxAmount = FDCConvert.ToString((Decimal)0);
                }
                authFP.LockFuelSaleTrx = Convert.ToString(authParams.LockToReleaseClient);
                authFP.ReleaseToken = string.Format("{0:X}", transactionId);
                authFP.ReservingDeviceId = Convert.ToString(reservingDeviceId);
                authFP.FuellingType = Convert.ToString((int)fuellingType);

                //FG, OCT-13-10, Add PayType to show outdoor payment type on FM
                authFP.PayType = Convert.ToString(authParams.PayType);

                //Product[] products = new Product[8];
                //Product product;
                ReleasedProductsClass products = new ReleasedProductsClass();

                AllowedFuelGrades fgs = (AllowedFuelGrades)(authParams.AllowedFuelGrade);
                int count = 0;
                products.Product = new ProductElementClass[fgs.Count];
                for (int iFuelGrade = 0; iFuelGrade < fgs.Count; iFuelGrade++)
                {
                    if (fgs[iFuelGrade])
                    {
                        products.Product[count] = new ProductElementClass();
                        products.Product[count].ProductNo = Convert.ToString(iFuelGrade);
                        //products[count] = product;
                        count++;
                    }
                }
                authFP.ReleasedProducts = products;


                posDataElem.DeviceClass = authFP;
                ServiceRequestPOSdataAuthoriseFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, transactionId);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void AuthoriseFuelPointResp(int requestId, string sOverallResult, ServiceResponseAuthoriseFuelPoint sr)
        {
            try
            {
                if (clientSocket.ifsfMessages.asyncResponseManager.AsyncResponseOperationList.ContainsKey(requestId))
                {
                    AsyncResponseOperation asyncResponseOperation = (AsyncResponseOperation)(clientSocket.ifsfMessages.asyncResponseManager.AsyncResponseOperationList[requestId]);
                    try
                    {
                        asyncResponseOperation.resultLong = Int32.Parse(sr.FDCdata[0].DeviceClass.ReleaseToken, NumberStyles.HexNumber);
                    }
                    catch (Exception ex)
                    {
                        Trace.WriteLine("AuthoriseFuelPointResp Exception! cannot convert ReleaseToken to Int32");
                    }
                }
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }


        public void ChangeFuelMode(int pumpId, int mode, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestChangeFuelMode sr = new ServiceRequestChangeFuelMode();
                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                    sr.RequestType = "ChangeFuelMode";
                else
                    sr.RequestType = "ChangeFPFuelMode";
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataChangeFuelMode posDataElem = new ServiceRequestPOSdataChangeFuelMode();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassChangeFuelMode deviceClass = new ServiceRequestDeviceClassChangeFuelMode();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                deviceClass.FuelMode = new FuelModeElementClass();
                deviceClass.FuelMode.ModeNo = Convert.ToString(mode);

                ServiceRequestDeviceClassChangeFuelMode[] deviceClassArray = { deviceClass };

                posDataElem.DeviceClass = deviceClassArray;
                ServiceRequestPOSdataChangeFuelMode[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ChangeFuelModeAdd(ServiceRequestChangeFuelMode sr, int pumpId, int mode, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            // create XML ServiceRequest object
            sr.ApplicationSender = this.clientSocket.applicationSender;
            sr.WorkstationID = this.clientSocket.workstationID;
            Trace.WriteLine(string.Format("ChangeFuelModeAdd init: sr.ApplicationSender={0}, sr.WorkstationID={1}, pumpId={2}, mode={3}", sr.ApplicationSender, sr.WorkstationID, pumpId, mode));

            ServiceRequestPOSdataChangeFuelMode POSDataElem = null;
            if (sr.POSdata != null)
                POSDataElem = sr.POSdata[0];
            else
            {
                ServiceRequestPOSdataChangeFuelMode[] POSDataArray = null;
                Trace.WriteLine(string.Format("ChangeFuelModeAdd: new ServiceRequestPOSdataChangeFuelMode"));
                POSDataElem = new ServiceRequestPOSdataChangeFuelMode();
                ArrayResize<ServiceRequestPOSdataChangeFuelMode>(ref POSDataArray, (POSDataArray != null) ? POSDataArray.Length + 1 : 1);
                POSDataArray[POSDataArray.Length - 1] = POSDataElem;
                POSDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                sr.POSdata = POSDataArray;
            }

            ServiceRequestDeviceClassChangeFuelMode devicemode = null;
            if (POSDataElem.DeviceClass != null)
            {
                foreach (ServiceRequestDeviceClassChangeFuelMode devicemodeTemp in POSDataElem.DeviceClass)
                    if (devicemodeTemp.DeviceID == Convert.ToString(pumpId) && devicemodeTemp.ModeNo == Convert.ToString(mode))
                    {
                        devicemode = devicemodeTemp;
                        Trace.WriteLine(string.Format("ChangeFuelModeAdd: device/mode found"));
                    }
            }
            if (devicemode == null)
            {
                Trace.WriteLine(string.Format("ChangeFuelModeAdd: new mode"));
                devicemode = new ServiceRequestDeviceClassChangeFuelMode();
                devicemode.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                devicemode.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                devicemode.FuelMode = new FuelModeElementClass();
                devicemode.FuelMode.ModeNo = Convert.ToString(mode);

                ServiceRequestDeviceClassChangeFuelMode[] devicemodeArray = POSDataElem.DeviceClass;
                ArrayResize<ServiceRequestDeviceClassChangeFuelMode>(ref devicemodeArray, (devicemodeArray != null) ? devicemodeArray.Length + 1 : 1);
                Trace.WriteLine(string.Format("ChangeFuelModeAdd: resize devidemodeArray to '{0}' items", devicemodeArray.Length));
                devicemodeArray[devicemodeArray.Length - 1] = devicemode;
                POSDataElem.DeviceClass = devicemodeArray;
            }
            Trace.WriteLine(string.Format("ChangeFuelModeAdd end: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));

        }

        public void ChangeFuelModeSend(ServiceRequestChangeFuelMode sr, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            Trace.WriteLine(string.Format("ChangeFuelModeSend init: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));
            clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            Trace.WriteLine(string.Format("ChangeFuelModeSend end: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));

        }

        public void ChangeFuelModeResp(int requestId, string sOverallResult, ServiceResponseFDCdataChangeFuelMode[] fdcData)
        {
            try
            {
                Trace.WriteLine(string.Format("ChangeFuelModeResp sOverallResult={0}", sOverallResult));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                if (fdcData[0] != null && fdcData[0].DeviceClass != null)
                {
                    for (int i = 0; i < fdcData[0].DeviceClass.Length; i++)
                    {
                        if (fdcData[0].DeviceClass[i].ErrorCode != null && fdcData[0].DeviceClass[i].ErrorCode != ErrorCode.ERRCD_OK.ToString() && fdcData[0].DeviceClass[i].ErrorCode != ErrorCode.ERRCD_NO.ToString())
                        {
                            Trace.WriteLine(string.Format("ChangeFuelModeResp type={0}, id={1}, errorCode={2}", fdcData[0].DeviceClass[i].Type, fdcData[0].DeviceClass[i].DeviceID, fdcData[0].DeviceClass[i].ErrorCode));
                            string deviceType = fdcData[0].DeviceClass[i].Type;
                            int deviceId = Convert.ToInt16(fdcData[0].DeviceClass[i].DeviceID);
                            int alarmId = -1;
                            string alarmmsg = "Error " + fdcData[0].DeviceClass[i].ErrorCode + " changing fuel mode";
                            OnDeviceAlarm.BeginInvoke(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg), null, null);
                        }
                    }
                }
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }


        public void ChangeFuelPrice(int productId, Decimal price, int mode, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestChangeFuelPrice sr = new ServiceRequestChangeFuelPrice();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;


                ServiceRequestPOSdataChangeFuelPrice posDataElem = new ServiceRequestPOSdataChangeFuelPrice();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestProductChangeFuelPrice[] products = new ServiceRequestProductChangeFuelPrice[1];
                ServiceRequestProductChangeFuelPrice product = new ServiceRequestProductChangeFuelPrice();
                product.ProductNo = (productId == -1) ? "*" : Convert.ToString(productId);

                ServiceRequestFuelModeChangeFuelPrice[] fuelModes = new ServiceRequestFuelModeChangeFuelPrice[1];
                ServiceRequestFuelModeChangeFuelPrice fuelMode = new ServiceRequestFuelModeChangeFuelPrice();
                fuelMode.PriceNew = FDCConvert.ToString(price);
                fuelMode.ModeNo = Convert.ToString(mode);
                fuelMode.EffectiveDateTime = "";
                fuelModes[0] = fuelMode;

                product.FuelMode = fuelModes;

                products[0] = product;

                posDataElem.Product = products;

                ServiceRequestPOSdataChangeFuelPrice[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ChangeFuelPriceAdd(ServiceRequestChangeFuelPrice sr, int productId, Decimal price, int mode)
        {
            // create XML ServiceRequest object
            sr.ApplicationSender = this.clientSocket.applicationSender;
            sr.WorkstationID = this.clientSocket.workstationID;
            Trace.WriteLine(string.Format("ChangeFuelPriceAdd init: sr.ApplicationSender={0}, sr.WorkstationID={1}, productId={2}, price={3}, mode={4}", sr.ApplicationSender, sr.WorkstationID, productId, price, mode));

            ServiceRequestPOSdataChangeFuelPrice POSDataElem = null;
            if (sr.POSdata != null)
                POSDataElem = sr.POSdata[0];
            else
            {
                ServiceRequestPOSdataChangeFuelPrice[] POSDataArray = null;
                Trace.WriteLine(string.Format("ChangeFuelPriceAdd: new ServiceRequestPOSdataChangeFuelPrice"));
                POSDataElem = new ServiceRequestPOSdataChangeFuelPrice();
                ArrayResize<ServiceRequestPOSdataChangeFuelPrice>(ref POSDataArray, (POSDataArray != null) ? POSDataArray.Length + 1 : 1);
                POSDataArray[POSDataArray.Length - 1] = POSDataElem;
                POSDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                sr.POSdata = POSDataArray;
            }

            ServiceRequestProductChangeFuelPrice product = null;
            if (POSDataElem.Product != null)
            {
                foreach (ServiceRequestProductChangeFuelPrice productTemp in POSDataElem.Product)
                    if (productTemp.ProductNo == Convert.ToString(productId) && productTemp.ModeNo == Convert.ToString(mode))
                    {
                        product = productTemp;
                        Trace.WriteLine(string.Format("ChangeFuelPriceAdd: product found"));
                    }
            }
            if (product == null && productId > 0)
            {
                Trace.WriteLine(string.Format("ChangeFuelPriceAdd: new product"));
                product = new ServiceRequestProductChangeFuelPrice();
                product.ProductNo = (productId == -1) ? "*" : Convert.ToString(productId);

                ServiceRequestProductChangeFuelPrice[] productArray = POSDataElem.Product;
                ArrayResize<ServiceRequestProductChangeFuelPrice>(ref productArray, (productArray != null) ? productArray.Length + 1 : 1);
                Trace.WriteLine(string.Format("ChangeFuelPriceAdd: resize product to '{0}' items", productArray.Length));
                productArray[productArray.Length - 1] = product;
                POSDataElem.Product = productArray;
            }

            ServiceRequestFuelModeChangeFuelPrice fuelMode = null;
            if (product.FuelMode != null)
            {
                foreach (ServiceRequestFuelModeChangeFuelPrice fuelModeTemp in product.FuelMode)
                    if (product.ProductNo == Convert.ToString(productId) && fuelModeTemp.ModeNo == Convert.ToString(mode))
                    {
                        fuelMode = fuelModeTemp;
                        Trace.WriteLine(string.Format("ChangeFuelPriceAdd: fuelMode found"));
                    }
            }
            if (fuelMode == null && mode > 0)
            {
                fuelMode = new ServiceRequestFuelModeChangeFuelPrice();
                fuelMode.PriceNew = FDCConvert.ToString(price);
                fuelMode.ModeNo = Convert.ToString(mode);
                fuelMode.EffectiveDateTime = "";

                ServiceRequestFuelModeChangeFuelPrice[] fuelModeArray = product.FuelMode;
                ArrayResize<ServiceRequestFuelModeChangeFuelPrice>(ref fuelModeArray, (fuelModeArray != null) ? fuelModeArray.Length + 1 : 1);
                Trace.WriteLine(string.Format("ChangeFuelPriceAdd: resize fuelMode to '{0}' items", fuelModeArray.Length));
                fuelModeArray[fuelModeArray.Length - 1] = fuelMode;
                product.FuelMode = fuelModeArray;
            }
            Trace.WriteLine(string.Format("ChangeFuelPriceAdd end: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));

        }

        public void ChangeFuelPriceSend(ServiceRequestChangeFuelPrice sr, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            Trace.WriteLine(string.Format("ChangeFuelPriceSend init: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));
            clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            Trace.WriteLine(string.Format("ChangeFuelPriceSend end: sr.ApplicationSender={0}, sr.WorkstationID={1}", sr.ApplicationSender, sr.WorkstationID));

        }

        public void ChangeFuelPriceResp(int requestId, string sOverallResult, ServiceResponseFDCdataChangeFuelPrice[] fdcData)
        {
            try
            {

                //Trace.WriteLine(string.Format("product={0}, newprice={1}, oldprice={2}", fdcData[0].Product[0].ProductNo, fdcData[0].Product[0].NewPrice, fdcData[0].Product[0].OldPrice));
                Trace.WriteLine(string.Format("ChangeFuelPriceResp init"));

                string errorCode = (fdcData[0].FDCStatus != null) ? fdcData[0].FDCStatus : fdcData[0].ErrorCode;
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());

                // OnChangeFuelPrice event is sent when FuelPriceChange FDCMessage is coming
                //if (OnChangeFuelPrice != null)
                //{
                //    OnChangeFuelPrice.BeginInvoke(this, new ChangeFuelPriceEventArgs(Convert.ToInt32(fdcData[0].Product[0].ProductNo), Convert.ToInt32(fdcData[0].Product[0].ModeNo),
                //                                                                FDCConvert.ToDecimal(fdcData[0].Product[0].OldPrice), FDCConvert.ToDecimal(fdcData[0].Product[0].NewPrice)), null, null);
                //}
                Trace.WriteLine(string.Format("ChangeFuelPriceResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LockFuelSaleTrx(int pumpId, int transactionNo, int releaseToken, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                ServiceRequestLockFuelSaleTrx sr = new ServiceRequestLockFuelSaleTrx();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataBaseFuelSaleTrx posDataElem = new ServiceRequestPOSdataBaseFuelSaleTrx();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassBaseFuelSaleTrx deviceClass = new ServiceRequestDeviceClassBaseFuelSaleTrx();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.TransactionSeqNo = Convert.ToString(transactionNo);
                deviceClass.ReleaseToken = string.Format("{0:X}", releaseToken);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataBaseFuelSaleTrx[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LockFuelSaleTrxResp(int requestId, string sOverallResult, ServiceResponseLockFuelSaleTrx sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                if (OnLockFuelSaleTrx != null)
                {
                    //string deviceType = sr.FDCdata[0].DeviceClass.Type;
                    //int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass.DeviceID);
                    //int transactionNo = Convert.ToInt16(sr.FDCdata[0].DeviceClass.TransactionSeqNo);
                    //string status = sr.FDCdata[0].FDCStatus;
                    //OnLockFuelSaleTrx.Invoke(this, new FuelSaleTrxEventArgs(deviceType, deviceId, state));
                }
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void UnlockFuelSaleTrx(int pumpId, int transactionNo, int releaseToken, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                ServiceRequestUnlockFuelSaleTrx sr = new ServiceRequestUnlockFuelSaleTrx();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataBaseFuelSaleTrx posDataElem = new ServiceRequestPOSdataBaseFuelSaleTrx();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassBaseFuelSaleTrx deviceClass = new ServiceRequestDeviceClassBaseFuelSaleTrx();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.TransactionSeqNo = Convert.ToString(transactionNo);
                deviceClass.ReleaseToken = string.Format("{0:X}", releaseToken);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataBaseFuelSaleTrx[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void UnlockFuelSaleTrxResp(int requestId, string sOverallResult, ServiceResponseUnlockFuelSaleTrx sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                if (OnUnlockFuelSaleTrx != null)
                {
                    //string deviceType = sr.FDCdata[0].DeviceClass.Type;
                    //int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass.DeviceID);
                    //int transactionNo = Convert.ToInt16(sr.FDCdata[0].DeviceClass.TransactionSeqNo);
                    //string status = sr.FDCdata[0].FDCStatus;
                    //OnUnlockFuelSaleTrx.Invoke(this, new FuelSaleTrxEventArgs(deviceType, deviceId, state));
                }
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ClearFuelSaleTrx(int pumpId, int transactionNo, int releaseToken, string note, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                ServiceRequestClearFuelSaleTrx sr = new ServiceRequestClearFuelSaleTrx();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataClearFuelSaleTrx posDataElem = new ServiceRequestPOSdataClearFuelSaleTrx();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassClearFuelSaleTrx deviceClass = new ServiceRequestDeviceClassClearFuelSaleTrx();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.TransactionSeqNo = Convert.ToString(transactionNo);
                deviceClass.ReleaseToken = string.Format("{0:X}", releaseToken);
                deviceClass.FuelSaleNote = note;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataClearFuelSaleTrx[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ClearFuelSaleTrxResp(int requestId, string sOverallResult, ServiceResponseClearFuelSaleTrx sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                if (OnClearFuelSaleTrx != null)
                {
                    //string deviceType = sr.FDCdata[0].DeviceClass.Type;
                    //int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass.DeviceID);
                    //int transactionNo = Convert.ToInt16(sr.FDCdata[0].DeviceClass.TransactionSeqNo);
                    //string status = sr.FDCdata[0].FDCStatus;
                    //OnClearFuelSaleTrx.Invoke(this, new FuelSaleTrxEventArgs(deviceType, deviceId, state));
                }
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void SendConfig(string commandFileName, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            clientSocket.SendConfig(commandFileName);
        }

        public void GetAvailableFuelSaleTrxs(int pumpId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetAvailableFuelSaleTrxs sr = new ServiceRequestGetAvailableFuelSaleTrxs();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetAvailableFuelSaleTrxs posDataElem = new ServiceRequestPOSdataGetAvailableFuelSaleTrxs();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetAvailableFuelSaleTrxs[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetAvailableFuelSaleTrxsResp(int requestId, string sOverallResult, ServiceResponseGetAvailableFuelSaleTrxs sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetAvailableFuelSaleTrxsResp"));
                if (sr.FDCdata == null || sr.FDCdata[0].DeviceClass == null)
                {
                    Trace.WriteLine(string.Format("no fuel sale available - end"));
                    return;
                }
                if (OnGetAvailableFuelSaleTrx != null && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        //if (sr.FDCdata[0].DeviceClass[i].Transaction == null)
                        //    continue;
                        //for (int j = 0; j < sr.FDCdata[0].DeviceClass[i].Transaction.Length; j++)
                        //{
                        //    Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("type={0}, id={1}, TransactionSeqNo={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, sr.FDCdata[0].DeviceClass[i].Transaction[j].TransactionSeqNo));

                        //    string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                        //    int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        //    int transactionNo = Convert.ToInt32(sr.FDCdata[0].DeviceClass[i].Transaction[j].TransactionSeqNo);
                        //    OnGetAvailableFuelSaleTrx.Invoke(this, new FuelSaleTrxEventArgs(transactionNo, 0, 0, deviceType, deviceId, 0, 0, 0, 0, 0,
                        //        DateTime.Now, DateTime.Now, CRC16.CalculateCRC(deviceId, transactionNo, 0, 0)));
                        //}
                        if (ConfigParam.IsEMSGVersion || (sr.FDCdata[0].DeviceClass[i].ErrorCode != null && sr.FDCdata[0].DeviceClass[i].ErrorCode == ErrorCode.ERRCD_OK.ToString()))
                        {
                            string deviceType = sr.FDCdata[0].DeviceClass[i].Type;
                            int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                            int transactionNo = Convert.ToInt32(sr.FDCdata[0].DeviceClass[i].TransactionSeqNo);
                            int releaseToken;
                            //#if !_USE_OLD_FCONTROL_
                            //                        if (!Strings.TryParseInt(sr.FDCdata[0].DeviceClass[i].ReleaseToken, out releaseToken))
                            //                            releaseToken = 0;
                            //#else
                            try
                            {
                                releaseToken = Int32.Parse(sr.FDCdata[0].DeviceClass[i].ReleaseToken, System.Globalization.NumberStyles.HexNumber);
                            }
                            catch (Exception ex)
                            {
                                releaseToken = 0;
                            }
                            //#endif
                            OnGetAvailableFuelSaleTrx.BeginInvoke(this, new FuelSaleTrxEventArgs(transactionNo, 0, 0, deviceType, deviceId, 0, 0, 0, 0, 0,
                                                                    DateTime.Now, DateTime.Now, "", "", null, null, null, null, releaseToken, 0, FuellingType.Unknown), null, null);
                            int timeout = 0;
                            string sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "GetFuelSaleTrxDetailTimeout");
                            if (sValue.Length > 0)
                                timeout = Convert.ToInt16(sValue);
                            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("GetFuelSaleTrxDetailTimeout={0}", timeout));
                            Thread.Sleep(timeout);
                        }
                        else
                            Trace.WriteLine(string.Format("Id={0} - Error={1}", sr.FDCdata[0].DeviceClass[i].DeviceID, sr.FDCdata[0].DeviceClass[i].ErrorCode));
                    }
                }
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetAvailableFuelSaleTrxsResp"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetFuelSaleTrxDetails(int pumpId, int transactionNo, int releaseToken, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            // create XML ServiceRequest object
            try
            {
                ServiceRequestGetFuelSaleTrxDetails sr = new ServiceRequestGetFuelSaleTrxDetails();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetFuelSaleTrxDetails posDataElem = new ServiceRequestPOSdataGetFuelSaleTrxDetails();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassGetFuelSaleTrxDetails deviceClass = new ServiceRequestDeviceClassGetFuelSaleTrxDetails();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.TransactionSeqNo = (transactionNo == -1) ? "*" : Convert.ToString(transactionNo);
                deviceClass.ReleaseToken = string.Format("{0:X}", releaseToken);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetFuelSaleTrxDetails[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetFuelSaleTrxDetailsResp(int requestId, string sOverallResult, ServiceResponseGetFuelSaleTrxDetails sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetFuelSaleTrxDetailsResp"));
                if (sr.FDCdata == null || sr.FDCdata[0].DeviceClass == null)
                {
                    Trace.WriteLine(string.Format("no fuel sale details - end"));
                    return;
                }
                if ((OnGetFuelSaleTrxDetails != null || OnFuelSaleTrx != null) && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("type={0}, id={1}, nozzle={2}, amount={3}, vol={4}",
                                            sr.FDCdata[0].DeviceClass[i].Type, sr.FDCdata[0].DeviceClass[i].DeviceID,
                                            sr.FDCdata[0].DeviceClass[i].NozzleNo, sr.FDCdata[0].DeviceClass[i].Amount, sr.FDCdata[0].DeviceClass[i].Volume));

                        string deviceType = sr.FDCdata[0].DeviceClass[0].Type;
                        int transactionSeqNum = Convert.ToInt32(sr.FDCdata[0].DeviceClass[i].TransactionSeqNo);
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        Wayne.FDCPOSLibrary.FuellingState transactionState = convertFuellingState(sr.FDCdata[0].DeviceClass[i].State);
                        int completionReason = 0;
                        int nozzleId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].NozzleNo);
                        decimal volume = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Volume);
                        decimal amount = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Amount);
                        decimal price = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].UnitPrice);
                        int fuelMode = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].FuelMode.ModeNo);
                        DateTime trxStartDateTime = Convert.ToDateTime(sr.FDCdata[0].DeviceClass[i].StartTimeStamp);
                        DateTime trxEndDateTime = Convert.ToDateTime(sr.FDCdata[0].DeviceClass[i].EndTimeStamp);
                        string lockingAS = sr.FDCdata[0].DeviceClass[i].LockingApplicationSender;
                        string authAS = sr.FDCdata[0].DeviceClass[i].AuthorisationApplicationSender;
                        string DSPFields = sr.FDCdata[0].DeviceClass[i].DSPFields;
                        string CRCMode = sr.FDCdata[0].DeviceClass[i].CRCMode;
                        string MIDLinesNarrow = sr.FDCdata[0].DeviceClass[i].MIDLinesNarrow;
                        string MIDLinesWide = sr.FDCdata[0].DeviceClass[i].MIDLinesWide;
                        //string DSPFields = System.Text.UTF8Encoding.UTF8.GetString(sr.FDCdata[0].DeviceClass[i].DSPFieldsByte, 0, sr.FDCdata[0].DeviceClass[i].DSPFieldsByte.GetLength(0));
                        //string CRCMode = System.Text.UTF8Encoding.UTF8.GetString(sr.FDCdata[0].DeviceClass[i].CRCModeByte, 0, sr.FDCdata[0].DeviceClass[i].CRCModeByte.GetLength(0));

                        FuellingType fuellingType = (sr.FDCdata[0].DeviceClass[i].FuellingType == "") ? FuellingType.Unknown : ((FuellingType)Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].FuellingType));

                        int releaseToken;
                        //#if !_USE_OLD_FCONTROL_
                        //                        if (!Strings.TryParseInt(sr.FDCdata[0].DeviceClass[i].ReleaseToken, out releaseToken))
                        //                            releaseToken = 0;
                        //#else
                        try
                        {
                            releaseToken = Int32.Parse(sr.FDCdata[0].DeviceClass[i].ReleaseToken, NumberStyles.HexNumber);
                        }
                        catch (Exception ex)
                        {
                            releaseToken = 0;
                        }
                        //#endif

                        byte reservingDeviceId;
                        //#if !_SINP
                        //                        if (!Strings.TryParseByte(sr.FDCdata[0].DeviceClass[i].ReservingDeviceId, out reservingDeviceId))
                        //                            reservingDeviceId = 0;
                        //#else
                        try
                        {
                            reservingDeviceId = Convert.ToByte(sr.FDCdata[0].DeviceClass[i].ReservingDeviceId);
                        }
                        catch (Exception ex)
                        {
                            reservingDeviceId = 0;
                        }
                        //#endif
                        if (OnGetFuelSaleTrxDetails != null)
                        {
                            OnGetFuelSaleTrxDetails.BeginInvoke(this, new FuelSaleTrxEventArgs(transactionSeqNum, transactionState, completionReason, deviceType, deviceId, nozzleId, volume, amount, price, fuelMode, trxStartDateTime, trxEndDateTime, lockingAS, authAS, DSPFields, CRCMode, MIDLinesNarrow, MIDLinesWide, releaseToken, reservingDeviceId, fuellingType), null, null);
                        }
                        if (OnFuelSaleTrx != null)
                        {
                            OnFuelSaleTrx.BeginInvoke(this, new FuelSaleTrxEventArgs(transactionSeqNum, transactionState, completionReason, deviceType, deviceId, nozzleId, volume, amount, price, fuelMode, trxStartDateTime, trxEndDateTime, lockingAS, authAS, DSPFields, CRCMode, MIDLinesNarrow, MIDLinesWide, releaseToken, reservingDeviceId, fuellingType), null, null);
                        }
                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetFuelSaleTrxDetailsResp"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetFuelSaleTrxDetailsResp(int requestId, string sOverallResult, ServiceResponseGetFuelSaleTrxDetailsV03 sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetFuelSaleTrxDetailsRespV03"));
                if (sr.FDCdata == null || sr.FDCdata[0].DeviceClass == null)
                {
                    Trace.WriteLine(string.Format("no fuel sale details - end"));
                    return;
                }
                if ((OnGetFuelSaleTrxDetails != null || OnFuelSaleTrx != null) && sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                {
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("type={0}, id={1}, nozzle={2}, amount={3}, vol={4}",
                                            sr.FDCdata[0].DeviceClass[i].Type, sr.FDCdata[0].DeviceClass[i].DeviceID,
                                            sr.FDCdata[0].DeviceClass[i].NozzleNo, sr.FDCdata[0].DeviceClass[i].Amount, sr.FDCdata[0].DeviceClass[i].Volume));

                        string deviceType = sr.FDCdata[0].DeviceClass[0].Type;
                        int transactionSeqNum = Convert.ToInt32(sr.FDCdata[0].DeviceClass[i].TransactionNo);
                        int deviceId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].DeviceID);
                        Wayne.FDCPOSLibrary.FuellingState transactionState = convertFuellingState(sr.FDCdata[0].DeviceClass[i].State);
                        int completionReason = 0;
                        int nozzleId = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].NozzleNo);
                        decimal volume = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Volume);
                        decimal amount = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].Amount);
                        decimal price = FDCConvert.ToDecimal(sr.FDCdata[0].DeviceClass[i].UnitPrice);
                        int fuelMode = Convert.ToInt16(sr.FDCdata[0].DeviceClass[i].FuelMode);
                        DateTime trxStartDateTime = Convert.ToDateTime(sr.FDCdata[0].DeviceClass[i].StartTimeStamp);
                        DateTime trxEndDateTime = Convert.ToDateTime(sr.FDCdata[0].DeviceClass[i].EndTimeStamp);
                        string lockingAS = "";
                        string authAS = "";
                        string DSPFields = sr.FDCdata[0].DeviceClass[i].DSPFields;
                        string CRCMode = sr.FDCdata[0].DeviceClass[i].CRCMode;
                        string MIDLinesNarrow = "";
                        string MIDLinesWide = "";
                        //string DSPFields = System.Text.UTF8Encoding.UTF8.GetString(sr.FDCdata[0].DeviceClass[i].DSPFieldsByte, 0, sr.FDCdata[0].DeviceClass[i].DSPFieldsByte.GetLength(0));
                        //string CRCMode = System.Text.UTF8Encoding.UTF8.GetString(sr.FDCdata[0].DeviceClass[i].CRCModeByte, 0, sr.FDCdata[0].DeviceClass[i].CRCModeByte.GetLength(0));

                        if (OnGetFuelSaleTrxDetails != null)
                            OnGetFuelSaleTrxDetails.BeginInvoke(this, new FuelSaleTrxEventArgs(transactionSeqNum, transactionState, completionReason, deviceType, deviceId, nozzleId, volume, amount, price, fuelMode, trxStartDateTime, trxEndDateTime, lockingAS, authAS, DSPFields, CRCMode, MIDLinesNarrow, MIDLinesWide, Int32.Parse(sr.FDCdata[0].DeviceClass[i].ReleaseToken, NumberStyles.HexNumber), 0, FuellingType.Unknown), null, null);
                        if (OnFuelSaleTrx != null)
                            OnFuelSaleTrx.BeginInvoke(this, new FuelSaleTrxEventArgs(transactionSeqNum, transactionState, completionReason, deviceType, deviceId, nozzleId, volume, amount, price, fuelMode, trxStartDateTime, trxEndDateTime, lockingAS, authAS, DSPFields, CRCMode, MIDLinesNarrow, MIDLinesWide, Int32.Parse(sr.FDCdata[0].DeviceClass[i].ReleaseToken, NumberStyles.HexNumber), 0, FuellingType.Unknown), null, null);

                    }
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetFuelSaleTrxDetailsResp"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }


        public void GetProductTable(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetProductTable sr = new ServiceRequestGetProductTable();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetProductTable posDataElem = new ServiceRequestPOSdataGetProductTable();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetProductTable[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetProductTableResp(int requestId, string sOverallResult, ServiceResponseGetProductTable sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetProductTableResp"));
                //load products
                if (OnGetProductTable != null)
                {
                    Trace.WriteLineIf(Trace.CheckTraceLevel(3), "Call OnGetProductTable");
                    OnGetProductTable.Invoke(this, new GetProductTableEventArgs(sr));
                }
                //manage getConfigurationData
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), "Call AsyncResponseManager");
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetProductTableResp"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetConfiguration_Result(object src, Wayne.Lib.AsyncCompletedEventArgs completed)
        {
            try
            {
                Trace.WriteLine("init");
                GetConfigurationRespEventArgs gcr = (GetConfigurationRespEventArgs)completed.UserToken;
                if (OnGetConfiguration != null)
                {
                    Trace.WriteLine("call OnGetConfiguration");
                    OnGetConfiguration.Invoke(this, new GetConfigurationEventArgs(gcr.sr));
                }
                if (gcr.getConfigurationRequestCompleted != null)
                {
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(gcr.requestId, gcr.result);
                }
                Trace.WriteLine("end");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetDSPConfiguration_Result(object src, Wayne.Lib.AsyncCompletedEventArgs completed)
        {
            //    delegGetConfiguration_Result mydelegGetConfiguration_Result = new delegGetConfiguration_Result(this.deleg_method_GetConfiguration_Result);
            //    mydelegGetConfiguration_Result.BeginInvoke(src, completed, null, null);
            //}
            //void deleg_method_GetConfiguration_Result(object src, Wayne.Lib.AsyncCompletedEventArgs completed)
            //{
            try
            {
                Trace.WriteLine("init");
                GetConfigurationRespEventArgs gcr = (GetConfigurationRespEventArgs)completed.UserToken;
                if (OnGetConfiguration != null)
                {
                    Trace.WriteLine("call OnGetConfiguration");
                    OnGetConfiguration.Invoke(this, new GetConfigurationEventArgs(gcr.sr));
                }
                if (gcr.getConfigurationRequestCompleted != null)
                {
                    clientSocket.ifsfMessages.asyncResponseManager.SendResponse(gcr.requestId, gcr.result);
                }
                Trace.WriteLine("end");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }
        //public void GetConfigurationProductTableResp

        public void GetModeTable(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetModeTable sr = new ServiceRequestGetModeTable();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetModeTable posDataElem = new ServiceRequestPOSdataGetModeTable();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetModeTable[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetModeTableResp(int requestId, string sOverallResult, ServiceResponseGetModeTable sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetModeTableResp"));
                /*            if (sr.FDCdata == null || sr.FDCdata[0].ModeProduct == null )
                            {
                                Trace.WriteLine(string.Format("no fuel product available - end"));
                                return;
                            }
                            for (int i = 0; i < sr.FDCdata[0].ModeProduct.Length; i++)
                            {
                                string ModeNo = sr.FDCdata[0].ModeProduct[i].ModeNo;
                                string ModeName = sr.FDCdata[0].ModeProduct[i].ModeName;
                                Trace.WriteLine(string.Format("ModeNo={0}, ModeName = {1}", ModeNo, ModeName));
                                if (OnGetModeTable != null)
                                {
                                    OnGetModeTable.Invoke(this, new ModeTableEventArgs(ModeNo,ModeName));
                                }
                            }
                            clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);*/
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetModeTableResp"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetFuelMode(int pumpId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetFuelMode srV07 = new ServiceRequestGetFuelMode();
                ServiceRequestGetFPFuelMode sr = new ServiceRequestGetFPFuelMode();
                srV07.ApplicationSender = this.clientSocket.applicationSender;
                srV07.WorkstationID = this.clientSocket.workstationID;
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetFuelMode posDataElem = new ServiceRequestPOSdataGetFuelMode();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (pumpId == -1) ? "*" : Convert.ToString(pumpId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetFuelMode[] posDataArray = { posDataElem };

                srV07.POSdata = posDataArray;
                sr.POSdata = posDataArray;

                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                    clientSocket.ifsfMessages.EnqueueMessage(srV07, requestCompleted, userToken, src, true);
                else
                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetFuelModeResp(int requestId, string sOverallResult, ServiceResponseFDCdataGetFuelMode[] fdcData)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetFuelModeResp"));
                if (fdcData == null || fdcData[0].DeviceClass == null)
                {
                    Trace.WriteLine(string.Format("no device available - end"));
                    return;
                }
                // TO ADD
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetFuelModeResp"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetConfiguration(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetConfiguration sr = new ServiceRequestGetConfiguration();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetConfiguration posDataElem = new ServiceRequestPOSdataGetConfiguration();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetConfiguration[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }
        public void GetConfigurationResp(int requestId, string sOverallResult, ServiceResponseGetConfiguration sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init GetConfigurationResp: INVALID FOR V7 !"));

                GetConfigurationRespEventArgs gcea = new GetConfigurationRespEventArgs(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString(), sr, null, null);
                if (clientSocket.ifsfMessages.asyncResponseManager.AsyncResponseOperationList.ContainsKey(requestId))
                {
                    AsyncResponseOperation aro = (AsyncResponseOperation)clientSocket.ifsfMessages.asyncResponseManager.AsyncResponseOperationList[requestId];
                    if (aro.requestCompleted != null)
                    {
                        gcea.getConfigurationUserToken = aro.userToken;
                        gcea.getConfigurationRequestCompleted = aro.requestCompleted;
                    }
                }
                this.GetProductTable(new EventHandler<Wayne.Lib.AsyncCompletedEventArgs>(GetConfiguration_Result), gcea, this);
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetConfigurationResp"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetDSPConfiguration(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetDSPConfiguration sr = new ServiceRequestGetDSPConfiguration();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetConfiguration posDataElem = new ServiceRequestPOSdataGetConfiguration();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetConfiguration[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }
        public void GetDSPConfigurationResp(int requestId, string sOverallResult, ServiceResponseGetDSPConfiguration sr)
        {
            try
            {
                Trace.WriteLine("init");
                if (OnGetConfiguration != null)
                {
                    Trace.WriteLine("call OnGetConfiguration");
                    OnGetConfiguration.Invoke(this, new GetConfigurationEventArgs(sr));
                }
                Trace.WriteLine("end");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetTLGConfiguration(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetTLGConfiguration sr = new ServiceRequestGetTLGConfiguration();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetConfiguration posDataElem = new ServiceRequestPOSdataGetConfiguration();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestPOSdataGetConfiguration[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }
        public void GetTLGConfigurationResp(int requestId, string sOverallResult, ServiceResponseGetTLGConfiguration sr)
        {
            try
            {
                if (OnGetConfiguration != null)
                {
                    Trace.WriteLine("call OnGetConfiguration");
                    OnGetConfiguration.Invoke(this, new GetConfigurationEventArgs(sr));
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end GetDSPConfigurationResp"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void SetConfigurationResp(int requestId, string sOverallResult, ServiceResponseSetConfiguration sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init"));

                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LockNozzle(int deviceId, int nozzleNo, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestLockNozzle sr = new ServiceRequestLockNozzle();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataLockNozzle posDataElem = new ServiceRequestPOSdataLockNozzle();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassLockNozzle deviceClass = new ServiceRequestDeviceClassLockNozzle();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.NozzleNo = (nozzleNo == -1) ? "*" : Convert.ToString(nozzleNo);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataLockNozzle[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LockNozzleResp(int requestId, string sOverallResult, ServiceResponseLockNozzle sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, nozzleNo={2}, errorCode={3}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, sr.FDCdata[0].DeviceClass.NozzleNo, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void UnlockNozzle(int deviceId, int nozzleNo, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestUnlockNozzle sr = new ServiceRequestUnlockNozzle();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataUnlockNozzle posDataElem = new ServiceRequestPOSdataUnlockNozzle();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassUnlockNozzle deviceClass = new ServiceRequestDeviceClassUnlockNozzle();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;
                deviceClass.NozzleNo = (nozzleNo == -1) ? "*" : Convert.ToString(nozzleNo);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataUnlockNozzle[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void UnlockNozzleResp(int requestId, string sOverallResult, ServiceResponseUnlockNozzle sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, nozzleNo={2}, errorCode{3}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, sr.FDCdata[0].DeviceClass.NozzleNo, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetCountrySettings(EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetCountrySettings sr = new ServiceRequestGetCountrySettings();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetCountrySettings posDataElem = new ServiceRequestPOSdataGetCountrySettings();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);
                ServiceRequestPOSdataGetCountrySettings[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetCountrySettingsResp(int requestId, string sOverallResult, ServiceResponseGetCountrySettings sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init"));
                if (sr.FDCdata[0].DecimalSign != null)
                    FDCConvert.DecimalSeparator = sr.FDCdata[0].DecimalSign;
                if (sr.FDCdata[0].ThousandDelimiter != null)
                    FDCConvert.ThousandSeparator = sr.FDCdata[0].ThousandDelimiter;
                //clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, true);
                Console.WriteLine("GetCountrySetting Response back, now switch to FC connected");
                this.clientSocket.mainConnectionState = DeviceConnectionState.Connected;
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end: DecimalSeparator={0}, ThousandSeparator={1}, connectionState={2}", FDCConvert.DecimalSeparator, FDCConvert.ThousandSeparator, this.clientSocket.mainConnectionState));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetDSPLimits(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetDSPLimits sr = new ServiceRequestGetDSPLimits();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetDSPLimits posDataElem = new ServiceRequestPOSdataGetDSPLimits();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetDSPLimits[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetDSPLimitsResp(int requestId, string sOverallResult, ServiceResponseGetDSPLimits sr)
        {
            try
            {
                if (sr.FDCdata[0] != null && sr.FDCdata[0].DeviceClass != null)
                    for (int i = 0; i < sr.FDCdata[0].DeviceClass.Length; i++)
                    {
                        Trace.WriteLine(string.Format("type={0}, id={1}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[i].DeviceID));

                    }
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ChangeDSPLimits(int deviceId, int productNo, int modeNo, double maxTrxAmount, double maxTrxVolume, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestChangeDSPLimits sr = new ServiceRequestChangeDSPLimits();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataChangeDSPLimits posDataElem = new ServiceRequestPOSdataChangeDSPLimits();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassChangeDSPLimits deviceClass = new ServiceRequestDeviceClassChangeDSPLimits();
                deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuelDispenser;
                //deviceClass.Product = new ServiceRequestProductDeviceClassChangeDSPLimits();
                //deviceClass.Product.ProductNo = Convert.ToString(productNo);
                //deviceClass.Product.ModeNo = Convert.ToString(modeNo);
                deviceClass.ProductNo = Convert.ToString(productNo);
                deviceClass.ModeNo = Convert.ToString(modeNo);
                System.Globalization.NumberFormatInfo provider = new System.Globalization.NumberFormatInfo();
                provider.NumberDecimalSeparator = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
                provider.NumberGroupSeparator = System.Globalization.NumberFormatInfo.CurrentInfo.NumberGroupSeparator;
                provider.NumberGroupSizes = System.Globalization.NumberFormatInfo.CurrentInfo.NumberGroupSizes;
                //deviceClass.Product.MaxTrxAmount = string.Format(provider, "{0:F2}", maxTrxAmount);
                deviceClass.MaxTrxAmount = string.Format(provider, "{0:F2}", maxTrxAmount);
                provider.NumberDecimalDigits = 3;
                //deviceClass.Product.MaxTrxVolume = string.Format(provider, "{0:F3}", maxTrxVolume);
                deviceClass.MaxTrxVolume = string.Format(provider, "{0:F3}", maxTrxVolume);

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataChangeDSPLimits[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ChangeDSPLimitsResp(int requestId, string sOverallResult, ServiceResponseChangeDSPLimits sr)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init"));
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void SuspendFuelling(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestSuspendFuelling sr = new ServiceRequestSuspendFuelling();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataSuspendFuelling posDataElem = new ServiceRequestPOSdataSuspendFuelling();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataSuspendFuelling[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void SuspendFuellingResp(int requestId, string sOverallResult, ServiceResponseSuspendFuelling sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass[0].ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ResumeFuelling(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestResumeFuelling sr = new ServiceRequestResumeFuelling();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataResumeFuelling posDataElem = new ServiceRequestPOSdataResumeFuelling();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataResumeFuelling[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ResumeFuellingResp(int requestId, string sOverallResult, ServiceResponseResumeFuelling sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass[0].ErrorCode;
                Trace.WriteLine(string.Format("ResumeFuellingResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("ResumeFuellingResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LockTank(int deviceId, int tankNo, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestLockTank sr = new ServiceRequestLockTank();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataLockTank posDataElem = new ServiceRequestPOSdataLockTank();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassLockTank deviceClass = new ServiceRequestDeviceClassLockTank();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.TankNo = Convert.ToString(tankNo);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataLockTank[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("LockTank Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void LockTankResp(int requestId, string sOverallResult, ServiceResponseLockTank sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass[0].ErrorCode;
                Trace.WriteLine(string.Format("LockTankResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("LockTankResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("LockTankResp Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void UnlockTank(int deviceId, int tankNo, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestUnlockTank sr = new ServiceRequestUnlockTank();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataUnlockTank posDataElem = new ServiceRequestPOSdataUnlockTank();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassUnlockTank deviceClass = new ServiceRequestDeviceClassUnlockTank();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.TankNo = Convert.ToString(tankNo);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataUnlockTank[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("UnlockTank Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void UnlockTankResp(int requestId, string sOverallResult, ServiceResponseUnlockTank sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass[0].ErrorCode;
                Trace.WriteLine(string.Format("UnlockTankResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass[0].Type, sr.FDCdata[0].DeviceClass[0].DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("UnlockTankResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("UnlockTankResp Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetTankData(int deviceId, int tankNo, EventHandler<AsyncCompletedEventArgs<ITankReadingEx>> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestGetTankData sr = new ServiceRequestGetTankData();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataGetTankData posDataElem = new ServiceRequestPOSdataGetTankData();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassGetTankData deviceClass = new ServiceRequestDeviceClassGetTankData();
                deviceClass.DeviceID = (deviceId == -1) ? "*" : Convert.ToString(deviceId);
                deviceClass.TankNo = (tankNo == -1) ? "*" : Convert.ToString(tankNo);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_TankProbe;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataGetTankData[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, null);//, (ITankReading)(new FUSIONTankReading()));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("GetTankData Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void GetTankDataResp(int requestId, string sOverallResult, ServiceResponseGetTankData sr)
        {
            try
            {
                // TODO Tank
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("GetTankDataResp init"));
                ServiceResponseDeviceClassGetTankData tankdata = sr.FDCdata[0].DeviceClass[0];
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("GetTankDataResp data received: tank={0}, state={1}, fuelLevel={2}, fuelVolume={3}, waterLevel={4}, waterVolume={5}, temperature={6}",
                                    tankdata.TankNo, tankdata.MeasurementData.TPStatus,
                                    tankdata.MeasurementData.ProductLevel,
                                    tankdata.MeasurementData.TotalObservedVolume,
                                    tankdata.MeasurementData.WaterLevel,
                                    tankdata.MeasurementData.WaterVolume,
                                    tankdata.MeasurementData.AverageTemp));
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("GetTankDataResp: tank={0}, date={1}",
                    tankdata.TankNo, sr.FDCdata[0].FDCTimeStamp));
                DateTime date = DateTime.Now;
                try
                {
                    date = Convert.ToDateTime(sr.FDCdata[0].FDCTimeStamp);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine("GetTankDataResp: Exception! " + ex.Message + " - " + ex.StackTrace);
                    Trace.WriteLine("GetTankDataResp: set datetime to now");
                    date = DateTime.Now;
                }
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass[0].ErrorCode;
                ProbeState probeState = ((errorCode != ErrorCode.ERRCD_OK.ToString()) ||
                                         tankdata.DeviceState != null && convertLogicalDeviceState(tankdata.DeviceState) != LogicalDeviceState.FDC_READY) ? ProbeState.Failed : ProbeState.Ok;
                FUSIONTankReading tankreading = new FUSIONTankReading(Convert.ToInt32(tankdata.TankNo), probeState,
                    date, FDCConvert.ToDecimal(tankdata.MeasurementData.ProductLevel), FDCConvert.ToDecimal(tankdata.MeasurementData.TotalObservedVolume),
                    0, FDCConvert.ToDecimal(tankdata.MeasurementData.WaterLevel), FDCConvert.ToDecimal(tankdata.MeasurementData.WaterVolume), FDCConvert.ToDecimal(tankdata.MeasurementData.AverageTemp),
                    UnitOfMeasure.Liters, UnitOfMeasure.Liters, false);
                //tankdata.Type;
                //Convert.ToInt32(tankdata.ManualMode);
                //FDCConvert.ToDecimal(tankdata.MeasurementData.GrossStandardVolume);
                //FDCConvert.ToDecimal(tankdata.MeasurementData.ObservedDensity)
                //FDCConvert.ToDecimal(tankdata.MeasurementData.TotalObservedVolume);


                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString(), tankreading);

                //foreach (ServiceResponseDeviceClassGetTankData tankdata in sr.FDCdata[0].DeviceClass)
                //{
                //    if (OnTankData != null)
                //    {
                //        OnTankData.Invoke(this, new TankDataEventArgs(Convert.ToInt32(tankdata.DeviceID), Convert.ToInt32(tankdata.TankNo), tankdata.Type, Convert.ToInt32(tankdata.ManualMode),
                //                                                                    FDCConvert.ToDecimal(tankdata.MeasurementData.AverageTemp), FDCConvert.ToDecimal(tankdata.MeasurementData.GrossStandardVolume),
                //                                                                    FDCConvert.ToDecimal(tankdata.MeasurementData.ObservedDensity), FDCConvert.ToDecimal(tankdata.MeasurementData.ProductLevel),
                //                                                                    FDCConvert.ToDecimal(tankdata.MeasurementData.TotalObservedVolume), FDCConvert.ToDecimal(tankdata.MeasurementData.WaterLevel),
                //                                                                    Convert.ToInt32(tankdata.MeasurementData.TPStatus)));
                //    }
                //}
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("GetTankDataResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("GetTankDataResp Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ReserveFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestReserveFuelPoint sr = new ServiceRequestReserveFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataReserveFuelPoint posDataElem = new ServiceRequestPOSdataReserveFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataReserveFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("ReserveFuelPoint Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void ReserveFuelPointResp(int requestId, string sOverallResult, ServiceResponseReserveFuelPoint sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("ReserveFuelPointResp type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("ReserveFuelPointResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("ReserveFuelPointResp Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void FreeFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestFreeFuelPoint sr = new ServiceRequestFreeFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataFreeFuelPoint posDataElem = new ServiceRequestPOSdataFreeFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataFreeFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("FreeFuelPoint Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void StartFuelPointTest(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestStartFuelPointTest sr = new ServiceRequestStartFuelPointTest();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataStartFuelPointTest posDataElem = new ServiceRequestPOSdataStartFuelPointTest();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataStartFuelPointTest[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void EndFuelPointTest(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestEndFuelPointTest sr = new ServiceRequestEndFuelPointTest();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataEndFuelPointTest posDataElem = new ServiceRequestPOSdataEndFuelPointTest();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataEndFuelPointTest[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OpenFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestOpenFuelPoint sr = new ServiceRequestOpenFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOpenFuelPoint posDataElem = new ServiceRequestPOSdataOpenFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataOpenFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OpenDevice(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestOpenDevice sr = new ServiceRequestOpenDevice();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOpenFuelPoint posDataElem = new ServiceRequestPOSdataOpenFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataOpenFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void CloseFuelPoint(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestCloseFuelPoint sr = new ServiceRequestCloseFuelPoint();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataCloseFuelPoint posDataElem = new ServiceRequestPOSdataCloseFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataCloseFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void CloseDevice(int deviceId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestCloseDevice sr = new ServiceRequestCloseDevice();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataCloseFuelPoint posDataElem = new ServiceRequestPOSdataCloseFuelPoint();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClass deviceClass = new ServiceRequestDeviceClass();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = Wayne.FDCPOSLibrary.DeviceType.DT_FuellingPoint;

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataCloseFuelPoint[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void SetDeviceAlarm(string deviceType, int deviceId, int alarmCode, string alarmMsg, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestSetDeviceAlarm sr = new ServiceRequestSetDeviceAlarm();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataSetDeviceAlarm posDataElem = new ServiceRequestPOSdataSetDeviceAlarm();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassSetDeviceAlarm deviceClass = new ServiceRequestDeviceClassSetDeviceAlarm();
                deviceClass.DeviceID = Convert.ToString(deviceId);
                deviceClass.Type = deviceType;


                ServiceRequestDeviceAlarmMsg alarmElem = new ServiceRequestDeviceAlarmMsg();
                alarmElem.Number = Convert.ToString(alarmCode);
                alarmElem.Text = alarmMsg;
                ServiceRequestDeviceAlarmMsg[] alarmMsgArray = { alarmElem };

                posDataElem.DeviceClass = deviceClass;
                ServiceRequestPOSdataSetDeviceAlarm[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void FreeFuelPointResp(int requestId, string sOverallResult, ServiceResponseFreeFuelPoint sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, errorCode={2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void StartFuelPointTestResp(int requestId, string sOverallResult, ServiceResponseStartFuelPointTest sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, errorCode{2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void EndFuelPointTestResp(int requestId, string sOverallResult, ServiceResponseEndFuelPointTest sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass.ErrorCode;
                Trace.WriteLine(string.Format("type={0}, id={1}, errorCode{2}", sr.FDCdata[0].DeviceClass.Type, sr.FDCdata[0].DeviceClass.DeviceID, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OpenFuelPointResp(int requestId, string sOverallResult, ServiceResponseOpenFuelPoint sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus;
                Trace.WriteLine(string.Format("requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void CloseFuelPointResp(int requestId, string sOverallResult, ServiceResponseCloseFuelPoint sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus;
                Trace.WriteLine(string.Format("requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OpenDeviceResp(int requestId, string sOverallResult, ServiceResponseOpenDevice sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass[0].ErrorCode;
                Trace.WriteLine(string.Format("OpenDeviceResp requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("OpenDeviceResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("OpenDeviceResp Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void CloseDeviceResp(int requestId, string sOverallResult, ServiceResponseCloseDevice sr)
        {
            try
            {
                string errorCode = (sr.FDCdata[0].FDCStatus != null) ? sr.FDCdata[0].FDCStatus : sr.FDCdata[0].DeviceClass[0].ErrorCode;
                Trace.WriteLine(string.Format("CloseDeviceResp requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("CloseDeviceResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("CloseDeviceResp Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void SetDeviceAlarmResp(int requestId, string sOverallResult, ServiceResponseSetDeviceAlarm sr)
        {
            try
            {
                string errorCode = sr.FDCdata[0].FDCStatus;
                Trace.WriteLine(string.Format("SetDeviceAlarmResp requestId={0}, errorCode={1}", requestId, errorCode));
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, errorCode == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                Trace.WriteLine(string.Format("SetDeviceAlarmResp end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("SetDeviceAlarmResp Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptAddSerialPort(int optId, string port, int baudRate, int dataBit, int stopBit, int parity, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                Trace.WriteLine(string.Format("OptAddSerialPort init: tp={0}, port={1}", optId, port));
                // create XML ServiceRequest object
                ServiceRequestOPTAdd sr = new ServiceRequestOPTAdd();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOPTAdd posDataElem = new ServiceRequestPOSdataOPTAdd();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassOPTAdd optadd = new ServiceRequestDeviceClassOPTAdd();
                optadd.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                optadd.Type = Wayne.FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal;

                ServiceRequestDeviceClassSerialPortOPTAdd serialPort = new ServiceRequestDeviceClassSerialPortOPTAdd();
                serialPort.Port = port;
                serialPort.BaudRate = Convert.ToString(baudRate);
                serialPort.DataBit = Convert.ToString(dataBit);
                serialPort.StopBit = Convert.ToString(stopBit);
                serialPort.Parity = Convert.ToString(parity);
                optadd.serialPort = serialPort;

                posDataElem.DeviceClass = optadd;
                ServiceRequestPOSdataOPTAdd[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
                Trace.WriteLine(string.Format("OptAddSerialPort end: tp={0}, port={1}", optId, port));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("OptAddSerialPort Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptAddTCP(int optId, string address, int port, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestOPTAdd sr = new ServiceRequestOPTAdd();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOPTAdd posDataElem = new ServiceRequestPOSdataOPTAdd();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassOPTAdd optadd = new ServiceRequestDeviceClassOPTAdd();
                optadd.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                optadd.Type = Wayne.FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal;

                ServiceRequestDeviceClassTCPOPTAdd tcp = new ServiceRequestDeviceClassTCPOPTAdd();
                tcp.Address = address;
                tcp.Port = Convert.ToString(port);
                optadd.tcp = tcp;

                posDataElem.DeviceClass = optadd;
                ServiceRequestPOSdataOPTAdd[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptAddResp(int requestId, string sOverallResult, ServiceResponseOPTAdd sr)
        {
            try
            {
                //clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sr.FDCdata[0].FDCStatus == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptRemove(int optId, EventHandler<AsyncCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                ServiceRequestOPTRemove sr = new ServiceRequestOPTRemove();
                sr.ApplicationSender = this.clientSocket.applicationSender;
                sr.WorkstationID = this.clientSocket.workstationID;

                ServiceRequestPOSdataOPTRemove posDataElem = new ServiceRequestPOSdataOPTRemove();
                posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                ServiceRequestDeviceClassOPTRemove optRemove = new ServiceRequestDeviceClassOPTRemove();
                optRemove.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                optRemove.Type = Wayne.FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal;

                posDataElem.DeviceClass = optRemove;
                ServiceRequestPOSdataOPTRemove[] posDataArray = { posDataElem };

                sr.POSdata = posDataArray;

                clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true);
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptRemoveResp(int requestId, string sOverallResult, ServiceResponseOPTRemove sr)
        {
            try
            {
                //clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sr.FDCdata[0].FDCStatus == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptWrite(int optId, byte[] message, EventHandler<OptWriteCompletedEventArgs> requestCompleted, object userToken, object src)
        {
            try
            {
                // create XML ServiceRequest object
                if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                {
                    ServiceRequestOPTWriteV07 sr = new ServiceRequestOPTWriteV07();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataOPTWriteV07 posDataElem = new ServiceRequestPOSdataOPTWriteV07();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClassOPTWriteV07 optwrite = new ServiceRequestDeviceClassOPTWriteV07();
                    optwrite.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                    optwrite.Type = Wayne.FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal;
                    optwrite.Message = message;

                    posDataElem.DeviceClass = optwrite;
                    ServiceRequestPOSdataOPTWriteV07[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, null);//, new OptWriteCompletedEventArgs(true, userToken, 0));
                }
                else
                {
                    ServiceRequestOPTWrite sr = new ServiceRequestOPTWrite();
                    sr.ApplicationSender = this.clientSocket.applicationSender;
                    sr.WorkstationID = this.clientSocket.workstationID;

                    ServiceRequestPOSdataOPTWrite posDataElem = new ServiceRequestPOSdataOPTWrite();
                    posDataElem.POSTimeStamp = DateTime.Now.ToString(FDCConvert.DateFormat);

                    ServiceRequestDeviceClassOPTWrite optwrite = new ServiceRequestDeviceClassOPTWrite();
                    optwrite.DeviceID = (optId == -1) ? "*" : Convert.ToString(optId);
                    optwrite.Type = Wayne.FDCPOSLibrary.DeviceType.DT_OutdoorPaymentTerminal;
                    optwrite.Message = UTF8Encoding.UTF8.GetString(message, 0, message.GetLength(0)); ;

                    posDataElem.DeviceClass = optwrite;
                    ServiceRequestPOSdataOPTWrite[] posDataArray = { posDataElem };

                    sr.POSdata = posDataArray;

                    clientSocket.ifsfMessages.EnqueueMessage(sr, requestCompleted, userToken, src, true, null);//, new OptWriteCompletedEventArgs(true, userToken, 0));
                }

            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptWriteResp(int requestId, string sOverallResult, ServiceResponseOPTWrite sr)
        {
            try
            {
                //clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sr.FDCdata[0].FDCStatus == ErrorCode.ERRCD_OK.ToString() && sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
                clientSocket.ifsfMessages.asyncResponseManager.SendResponse(requestId, sOverallResult == FDCPOSLibrary.OverallResult.Success.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }










        public void HeartbeatMsg()
        {
            try
            {
                // when the heartbeat is received the disconnection timer is reset (the timer that is activated when the heartbeat is no more received)
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), "Ci sono !");
                heartbeat.ResetDisconnectionTimeout();
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void DeviceStateChangeMsg(FDCMessageDeviceStateChange msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init DeviceStateChangeMsg: type={0}, id={1}, state={2}, substate={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].LogicalState, msg.FDCdata[0].DeviceClass[0].LogicalSubState));
                if (OnDeviceStateChange != null)
                {
                    string deviceType = msg.FDCdata[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                    LogicalDeviceState state = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].LogicalState);
                    LogicalDeviceState substate = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].LogicalSubState);
                    int nozzleUp = 0;
                    if (msg.FDCdata[0].DeviceClass[0].Nozzle != null)
                    {
                        foreach (NozzleStateClass nozzleState in msg.FDCdata[0].DeviceClass[0].Nozzle)
                        {
                            if (nozzleState.LogicalNozzle == "NozzleUp")
                                nozzleUp = Convert.ToInt32(nozzleState.NozzleNo);
                        }
                    }
                    OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, "", nozzleUp));
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end DeviceStateChangeMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void FPStateChangeMsg(FDCMessageFPStateChange msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init FPStateChangeMsg: type={0}, id={1}, state={2}, substate={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].DeviceState, msg.FDCdata[0].DeviceClass[0].DeviceSubState));
                if (OnDeviceStateChange != null)
                {
                    string deviceType = msg.FDCdata[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                    LogicalDeviceState state = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].DeviceState);
                    LogicalDeviceState substate = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].DeviceSubState);
                    string lockingAS = msg.FDCdata[0].DeviceClass[0].LockingApplicationSender;
                    int nozzleUp = 0;
                    if (msg.FDCdata[0].DeviceClass[0].Nozzle != null)
                    {
                        foreach (NozzleStateClass nozzleState in msg.FDCdata[0].DeviceClass[0].Nozzle)
                        {
                            if (nozzleState.LogicalNozzle == "NozzleUp")
                                nozzleUp = Convert.ToInt32(nozzleState.NozzleNo);
                        }
                    }
                    OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, substate, lockingAS, nozzleUp));
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end DeviceStateChangeMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void TPStateChangeMsg(FDCMessageTPStateChange msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init TPStateChangeMsg: type={0}, id={1}, state={2}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].DeviceState));
                if (OnDeviceStateChange != null)
                {
                    string deviceType = msg.FDCdata[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                    LogicalDeviceState state = convertLogicalDeviceState(msg.FDCdata[0].DeviceClass[0].DeviceState);
                    OnDeviceStateChange.Invoke(this, new DeviceStateChangedEventArgs(deviceType, deviceId, state, LogicalDeviceState.FDC_UNDEFINED, "", 0));
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end DeviceStateChangeMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void VIRStateChangeMsg(FDCMessageVIRStateChange msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init VIRStateChangeMsg: type={0}, id={1}, state={2}, substate={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].DeviceState, msg.FDCdata[0].DeviceClass[0].DeviceSubState));
                if (OnVirStateChange != null)
                {
                    string deviceType = msg.FDCdata[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                    LogicalDeviceState state;
                    DeviceConnectionState deviceState = DeviceConnectionState.Unknown;
                    if (msg.FDCdata[0].DeviceClass[0].Vir != null)
                    {
                        foreach (VIRStateClass virState in msg.FDCdata[0].DeviceClass[0].Vir)
                        {
                            state = convertLogicalDeviceState(virState.DeviceState);
                            if (state == LogicalDeviceState.FDC_READY)
                                deviceState = DeviceConnectionState.Connected;
                            else if (state == LogicalDeviceState.FDC_OFFLINE)
                                deviceState = DeviceConnectionState.Disconnected;
                            else
                                deviceState = DeviceConnectionState.Unknown;
                            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init VIRStateChangeMsg: type={0}, id={1}, virID={2}, virstate={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, virState.VirID, virState.DeviceState));
                            OnVirStateChange.BeginInvoke(this, new VIRStateChangedEventArgs(deviceId, virState.VirID, deviceState), null, null);
                        }
                    }
                }
                else
                    Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("OnVirStateChange == null"));
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end VIRStateChangeMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void CalcCallback(IAsyncResult ar)
        {

        }


        public void FDCStoppedMsg(FDCMessageStopped msg)
        {
            try
            {
                Trace.WriteLine(string.Format("init FDCStoppedMsg"));
                this.clientSocket.mainConnectionState = DeviceConnectionState.Connecting;
                Trace.WriteLine(string.Format("end FDCStoppedMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void FDCStartedMsg(FDCMessageStarted msg)
        {
            try
            {
                Trace.WriteLine(string.Format("init FDCStartedMsg"));
                //QQ-
                //this.clientSocket.mainConnectionState = DeviceConnectionState.Connected;
                Trace.WriteLine(string.Format("end FDCStartedMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void TwinMasterReadyMsg(FDCMessageTwinMasterIsOn msg)
        {
            try
            {
                Trace.WriteLine(string.Format("init TwinMasterReadyMsg"));
                if (OnTwinMasterReady != null)
                    OnTwinMasterReady.BeginInvoke(this, null, null, null);
                Trace.WriteLine(string.Format("end TwinMasterReadyMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void CurrentFuellingStatusMsg(FDCMessageCurrentFuellingStatus msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init CurrentFuellingStatusMsg: type={0}, id={1}, volume={2}, amount={3}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID, msg.FDCdata[0].DeviceClass[0].CurrentVolume, msg.FDCdata[0].DeviceClass[0].CurrentAmount));
                if (OnCurrentFuellingStatus != null)
                {
                    string deviceType = msg.FDCdata[0].DeviceClass[0].Type;
                    int deviceId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].DeviceID);
                    int nozzleId = Convert.ToInt16(msg.FDCdata[0].DeviceClass[0].CurrentNozzleNo);
                    Decimal volume = FDCConvert.ToDecimal(msg.FDCdata[0].DeviceClass[0].CurrentVolume);
                    Decimal amount = FDCConvert.ToDecimal(msg.FDCdata[0].DeviceClass[0].CurrentAmount);
                    Decimal price = FDCConvert.ToDecimal(msg.FDCdata[0].DeviceClass[0].CurrentUnitPrice);
                    OnCurrentFuellingStatus.BeginInvoke(this, new CurrentFuellingStatusEventArgs(deviceType, deviceId, nozzleId, volume, amount, price, ""), null, null);
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end CurrentFuellingStatusMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void DeviceAlarmMsg(FDCMessageDeviceAlarm msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init DeviceAlarmMsg: type={0}, id={1}", msg.FDCdata[0].DeviceClass[0].Type, msg.FDCdata[0].DeviceClass[0].DeviceID));
                string deviceType = "";
                int deviceId = 0;
                foreach (FDCMessageDeviceAlarmDeviceClass device in msg.FDCdata[0].DeviceClass)
                {
                    deviceType = device.Type;
                    deviceId = Convert.ToInt16(device.DeviceID);
                    if (device.AlarmMsg != null && device.AlarmMsg.Length > 0)
                    {
                        foreach (FDCMessageDeviceAlarmMsg alarmmsg in device.AlarmMsg)
                        {
                            if (OnDeviceAlarm != null)
                            {
                                int alarmId = Convert.ToInt32(alarmmsg.Number);
                                OnDeviceAlarm.BeginInvoke(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg.Text), null, null);
                            }
                        }
                    }
                    else //if (deviceType == "TP") // send empty message for Tank Probe
                    {
                        if (OnDeviceAlarm != null)
                        {
                            OnDeviceAlarm.BeginInvoke(this, new DeviceAlarmEventArgs(deviceType, deviceId, 0, ""), null, null);
                        }
                    }
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end DeviceAlarmMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void FuelSaleTrxMsg(FDCMessageFuelSaleTrx msg)
        {
            try
            {
                Trace.WriteLine(string.Format("FuelSaleTrxMsg init"));
                //foreach (FDCMessageDeviceClassFuelSaleTrx deviceClass in msg.FDCdata[0].DeviceClass)

                if (msg != null && msg.FDCdata != null && msg.FDCdata[0] != null && msg.FDCdata[0].DeviceClass != null)
                {
                    FDCMessageDeviceClassFuelSaleTrx deviceClass = msg.FDCdata[0].DeviceClass;
                    if (OnFuelSaleTrx != null)
                    {
                        string deviceType = deviceClass.Type;
                        Trace.WriteLine(string.Format("FuelSaleTrxMsg type={0}, id={1}", deviceClass.Type, deviceClass.DeviceID));
                        Trace.WriteLine(string.Format("FuelSaleTrxMsg nozzle={0}, price={1}, vol={2}, amount={3}", deviceClass.NozzleNo, deviceClass.UnitPrice, deviceClass.Volume, deviceClass.Amount));
                        Trace.WriteLine(string.Format("FuelSaleTrxMsg authAS={0}, lockAS={1}", deviceClass.AuthorisationApplicationSender, deviceClass.LockingApplicationSender));
                        int deviceId = Convert.ToInt16(deviceClass.DeviceID);
                        int nozzleId = Convert.ToInt16(deviceClass.NozzleNo);
                        Decimal volume = FDCConvert.ToDecimal(deviceClass.Volume);
                        Decimal amount = FDCConvert.ToDecimal(deviceClass.Amount);
                        Decimal price = FDCConvert.ToDecimal(deviceClass.UnitPrice);
                        int transactionSeqNum = Convert.ToInt32(deviceClass.TransactionSeqNo);
                        Wayne.FDCPOSLibrary.FuellingState transactionState = convertFuellingState(deviceClass.State);
                        int completionReason = Convert.ToInt32(deviceClass.CompletionReason);
                        int fuelMode = (deviceClass.FuelMode != null && deviceClass.FuelMode.ModeNo != null && deviceClass.FuelMode.ModeNo != "") ? Convert.ToInt32(deviceClass.FuelMode.ModeNo) : 0;
                        DateTime trxStartDateTime = Convert.ToDateTime(deviceClass.StartTimeStamp);
                        DateTime trxEndDateTime = Convert.ToDateTime(deviceClass.EndTimeStamp);
                        string authAS = deviceClass.AuthorisationApplicationSender;
                        string lockingAS = deviceClass.LockingApplicationSender;
                        string DSPFields = deviceClass.DSPFields;
                        string CRCMode = deviceClass.CRCMode;
                        string MIDLinesNarrow = deviceClass.MIDLinesNarrow;
                        string MIDLinesWide = deviceClass.MIDLinesWide;
                        //string DSPFields = System.Text.UTF8Encoding.UTF8.GetString(deviceClass.DSPFieldsByte, 0, deviceClass.DSPFieldsByte.GetLength(0));
                        //string CRCMode = System.Text.UTF8Encoding.UTF8.GetString(deviceClass.CRCModeByte, 0, deviceClass.CRCModeByte.GetLength(0));
                        int releaseToken = 0;
                        //#if !_USE_OLD_FCONTROL_
                        //                        if (!Strings.TryParseInt(deviceClass.ReleaseToken, out releaseToken))
                        //                            releaseToken = 0;
                        //#else
                        try
                        {
                            releaseToken = Int32.Parse(deviceClass.ReleaseToken, NumberStyles.HexNumber);
                        }
                        catch (Exception ex)
                        {
                            releaseToken = 0;
                        }
                        //#endif

                        byte reservingDeviceId = 0;
                        try
                        {
                            reservingDeviceId = Convert.ToByte(deviceClass.ReservingDeviceId);
                        }
                        catch (Exception ex)
                        {
                            Trace.WriteLine("FuelSaleTrxMsg Exception! cannot convert ReleaseToken to Int32");
                        }
                        OnFuelSaleTrx.BeginInvoke(this, new FuelSaleTrxEventArgs(transactionSeqNum, transactionState, completionReason, deviceType, deviceId, nozzleId, volume, amount, price, fuelMode, trxStartDateTime, trxEndDateTime, lockingAS, authAS, DSPFields, CRCMode, MIDLinesNarrow, MIDLinesWide, releaseToken, reservingDeviceId, (FuellingType)(Convert.ToInt16(deviceClass.FuellingType))), null, null);
                    }
                    else
                        Trace.WriteLine("FuelSaleTrxMsg OnFuelSaleTrx == null");
                }
                else
                {
                    if (msg == null)
                        Trace.WriteLine("FuelSaleTrxMsg msg == null");
                    else if (msg.FDCdata == null)
                        Trace.WriteLine("FuelSaleTrxMsg msg.FDCdata == null");
                    else if (msg.FDCdata[0] == null)
                        Trace.WriteLine("FuelSaleTrxMsg msg.FDCdata[0] == null");
                    else if (msg.FDCdata[0].DeviceClass == null)
                        Trace.WriteLine("FuelSaleTrxMsg msg.FDCdata[0].DeviceClass == null");
                }
                //foreach (FDCMessageTRXdataFuelSaleTrx trxdata in msg.FDCdata[0].TRXdata)
                //{
                //    if (OnFuelSaleTrx != null)
                //    {
                //        string deviceType = trxdata.DeviceClass.Type;
                //        Trace.WriteLine(string.Format("type={0}, id={1}, nozzle={2}, price={3}, vol={4}, amount={5}", trxdata.DeviceClass.Type, trxdata.DeviceClass.DeviceID, trxdata.DeviceClass.NozzleNo, trxdata.UnitPrice, trxdata.Volume, trxdata.Amount));
                //        int deviceId = Convert.ToInt16(trxdata.DeviceClass.DeviceID);
                //        int nozzleId = Convert.ToInt16(trxdata.DeviceClass.NozzleNo);
                //        Decimal volume = FDCConvert.ToDecimal(trxdata.Volume);
                //        Decimal amount = FDCConvert.ToDecimal(trxdata.Amount);
                //        Decimal price = FDCConvert.ToDecimal(trxdata.UnitPrice);
                //        int transactionSeqNum = Convert.ToInt32(trxdata.TransactionSeqNo);
                //        Wayne.FDCPOSLibrary.FuellingState transactionState = convertFuellingState(trxdata.State);
                //        int completionReason = Convert.ToInt32(trxdata.CompletionReason);
                //        int fuelMode = Convert.ToInt32(trxdata.FuelMode);
                //        DateTime trxStartDateTime = Convert.ToDateTime(trxdata.StartTimeStamp);
                //        DateTime trxEndDateTime = Convert.ToDateTime(trxdata.EndTimeStamp);
                //        string sCRC = (trxdata.DSPFields.LastIndexOf(' ') >= 0) ? trxdata.DSPFields.Substring(trxdata.DSPFields.LastIndexOf(' ')) : "";
                //        ushort CRC = 0;
                //        try
                //        {
                //            CRC = Convert.ToUInt16(sCRC);
                //        }
                //        catch (Exception ex)
                //        {

                //        }
                //        OnFuelSaleTrx.Invoke(this, new FuelSaleTrxEventArgs(transactionSeqNum, transactionState, completionReason, deviceType, deviceId, nozzleId, volume, amount, price, fuelMode, trxStartDateTime, trxEndDateTime, CRC));
                //    }
                //}
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("FuelSaleTrxMsg end"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void FuelPriceChangeMsg(FDCMessageFuelPriceChange msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init FuelPriceChangeMsg"));
                Trace.WriteLine(string.Format("product={0}, newprice={1}, oldprice={2}", msg.FDCdata[0].Product[0].ProductNo, msg.FDCdata[0].Product[0].NewPrice, msg.FDCdata[0].Product[0].OldPrice));
                if (OnChangeFuelPrice != null)
                {
                    OnChangeFuelPrice.BeginInvoke(this, new ChangeFuelPriceEventArgs(Convert.ToInt32(msg.FDCdata[0].Product[0].ProductNo), Convert.ToInt32(msg.FDCdata[0].Product[0].ModeNo),
                                                                                FDCConvert.ToDecimal(msg.FDCdata[0].Product[0].OldPrice), FDCConvert.ToDecimal(msg.FDCdata[0].Product[0].NewPrice)), null, null);
                }
                //foreach (FDCMessageProductFuelPriceChange product in msg.FDCdata[0].Product)
                //{
                //    if (OnDeviceAlarm != null)
                //    {
                //        string deviceType = "";
                //        int deviceId = 0;
                //        int alarmId = Convert.ToInt32(1409); //MC_INFO_PUMPPRICECHANGED		1409
                //        string alarmmsg = string.Format("prezzo prodotto '{0}'", product.ProductNo);
                //        OnDeviceAlarm.Invoke(this, new DeviceAlarmEventArgs(deviceType, deviceId, alarmId, alarmmsg));
                //    }
                //}
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end FuelPriceChangeMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }
        public void FuelModeChangeMsg(FDCMessageFDCdataFuelModeChange fdcData)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init FuelModeChangeMsg"));
                foreach (FDCMessageDeviceClassFuelModeChange device in fdcData.DeviceClass)
                {
                    if (OnFuelModeChange != null)
                    {
                        string deviceType = fdcData.DeviceClass[0].Type;
                        int deviceId = Convert.ToInt16(fdcData.DeviceClass[0].DeviceID);
                        int mode = 0;
                        if (fdcData.DeviceClass[0].FuelMode.ModeNo != null)
                            mode = Convert.ToInt16(fdcData.DeviceClass[0].FuelMode.ModeNo);
                        else
                            mode = Convert.ToInt16(fdcData.DeviceClass[0].ModeNo);
                        OnFuelModeChange.BeginInvoke(this, new FuelModeChangedEventArgs(deviceType, deviceId, mode), null, null);
                    }
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end FuelModeChangeMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }
        public void FDCExceptionMsg(FDCMessageFDCExceptionMsg msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init FDCExceptionMsg"));
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end FDCExceptionMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void FDCMessageConfigurationChangeMsg(FDCMessageConfigurationChange msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("init FDCMessageConfigurationChangeMsg"));
                OnConfigurationChange.Invoke(this, null);
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("end FDCMessageConfigurationChangeMsg"));
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptReadMsg(FDCMessageOPTRead msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), "init OptReadMsg");
                foreach (FDCMessageDeviceClassOPTRead optdata in msg.FDCdata[0].DeviceClass)
                {
                    if (OnOptRead != null)
                    {
                        string deviceType = optdata.Type;
                        byte[] databytes = ASCIIEncoding.ASCII.GetBytes(optdata.Message); ;
                        Trace.WriteLine(string.Format("type={0}, id={1}, msg={2}", optdata.Type, optdata.DeviceID, optdata.Message));
                        int deviceId = Convert.ToInt16(optdata.DeviceID);
                        OnOptRead.BeginInvoke(this, new OptReadEventArgs(deviceType, deviceId, databytes), null, null);
                    }
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), "end OptReadMsg");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        public void OptReadMsg(FDCMessageOPTReadV07 msg)
        {
            try
            {
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), "init OptReadMsg");
                foreach (FDCMessageDeviceClassOPTReadV07 optdata in msg.FDCdata[0].DeviceClass)
                {
                    if (OnOptRead != null)
                    {
                        string deviceType = optdata.Type;
                        System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
                        Trace.WriteLine(string.Format("type={0}, id={1}, msg={2}", optdata.Type, optdata.DeviceID, encoding.GetString(optdata.Message, 0, optdata.Message.Length)));
                        int deviceId = Convert.ToInt16(optdata.DeviceID);
                        byte[] message = optdata.Message;
                        OnOptRead.BeginInvoke(this, new OptReadEventArgs(deviceType, deviceId, message), null, null);
                    }
                }
                Trace.WriteLineIf(Trace.CheckTraceLevel(3), "end OptReadMsg");
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }
    }
}