//-----------------------------------------------------------------------
// <copyright file="SerialAtPassThru.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.Serial
{
    using System.Collections.Generic;
    using System.Threading;
    using global::SharedObjects.Api;
    using global::SharedObjects.Protocol;

    /// <summary>
    /// Class for when using Serial interface with AT commands.
    /// <para>
    /// Notice that much of this class will not be called and that the communication
    /// with the device is done with the protocol handler.
    /// </para>
    /// </summary>
    public abstract class SerialAtPassThru : IPassThru
    {
        /// <summary>
        /// Supported connection flags by the device.
        /// </summary>
        private static CanFlags[] connFlags = new CanFlags[]
        {
        };

        /// <summary>
        /// Supported filter flags by the device.
        /// </summary>
        private static CanFlags[] filterFlags = new CanFlags[]
        {
        };

        /// <summary>
        /// List of supported protocols by device.
        /// </summary>
        private Protocols[] protos = null;

        /// <summary>
        /// Gets or sets array of supported protocols by device.
        /// </summary>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "Reviewed, intentional.")]
        public Protocols[] protocols
        {
            get { return this.protos; }
            protected set { this.protos = value; }
        }

        /// <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>
        /// Default serial port parameters for the protocol.
        /// </summary>
        private SerialPortParameters serialPortPars = null;

        /// <summary>
        /// Gets or sets the default parameters for the protocol.
        /// </summary>
        public SerialPortParameters serialPortParameters
        {
            get { return new SerialPortParameters(this.serialPortPars); }
            protected set { this.serialPortPars = value; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SerialAtPassThru" /> class.
        /// </summary>
        protected SerialAtPassThru()
        {
        }

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

        /// <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 true;
        }

        /// <summary>
        /// Gets the name of the device.
        /// </summary>
        public abstract string name { get; }

        /// <summary>
        /// Gets the name of the device.
        /// </summary>
        public abstract string code { get; }

        /// <summary>
        /// Get flag indicating if device has disconnect bug.
        /// </summary>
        /// <returns>Flag indicating disconnect bug.</returns>
        public bool disconnectBug()
        {
            return false;
        }

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

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

        /// <summary>
        /// Open the device.
        /// </summary>
        /// <param name="pName">Device Name (Shall be 'null')</param>
        /// <param name="pDeviceID">Assigned Device ID (out value)</param>
        /// <returns>Status of operation, 0=Success.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1", Justification = "Provided data shall never be 'null'.")]
        public unsafe PassThruConstants.resultCode PassThruOpen(void* pName, int* pDeviceID)
        {
            this.openDevices.Add(this.DeviceIdCounter, new List<SimulatedChannel>());
            *pDeviceID = this.DeviceIdCounter++;
            return PassThruConstants.resultCode.ERR_SUCCESS;
        }

        /// <summary>
        /// Close the device.
        /// </summary>
        /// <param name="DeviceID">ID of device to close.</param>
        /// <returns>Status of operation, 0=Success.</returns>
        public PassThruConstants.resultCode PassThruClose(int DeviceID)
        {
            if (this.openDevices.ContainsKey(DeviceID))
            {
                List<SimulatedChannel> deviceChannels = this.openDevices[DeviceID];
                foreach (SimulatedChannel channel in deviceChannels)
                {
                    this.PassThruDisconnect(channel.channelId);
                }

                this.openDevices.Remove(DeviceID);

                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_DEVICE_ID;
        }

        /// <summary>
        /// Establish a connection to the device.
        /// </summary>
        /// <param name="DeviceID">ID of device.</param>
        /// <param name="ProtocolID">ID of protocol.</param>
        /// <param name="Flags">Connection flags.</param>
        /// <param name="Baudrate">Baudrate to connect with.</param>
        /// <param name="pChannelID">Assigned channel ID (out value)</param>
        /// <returns>Status of operation, 0=Success.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "4", Justification = "Provided data shall never be 'null'.")]
        public unsafe PassThruConstants.resultCode PassThruConnect(int DeviceID, int ProtocolID, uint Flags, uint Baudrate, int* pChannelID)
        {
            if (this.openDevices.ContainsKey(DeviceID))
            {
                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 from device.
        /// </summary>
        /// <param name="ChannelID">Channel to disconnect.</param>
        /// <returns>Status of operation, 0=Success.</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 device.
        /// </summary>
        /// <param name="ChannelID">Channel to read from.</param>
        /// <param name="pMsg">Pointer to message struct.</param>
        /// <param name="pNumMsgs">Number of messages to read, set to actual number of messages read when returned.</param>
        /// <param name="Timeout">Timeout waiting for messages.</param>
        /// <returns>Status of operation, 0=Success.</returns>
        public unsafe PassThruConstants.resultCode PassThruReadMsgs(int ChannelID, PASSTHRU_MSG* pMsg, int* pNumMsgs, int Timeout)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                Thread.Sleep(Timeout);
                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Write messages to device.
        /// </summary>
        /// <param name="ChannelID">Channel to write to.</param>
        /// <param name="pMsg">Pointer to message struct.</param>
        /// <param name="pNumMsgs">Number of messages to send.</param>
        /// <param name="Timeout">Timeout sending message.</param>
        /// <returns>Status of operation, 0=Success.</returns>
        public unsafe PassThruConstants.resultCode PassThruWriteMsgs(int ChannelID, PASSTHRU_MSG* pMsg, int* pNumMsgs, int Timeout)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Configure periodic message to send.
        /// </summary>
        /// <param name="ChannelID">Channel to send on.</param>
        /// <param name="pMsg">Message to send.</param>
        /// <param name="pMsgID">ID of message being sent. (out data)</param>
        /// <param name="TimeInterval">Interval between each transmission.</param>
        /// <returns>Status of operation, 0=Success.</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 sending periodic message.
        /// </summary>
        /// <param name="ChannelID">Channel to stop sending on.</param>
        /// <param name="MsgID">ID of message to stop sending.</param>
        /// <returns>Status of operation, 0=Success.</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>
        /// Add a message filter.
        /// </summary>
        /// <param name="ChannelID">Channel to add filter to.</param>
        /// <param name="FilterType">Type of filter.</param>
        /// <param name="pMaskMsg">Mask message.</param>
        /// <param name="pPatternMsg">Pattern message.</param>
        /// <param name="pFlowControlMsg">Flow control message.</param>
        /// <param name="pMsgID">ID of filter added. (out value)</param>
        /// <returns>Result status, 0=success.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "5", Justification = "Provided data shall never be 'null'.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Justification = "Provided data shall never be 'null'.")]
        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>
        /// Remove message filter.
        /// </summary>
        /// <param name="ChannelID">Channel to remove filter from.</param>
        /// <param name="MsgID">ID of filter to remove.</param>
        /// <returns>Result status, 0=success.</returns>
        public PassThruConstants.resultCode PassThruStopMsgFilter(int ChannelID, int MsgID)
        {
            if (this.openChannels.ContainsKey(ChannelID))
            {
                if (this.activeFilters.ContainsKey(MsgID))
                {
                    return PassThruConstants.resultCode.ERR_SUCCESS;
                }
                else
                {
                    return PassThruConstants.resultCode.ERR_INVALID_FILTER_ID;
                }
            }

            return PassThruConstants.resultCode.ERR_INVALID_CHANNEL_ID;
        }

        /// <summary>
        /// Set the programming voltage for the device.
        /// </summary>
        /// <param name="DeviceID">ID of device to set voltage on.</param>
        /// <param name="Pin">Pin to set voltage on.</param>
        /// <param name="Voltage">Voltage to set.</param>
        /// <returns>Result status, 0=success.</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 version of API.
        /// </summary>
        /// <param name="DeviceID">ID of device to read API version from.</param>
        /// <param name="pFirmwareVersion">Firmware Version (out value)</param>
        /// <param name="pDllVersion">DLL Version (out value)</param>
        /// <param name="pApiVersion">API Version (out value)</param>
        /// <returns>Result status, 0=success.</returns>
        public unsafe PassThruConstants.resultCode PassThruReadVersion(int DeviceID, byte* pFirmwareVersion, byte* pDllVersion, byte* pApiVersion)
        {
            if (this.openDevices.ContainsKey(DeviceID))
            {
                return PassThruConstants.resultCode.ERR_SUCCESS;
            }

            return PassThruConstants.resultCode.ERR_INVALID_DEVICE_ID;
        }

        /// <summary>
        /// Get the last error from the API.
        /// </summary>
        /// <param name="pErrorDescription">Error text.</param>
        /// <returns>Result status, 0=success.</returns>
        public unsafe PassThruConstants.resultCode PassThruGetLastError(sbyte* pErrorDescription)
        {
            return PassThruConstants.resultCode.ERR_SUCCESS;
        }

        /// <summary>
        /// Perform IOCTL operation on channel.
        /// </summary>
        /// <param name="ChannelID">Channel to perform operation on.</param>
        /// <param name="IoctlID">IOCTL operation.</param>
        /// <param name="pInput">Input data to operation.</param>
        /// <param name="pOutput">Result data from operation.</param>
        /// <returns>Result status, 0=success.</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>
        /// 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
            }
        }
    }
}