//-----------------------------------------------------------------------
// <copyright file="VectorPassthru.cs" company="bedug.com">
//     Copyright © 2012 Nils Hammar. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
/*
 * Software to access vehicle information via the OBD-II connector.
 * 
 * Copyright © 2012 Nils Hammar
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Alternative licensing is possible, see the licensing document.
 * 
 * The above text may not be removed or modified.
 */

namespace DeviceApi.J2534
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using global::SharedObjects;
    using global::SharedObjects.Api;
    using global::SharedObjects.CAN;
    using global::SharedObjects.CAN.Objects;
    using global::SharedObjects.DataMgmt;
    using global::SharedObjects.Protocol;
    using global::VectorComm;

    /// <summary>
    /// TODO: Update summary.
    /// </summary>
    public class VectorPassthru : IPassThru, IPresentationLayer, IDisposable
    {
        /// <summary>
        /// Supported connection flags by the device.
        /// </summary>
        private static CanFlags[] connFlags = new CanFlags[]
        {
            new CanFlags(PassThruConstants.connflags.SNIFF_MODE, "SNIFF_MODE", true),
            new CanFlags(PassThruConstants.connflags.CAN_ID_BOTH, "CAN_ID_BOTH", true),
            new CanFlags(PassThruConstants.connflags.CAN_29BIT_ID, "CAN_29BIT_ID", false),
        };

        /// <summary>
        /// Supported filter flags by the device.
        /// </summary>
        private static CanFlags[] messageFlags = new CanFlags[]
        {
            new CanFlags(PassThruConstants.txflags.CAN_29BIT_ID, "CAN_29BIT_ID", false),
            new CanFlags(PassThruConstants.txflags.ISO15765_ADDR_TYPE, "ISO15765_ADDR_TYPE", false),
            new CanFlags(PassThruConstants.txflags.ISO15765_FRAME_PAD, "ISO15765_FRAME_PAD", true),
        };

        /// <summary>
        /// Gets the name of the interface.
        /// </summary>
        public string name
        {
            get
            {
                return "Vector CAN Passthru emulation";
            }
        }

        /// <summary>
        /// Gets the code name of the interface.
        /// <para>
        /// For dynamic interfaces this is the same as the DLL filename without extension.
        /// </para>
        /// </summary>
        public string code
        {
            get
            {
                return "CANEmul";
            }
        }

        /// <summary>
        /// To return an unique device ID for each opening of the device.
        /// </summary>
        private int DeviceIdCounter = 1;

        /// <summary>
        /// To return an unique connection ID for each opening of the device.
        /// </summary>
        private int ChannelIdCounter = 1;

        /// <summary>
        /// To return an unique filter ID for each opening of the device.
        /// </summary>
        private int FilterIdCounter = 1;

        /// <summary>
        /// Dictionary of open devices.
        /// </summary>
        private Dictionary<int, List<SimulatedChannel>> openDevices = new Dictionary<int, List<SimulatedChannel>>();

        /// <summary>
        /// Dictionary of open channels.
        /// </summary>
        private Dictionary<int, SimulatedChannel> openChannels = new Dictionary<int, SimulatedChannel>();

        /// <summary>
        /// Dictionary of active filters.
        /// </summary>
        private Dictionary<int, FilterItem> activeFilters = new Dictionary<int, FilterItem>();

        /// <summary>
        /// Last error encountered.
        /// </summary>
        private string lastError = "No Error";

        /// <summary>
        /// CAN communicator instance.
        /// </summary>
        private VectorCanCommunicator vectorCanCommunicator;

        /// <summary>
        /// Session layer part.
        /// </summary>
        private SessionLayer sessionLayer;

        /// <summary>
        /// Event logging instance.
        /// </summary>
        private ILogging iLogging;

        /// <summary>
        /// Preferences instance.
        /// </summary>
        private IPreferences iPreferences;

        /// <summary>
        /// Queue of incoming data.
        /// </summary>
        private Queue<PayloadItem> inQueue = new Queue<PayloadItem>();

        /// <summary>
        /// Initializes a new instance of the <see cref="VectorPassthru" /> class.
        /// </summary>
        /// <param name="iLogging">Event logging instance.</param>
        /// <param name="iPreferences">Preferences instance.</param>
        public VectorPassthru(ILogging iLogging, IPreferences iPreferences)
        {
            this.iLogging = iLogging;
            this.iPreferences = iPreferences;

            this.vectorCanCommunicator = new VectorCanCommunicator("CanDataMiner", iLogging, 20);
        }

        /// <summary>
        /// Clean up.
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Process the payload data.
        /// </summary>
        /// <param name="address">Target address.</param>
        /// <param name="length">Data length.</param>
        /// <param name="data">Payload data.</param>
        public void processPayload(uint address, uint length, byte[] data)
        {
            lock (this.inQueue)
            {
                this.inQueue.Enqueue(new PayloadItem(address, length, data));
                Monitor.PulseAll(this.inQueue);
            }
        }

        /// <summary>
        /// Get list of supported protocols.
        /// </summary>
        /// <returns>Array of supported protocols by the device.</returns>
        public Protocols[] getProtocols()
        {
            return new Protocols[]
            {
                Protocols.getProtocolById(Protocols.ISO15765),
                Protocols.getProtocolById(Protocols.CAN),
            };
        }

        /// <summary>
        /// Indicate if the interface is a serial device.
        /// <para>
        /// Notice that this also applies to Serial on USB devices.
        /// </para>
        /// </summary>
        /// <returns>'true' if serial device.</returns>
        public bool isSerial()
        {
            return false;
        }

        /// <summary>
        /// Flag indicating that the interface has a disconnect bug that needs to be considered.
        /// </summary>
        /// <returns>'true' if bug exists.</returns>
        public bool disconnectBug()
        {
            return false;
        }

        /// <summary>
        /// Get array of connection flags available on the device.
        /// </summary>
        /// <returns>Array of CanFlags.</returns>
        public CanFlags[] getConnFlags()
        {
            return connFlags;
        }

        /// <summary>
        /// Get array of message flags available on the device.
        /// </summary>
        /// <returns>Array of CanFlags.</returns>
        public CanFlags[] getMessageFlags()
        {
            return messageFlags;
        }

        /// <summary>
        /// Implementation of PassThruOpen.
        /// </summary>
        /// <param name="pName">Always 'null'.</param>
        /// <param name="pDeviceID">Pointer to selected device ID. (return value)</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1", Justification = "Reviewed, intentional.")]
        public unsafe PassThruConstants.resultCode PassThruOpen(void* pName, int* pDeviceID)
        {
            PassThruConstants.resultCode res = PassThruConstants.resultCode.ERR_DEVICE_NOT_CONNECTED;

            try
            {
                this.sessionLayer = new SessionLayer(this.iLogging, this.iPreferences, 0x07E8, 0x07F8, true);
                this.sessionLayer.addPresentationLayer(this);
                this.sessionLayer.setCanCommunicator(this.vectorCanCommunicator);
                this.vectorCanCommunicator.startCan();

                this.openDevices.Add(this.DeviceIdCounter, new List<SimulatedChannel>());
                *pDeviceID = this.DeviceIdCounter++;
                res = PassThruConstants.resultCode.ERR_SUCCESS;
            }
            catch (Exception ex)
            {
                this.iLogging.appendTextLn(ex.GetType().ToString() + ": " + ex.Message);
            }

            return res;
        }

        /// <summary>
        /// Close the given device.
        /// </summary>
        /// <param name="DeviceID">ID of device to close.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public PassThruConstants.resultCode PassThruClose(int DeviceID)
        {
            if (this.openDevices.ContainsKey(DeviceID))
            {
                if (this.sessionLayer != null)
                {
                    this.vectorCanCommunicator.stopCan();
                    this.sessionLayer.setCanCommunicator(null);
                    this.sessionLayer.removePresentationLayer(this);
                    this.sessionLayer.Dispose();
                    this.sessionLayer = null;
                }

                List<SimulatedChannel> deviceChannels = this.openDevices[DeviceID];
                foreach (SimulatedChannel channel in deviceChannels)
                {
                    this.PassThruDisconnect(channel.channelId);
                }

                this.openDevices.Remove(DeviceID);

                // Remove remaining data from in queue.
                this.inQueue.Clear();

                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_DEVICE_ID;
        }

        /// <summary>
        /// Establish a connection on the given device.
        /// </summary>
        /// <param name="DeviceID">ID of current device.</param>
        /// <param name="ProtocolID">ID of protocol to use.</param>
        /// <param name="Flags">Connection Flags.</param>
        /// <param name="Baudrate">Baudrate to use for connection.</param>
        /// <param name="pChannelID">Pointer to value for channel id (return value)</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "4", Justification = "Reviewed, intentional.")]
        public unsafe PassThruConstants.resultCode PassThruConnect(int DeviceID, int ProtocolID, uint Flags, uint Baudrate, int* pChannelID)
        {
            if (this.openDevices.ContainsKey(DeviceID))
            {
                // Only CAN-bus handled.
                if (ProtocolID != Protocols.ISO15765 && ProtocolID != Protocols.CAN)
                {
                    return PassThruConstants.resultCode.ERR_INVALID_PROTOCOL_ID;
                }

                Protocols protocol = Protocols.getProtocolById(ProtocolID);
                foreach (SimulatedChannel channel in this.openChannels.Values)
                {
                    Protocols proto1 = Protocols.getProtocolById(channel.protocol.id);
                    if (proto1.families == protocol.families)
                    {
                        return PassThruConstants.resultCode.ERR_CHANNEL_IN_USE;
                    }
                }

                List<SimulatedChannel> deviceChannels = this.openDevices[DeviceID];
                SimulatedChannel simulatedConnection = new SimulatedChannel(DeviceID, this.ChannelIdCounter, protocol);
                deviceChannels.Add(simulatedConnection);
                *pChannelID = this.ChannelIdCounter;

                this.openChannels.Add(this.ChannelIdCounter++, simulatedConnection);

                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_DEVICE_NOT_CONNECTED;
        }

        /// <summary>
        /// Disconnect the given channel.
        /// </summary>
        /// <param name="ChannelID">ID of channel to disconnect.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public PassThruConstants.resultCode PassThruDisconnect(int ChannelID)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                SimulatedChannel channel = this.openChannels[ChannelID];
                List<SimulatedChannel> deviceChannels = this.openDevices[channel.deviceId];
                if (deviceChannels.Contains(channel))
                {
                    deviceChannels.Remove(channel);
                }

                this.openChannels.Remove(ChannelID);

                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Read messages from the given channel.
        /// </summary>
        /// <param name="ChannelID">ID of channel to read from.</param>
        /// <param name="pMsg">Pointer to message(s) read.</param>
        /// <param name="pNumMsgs">Number of messages to read, value set at return to actual number read.</param>
        /// <param name="Timeout">Timeout value before returning with no message read.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1", Justification = "Reviewed")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Justification = "Reviewed")]
        public unsafe PassThruConstants.resultCode PassThruReadMsgs(int ChannelID, PASSTHRU_MSG* pMsg, int* pNumMsgs, int Timeout)
        {
            if (pMsg != null)
            {
                if (pNumMsgs != null)
                {
                    if (this.openChannels.ContainsKey(ChannelID))
                    {
                        lock (this.inQueue)
                        {
                            if (this.inQueue.Count == 0)
                            {
                                if (!Monitor.Wait(this.inQueue, Timeout))
                                {
                                    if (this.inQueue.Count > 0)
                                    {
                                        this.iLogging.appendTextLn("VectorPassthru.PassThruReadMsgs(): Timeout with data present. this.sendQueue.Count=" + this.inQueue.Count);
                                    }
                                }
                            }

                            if (this.inQueue.Count > 0)
                            {
                                PayloadItem item = this.inQueue.Dequeue();

                                pMsg->DataSize = item.passthruData.Length;
                                for (int i = 0; i < pMsg->DataSize; i++)
                                {
                                    pMsg->Data[i] = item.passthruData[i];
                                }

                                pMsg->ExtraDataIndex = 0;
                                pMsg->RxStatus = 0;
                                pMsg->Timestamp = (int)(DateTime.Now.Ticks / TimeSpan.TicksPerSecond);
                                pMsg->TxFlags = 0;
                                *pNumMsgs = 1;
                            }
                            else
                            {
                                *pNumMsgs = 0;
                                return PassThruConstants.resultCode.ERR_TIMEOUT;
                            }
                        }

                        return PassThruConstants.resultCode.ERR_SUCCESS;
                    }

                    return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
                }
            }

            return PassThruConstants.resultCode.ERR_NULL_PARAMETER;
        }

        /// <summary>
        /// Write messages to the given channel.
        /// </summary>
        /// <param name="ChannelID">ID of channel to write to.</param>
        /// <param name="pMsg">Message(s) to write.</param>
        /// <param name="pNumMsgs">Number of messages to write.</param>
        /// <param name="Timeout">Timeout when writing message to out channel.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1", Justification = "Reviewed, intentional.")]
        public unsafe PassThruConstants.resultCode PassThruWriteMsgs(int ChannelID, PASSTHRU_MSG* pMsg, int* pNumMsgs, int Timeout)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                uint outAddress = (uint)(pMsg->Data[0] << 24 | pMsg->Data[1] << 16 | pMsg->Data[2] << 8 | pMsg->Data[3]);

                IList<byte> response = new List<byte>();
                for (int i = 0; i < pMsg->DataSize - 4; i++)
                {
                    response.Add(pMsg->Data[i + 4]);
                }

                if (this.sessionLayer != null)
                {
                    this.sessionLayer.sendData(outAddress, response, (uint)response.Count);
                    return PassThruConstants.resultCode.ERR_SUCCESS;
                }
                else
                {
                    return PassThruConstants.resultCode.ERR_NULL_PARAMETER;
                }
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Start a periodic message to send from application to vehicle.
        /// </summary>
        /// <param name="ChannelID">ID of channel to write to.</param>
        /// <param name="pMsg">Message(s) to write.</param>
        /// <param name="pMsgID">Return value: ID of message being sent.</param>
        /// <param name="TimeInterval">Interval between each message in milliseconds.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public unsafe PassThruConstants.resultCode PassThruStartPeriodicMsg(int ChannelID, PASSTHRU_MSG* pMsg, int* pMsgID, int TimeInterval)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Stop a periodic message from being sent to the vehicle.
        /// </summary>
        /// <param name="ChannelID">ID of channel to stop message on.</param>
        /// <param name="MsgID">ID of message to stop sending.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public PassThruConstants.resultCode PassThruStopPeriodicMsg(int ChannelID, int MsgID)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Configure a message filter.
        /// </summary>
        /// <param name="ChannelID">Channel to configure filter on.</param>
        /// <param name="FilterType">Type of filter to configure.</param>
        /// <param name="pMaskMsg">Mask message in filter.</param>
        /// <param name="pPatternMsg">Pattern message in filter.</param>
        /// <param name="pFlowControlMsg">Flow control message in filter.</param>
        /// <param name="pMsgID">ID of filter created (out value)</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "5", Justification = "Reviewed, intentional.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Justification = "Reviewed, intentional.")]
        public unsafe PassThruConstants.resultCode PassThruStartMsgFilter(
            int ChannelID,
            int FilterType,
            PASSTHRU_MSG* pMaskMsg,
            PASSTHRU_MSG* pPatternMsg,
            PASSTHRU_MSG* pFlowControlMsg,
            int* pMsgID)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                this.activeFilters.Add(
                    this.FilterIdCounter,
                    new FilterItem(
                        this.FilterIdCounter,
                        (uint)FilterType,
                        pMaskMsg->DataSize,
                        parseMask(pMaskMsg),
                        parseMask(pPatternMsg),
                        parseMask(pFlowControlMsg),
                        (uint)pMaskMsg->TxFlags,
                        pMaskMsg->ProtocolID));

                *pMsgID = this.FilterIdCounter;
                this.FilterIdCounter++;

                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Stop a message filter.
        /// </summary>
        /// <param name="ChannelID">Channel to remove filter from.</param>
        /// <param name="MsgID">ID of filter to remove.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public PassThruConstants.resultCode PassThruStopMsgFilter(int ChannelID, int MsgID)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                if (this.activeFilters.ContainsKey(MsgID))
                {
                    this.activeFilters.Remove(MsgID);
                    return PassThruConstants.resultCode.ERR_SUCCESS;
                }
                else
                {
                    return PassThruConstants.resultCode.ERR_INVALID_FILTER_ID;
                }
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Configure the programming voltage pin and voltage.
        /// </summary>
        /// <param name="DeviceID">ID of Device to configure.</param>
        /// <param name="Pin">Number of pin to configure.</param>
        /// <param name="Voltage">Voltage to set at pin.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public PassThruConstants.resultCode PassThruSetProgrammingVoltage(int DeviceID, int Pin, int Voltage)
        {
            if (this.openDevices.ContainsKey(DeviceID))
            {
                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_DEVICE_ID;
        }

        /// <summary>
        /// Read API version.
        /// </summary>
        /// <param name="DeviceID">ID to get version information from.</param>
        /// <param name="pFirmwareVersion">Firmware version (return value).</param>
        /// <param name="pDllVersion">DLL version (return value).</param>
        /// <param name="pApiVersion">API version (return value).</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public unsafe PassThruConstants.resultCode PassThruReadVersion(int DeviceID, byte* pFirmwareVersion, byte* pDllVersion, byte* pApiVersion)
        {
            if (this.openDevices.ContainsKey(DeviceID))
            {
                byte[] fwVer = System.Text.Encoding.ASCII.GetBytes("0.00");
                byte[] dllVer = System.Text.Encoding.ASCII.GetBytes(this.vectorCanCommunicator.dllVersion);
                byte[] apiVer = System.Text.Encoding.ASCII.GetBytes("04.04");

                strcpy(fwVer, pFirmwareVersion);
                strcpy(dllVer, pDllVersion);
                strcpy(apiVer, pApiVersion);

                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_DEVICE_ID;
        }

        /// <summary>
        /// Get the last error encountered on the device.
        /// </summary>
        /// <param name="pErrorDescription">Pointer to string with error description.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public unsafe PassThruConstants.resultCode PassThruGetLastError(sbyte* pErrorDescription)
        {
            // lastError
            byte[] ascii = System.Text.Encoding.ASCII.GetBytes(this.lastError);
            for (int i = 0; i < ascii.Length; i++)
            {
                *pErrorDescription = (sbyte)ascii[i];
                pErrorDescription++;
            }
            *pErrorDescription = 0;
            return PassThruConstants.resultCode.ERR_SUCCESS;
        }

        /// <summary>
        /// Perform IOCTL operation on the device.
        /// </summary>
        /// <param name="ChannelID">ID of channel to perform operation on.</param>
        /// <param name="IoctlID">IOCTL Operation.</param>
        /// <param name="pInput">Input parameter for operation.</param>
        /// <param name="pOutput">Output parameter for operation.</param>
        /// <returns>'0' if success, non-zero if a failure occurred.</returns>
        public unsafe PassThruConstants.resultCode PassThruIoctl(
            int ChannelID,
            int IoctlID,
            void* pInput,
            void* pOutput)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Clean up.
        /// </summary>
        /// <param name="disposing">'true' if disposing.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (this.sessionLayer != null)
            {
                this.sessionLayer.Dispose();
                this.sessionLayer = null;
            }

            if (this.vectorCanCommunicator != null)
            {
                this.vectorCanCommunicator.Dispose();
                this.vectorCanCommunicator = null;
            }
        }

        /// <summary>
        /// Copy a 'string' in a byte array to a pre-allocated area designated by a pointer.
        /// </summary>
        /// <param name="ba">Source array.</param>
        /// <param name="p">Target area.</param>
        private static unsafe void strcpy(byte[] ba, byte* p)
        {
            int i;
            for (i = 0; i < ba.Length; i++)
            {
                p[i] = ba[i];
            }

            p[i] = 0;
        }

        /// <summary>
        /// Parse the msg mask.
        /// </summary>
        /// <param name="pMsg">Pointer to struct.</param>
        /// <returns>Parsed value</returns>
        private static unsafe uint parseMask(PASSTHRU_MSG* pMsg)
        {
            return parseMask(new PassThruMsg(pMsg));
        }

        /// <summary>
        /// Parse the msg mask.
        /// </summary>
        /// <param name="msg">Message instance.</param>
        /// <returns>Parsed value</returns>
        private static uint parseMask(PassThruMsg msg)
        {
            uint mask = (uint)(msg.Data[0] << 24 | msg.Data[1] << 16 | msg.Data[2] << 8 | msg.Data[3]);
            return mask;
        }

        /// <summary>
        /// Item for a simulated channel.
        /// </summary>
        private class SimulatedChannel
        {
            /// <summary>
            /// Gets ID of device.
            /// </summary>
            public int deviceId { get; private set; }

            /// <summary>
            /// Gets ID of channel.
            /// </summary>
            public int channelId { get; private set; }

            /// <summary>
            /// Gets protocol instance.
            /// </summary>
            public Protocols protocol { get; private set; }

            /// <summary>
            /// Initializes a new instance of the <see cref="SimulatedChannel" /> class.
            /// </summary>
            /// <param name="deviceId">ID of device.</param>
            /// <param name="channelId">ID of channel.</param>
            /// <param name="protocol">Protocol instance.</param>
            public SimulatedChannel(int deviceId, int channelId, Protocols protocol)
            {
                this.deviceId = deviceId;
                this.channelId = channelId;
                this.protocol = protocol;
            }
        }

        /// <summary>
        /// Item for a filter.
        /// </summary>
        private class FilterItem
        {
            /// <summary>
            /// Gets ID of filter.
            /// </summary>
            public int msgId { get; private set; }

            /// <summary>
            /// Gets type of filter.
            /// </summary>
            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Reviewed.")]
            public uint filterType { get; private set; }

            /// <summary>
            /// Gets datasize.
            /// </summary>
            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Reviewed.")]
            public int datasize { get; private set; }

            /// <summary>
            /// Gets filter mask.
            /// </summary>
            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Reviewed.")]
            public uint mask { get; private set; }

            /// <summary>
            /// Gets filter pattern.
            /// </summary>
            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Reviewed.")]
            public uint pattern { get; private set; }

            /// <summary>
            /// Gets filter flow.
            /// </summary>
            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Reviewed.")]
            public uint flow { get; private set; }

            /// <summary>
            /// Gets filter TX flags.
            /// </summary>
            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Reviewed.")]
            public uint txFlags { get; private set; }

            /// <summary>
            /// Gets filter protocol ID.
            /// </summary>
            [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Reviewed.")]
            public int protocol { get; private set; }

            /// <summary>
            /// Initializes a new instance of the <see cref="FilterItem" /> class.
            /// </summary>
            /// <param name="msgId">Filter ID</param>
            /// <param name="filterType">Type of filter</param>
            /// <param name="datasize">Data Size</param>
            /// <param name="mask">Filter Mask</param>
            /// <param name="pattern">Filter Pattern</param>
            /// <param name="flow">Filter Flow</param>
            /// <param name="txFlags">Filter TX flags</param>
            /// <param name="protocol">Filter protocol ID</param>
            public FilterItem(
                int msgId,
                uint filterType,
                int datasize,
                uint mask,
                uint pattern,
                uint flow,
                uint txFlags,
                int protocol)
            {
                this.msgId = msgId;
                this.filterType = filterType;
                this.datasize = datasize;
                this.protocol = protocol;
                this.mask = mask;
                this.pattern = pattern;
                this.flow = flow;
                this.txFlags = txFlags;
            }

            /// <summary>
            /// Get string representation of filter.
            /// </summary>
            /// <returns>String representation</returns>
            public override string ToString()
            {
#if TRACE
                return "msgId=" + this.msgId + ", filterType=" + this.filterType + ", datasize=" + this.datasize + ", protocol=0x" + this.protocol.ToString("x2") + ", mask=0x" + this.mask.ToString("x4") + ", pattern=0x" + this.pattern.ToString("x4") + ", flow=0x" + this.flow.ToString("x4") + ", txFlags=0x" + this.txFlags.ToString("x4") + "\r\n";
#else
                return "msgId=" + this.msgId + "\r\n";
#endif
            }
        }

        /// <summary>
        /// Payload item.
        /// </summary>
        private class PayloadItem
        {
            /// <summary>
            /// Gets Data body to send through PassThru interface.
            /// </summary>
            public byte[] passthruData { get; private set; }

            /// <summary>
            /// Initializes a new instance of the <see cref="PayloadItem" /> class.
            /// </summary>
            /// <param name="address">Destination address.</param>
            /// <param name="length">Payload length.</param>
            /// <param name="data">Payload data.</param>
            public PayloadItem(uint address, uint length, byte[] data)
            {
                this.passthruData = new byte[length + 4];

                this.passthruData[0] = (byte)((address >> 24) & 0xff);
                this.passthruData[1] = (byte)((address >> 16) & 0xff);
                this.passthruData[2] = (byte)((address >> 8) & 0xff);
                this.passthruData[3] = (byte)(address & 0xff);

                Array.Copy(data, 0, this.passthruData, 4, length);
            }
        }
    }
}