//-----------------------------------------------------------------------
// <copyright file="Protocol_ISO14230.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 Protocol
{
    using System.Threading;
    using global::DeviceApi;
    using global::SharedObjects;
    using global::SharedObjects.Api;
    using global::SharedObjects.GUI;
    using global::SharedObjects.Misc;
    using global::SharedObjects.Protocol;

    /// <summary>
    /// Handler for ISO9141, ISO14230 and KWP2000
    /// <para>
    /// UNDER DEVELOPMENT!
    /// </para>
    /// </summary>
    public class Protocol_ISO14230 : Protocol_Common, IProtocolHandler, IMsgCallback
    {
        /// <summary>
        /// Start Communication.
        /// </summary>
        private const int SERVICEID_STARTCOMM = 0x81;

        /// <summary>
        /// Stop Communication.
        /// </summary>
        private const int SERVICEID_STOPCOMM = 0x82;

        /// <summary>
        /// Get Timing Parameters.
        /// </summary>
        private const int SERVICEID_GET_TIMING_PARAMS = 0x83;

        /// <summary>
        /// Negative Response. (usually handled by mode parser).
        /// </summary>
        private const int SERVICEID_NRC = 0x7F; // Same NRC as for other requests.

        /// <summary>
        /// Start Communication Response.
        /// </summary>
        private const int SERVICEID_STARTCOMM_RESPONSE = 0xC1;

        /// <summary>
        /// Stop Communication Response.
        /// </summary>
        private const int SERVICEID_STOPCOMM_RESPONSE = 0xC2;

        /// <summary>
        /// Get Timing Parameters Response.
        /// </summary>
        private const int SERVICEID_GET_TIMING_PARAMS_RESPONSE = 0xC3;

        /// <summary>
        /// Protocol not yet detected.
        /// </summary>
        private const int PROTOCOL_UNKNOWN = 0x00;

        /// <summary>
        /// Protocol ISO9141 detected.
        /// </summary>
        private const int PROTOCOL_ISO9141 = 0x01;

        /// <summary>
        /// Protocol ISO14230 (KWP2000) detected.
        /// </summary>
        private const int PROTOCOL_ISO14230 = 0x02;

        /// <summary>
        /// Possible address bit alternatives for protocol.
        /// </summary>
        private static readonly string[] possibleAddressbits = { "8" };
        /*
        /// <summary>
        /// Array of protocol names.
        /// </summary>
        private static readonly string[] possibleProtocols =
        {
            "Unknown",
            "ISO9141",
            "ISO14230"
        };
         */
        /*
        /// <summary>
        /// Header modes for data.
        /// </summary>
        private static readonly string[] headerModes =
        {
            "HM0: ",
            "HM1: ",
            "HM2: Physical Target Address",
            "HM3: Functional Target Address"
        };
        */

        /// <summary>
        /// Message ID for keep alive message.
        /// </summary>
        private int keepAliveMsgId;

        /// <summary>
        /// Gets Which protocol that was detected.
        /// </summary>
        public int detectedProtocol { get; private set; }

        /// <summary>
        /// Gets or sets a value indicating whether the long header shall be used even for short messages.
        /// </summary>
        public bool forceLongHeader { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="Protocol_ISO14230" /> class.
        /// </summary>
        /// <param name="iLogging">Logging interface.</param>
        /// <param name="protocol">Current protocol.</param>
        /// <param name="messageHandler">Current message handler instance.</param>
        /// <param name="srcAddr">Source address.</param>
        /// <param name="checksum">Checksum flag.</param>
        /// <param name="iEnableButtons">Callback interface for enabling the buttons when a protocol is fully initialized.</param>
        public Protocol_ISO14230(
            ILogging iLogging,
            Protocols protocol,
            MessageHandler messageHandler,
            uint srcAddr,
            bool checksum,
            IEnableButtons iEnableButtons)
            : base(iLogging, protocol, messageHandler, srcAddr, checksum, iEnableButtons)
        {
            this.iLogging.appendText("Protocol_ISO14230 & ISO9141: srcAddr=0x" + srcAddr.ToString("x2") + ", checksum=" + checksum + "\r\n");
            this.detectedProtocol = PROTOCOL_UNKNOWN;
            this.forceLongHeader = false;

            // Register this protocol handler with the message handler.
            this.messageHandler.setProtocolCallback(this);
        }

        /// <summary>
        /// Get the address bit alternatives for the protocol.
        /// </summary>
        /// <returns>Array of alternatives.</returns>
        public static string[] addressBitAlternatives()
        {
            return possibleAddressbits;
        }

        /// <summary>
        /// Indicates if protocol is in 29 bit mode.
        /// </summary>
        /// <returns>'true' if protocol is in 29 bit mode.</returns>
        public bool is29bit()
        {
            return false;
        }

        /// <summary>
        /// Initialize protocol.
        /// </summary>
        /// <param name="txFlags">TX Flags for any messages that are created during initialization.</param>
        public void init(int txFlags)
        {
            uint outBytes = 0;
            uint keyWord1 = 0;
            uint keyWord2 = 0;
            string errtext;
            PassThruConstants.resultCode ret = PassThruConstants.resultCode.ERR_SUCCESS;

            if (ret != 0 || (keyWord1 == 0 && keyWord2 == 0))
            {
                iLogging.appendText("init(FIVE_BAUD_INIT)\r\n");
                ret = this.messageHandler.IoctlFiveBaudInit(0x33, out outBytes, out keyWord1, out keyWord2);
                iLogging.appendText("FIVE_BAUD_INIT: ret=" + ret + "[" + J2534_Error.getErrorName(ret) + "],  outBytes=" + outBytes + ",  kw1=0x" + keyWord1.ToString("x2") + ",  kw2=0x" + keyWord2.ToString("x2") + "\r\n");
            }

            if (this.protocol.id == Protocols.ISO14230 && (ret != 0 || (keyWord1 == 0 && keyWord2 == 0)))
            {
                Thread.Sleep(400);
                iLogging.appendText("init(FAST_INIT)\r\n");
                IPassThruMsg result;
                ret = this.messageHandler.IoctlFastInit(this.protocol.id, this.srcAddr, out result);
                iLogging.appendText("FAST_INIT: ret=" + ret + "[" + J2534_Error.getErrorName(ret) + "]\r\n");
                iLogging.dispMsg("FAST_INIT", result);
                this.messageHandler.errTestConnection(ret, out errtext);
                iLogging.appendText(errtext + "\r\n");
            }

            if (this.messageHandler.errTestConnection(ret, out errtext))
            {
                uint keyword = keyWord1 << 8 | keyWord2;
                switch (keyword)
                {
                    case 0x0808:
                    case 0x9494:
                        this.detectedProtocol = PROTOCOL_ISO9141;
                        this.iLogging.appendText("ISO 9141 detected.\r\n");
                        this.start();
                        break;
                    case 0x8fe9:
                    case 0x8f6b:
                    case 0x8f6d:
                    case 0x8fef:
                        this.detectedProtocol = PROTOCOL_ISO14230;
                        this.iLogging.appendText("ISO 14230 detected.\r\n");
                        this.start();
                        break;
                    default:
                        this.iLogging.appendText("Unsupported keyword: 0x" + keyword.ToString("x4") + ".\r\n");
                        break;
                }
            }
            else
            {
                iLogging.appendText(errtext + "\r\n");
                throw new ProtocolInitException("Connection Failed.");
            }
        }

        /// <summary>
        /// Start protocol.
        /// </summary>
        public void start()
        {
            IPassThruMsg msg = PassThruMsg.getMaskedMsg(this.protocol);
            if (this.detectedProtocol == PROTOCOL_ISO9141)
            {
                iLogging.appendText("start(PROTOCOL_ISO9141)\r\n");

                // addPayload(new byte[] { 0x68, 0x6a, 0xf0, SERVICEID_STARTCOMM }, ref msg);
                // addPayload(new byte[] { 0x68, 0x6a, 0x3f, SERVICEID_STARTCOMM }, ref msg);
                addPayload(new byte[] { 0x68, 0x6a, 0xf1, SERVICEID_STARTCOMM }, ref msg);
            }
            else
            {
                iLogging.appendText("start(PROTOCOL_ISO14230)\r\n");
                addPayload(new byte[] { 0xc1, 0x33, 0xf1, SERVICEID_STARTCOMM }, ref msg);
            }

            PassThruConstants.resultCode res = this.messageHandler.startPeriodicMessage(msg, out this.keepAliveMsgId);
            this.iLogging.appendText("Keep alive msg started, res=" + res + ",  msgId=" + this.keepAliveMsgId + "\r\n");
            this.iEnableButtons.enableButtons();
        }

        /// <summary>
        /// Stop protocol.
        /// </summary>
        public void stopProtocol()
        {
            this.messageHandler.stopPeriodicMessage(this.keepAliveMsgId);
        }

        /// <summary>
        /// Receive one message and dispatch it to receivers.
        /// </summary>
        /// <param name="rxmsg">Message to receive.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed.")]
        public void receiveMessage(IPassThruMsg rxmsg)
        {
            int headerMode;
            int dataLength;
            int dataStart;
            int destination;
            int source;

            getHeaderData(rxmsg, out headerMode, out dataLength, out dataStart, out destination, out source);

            // Calculate Checksum if the checkbox is checked.
            // Additional flags may need to be checked too.
            int expectedCs = 0;
            int calculatedCs = 0;
            if (this.checksum)
            {
                expectedCs = (rxmsg.Data[rxmsg.DataSize - 1] & 0xff);
                calculatedCs = Utils.getChecksum(rxmsg.Data, 0, rxmsg.DataSize - 1);

                if (expectedCs != calculatedCs)
                {
                    this.iLogging.appendText("Checksum mismatch detected: expectedCs=" + expectedCs + ",  calculatedCs=" + calculatedCs);
                }
            }

            // Get the Service Identification.
            if (dataStart < rxmsg.DataSize)
            {
                // int sid = rxmsg.Data[dataStart];

                /*
                this.iLogging.appendText(headerModes[headerMode]
                    + ", From=0x" + source.ToString("x2")
                    + ", To=0x" + destination.ToString("x2")
                    + ", dataStart=" + dataStart
                    + ", dataLength=" + dataLength
                    + ", Sid=0x" + sid.ToString("x2")
                    + ", expectedCs=0x" + expectedCs.ToString("x2")
                    + ", calculatedCs=0x" + calculatedCs.ToString("x2")
                    + "\r\n"
                    );

                 this.iLogging.dispMsg("Rx", rxmsg);

                 */

                // Extract the payload.
                byte[] payload = extractPayload(rxmsg, dataStart);

                this.dispatchMessage(rxmsg, payload, (uint)source, 0);
            }
            else
            {
                this.iLogging.appendText("Data start is beyond end of received data.\r\n", LogLevel.LOG_WARN);
            }
        }

        /// <summary>
        /// Get payload part from message.
        /// </summary>
        /// <param name="msg">Message to get payload data from.</param>
        /// <returns>Payload byte array.</returns>
        public override byte[] getPayload(IPassThruMsg msg)
        {
            int headerMode;
            int dataLength;
            int dataStart;
            int destination;
            int source;

            getHeaderData(msg, out headerMode, out dataLength, out dataStart, out destination, out source);

            byte[] payload = extractPayload(msg, dataStart);

            return payload;
        }

        /// <summary>
        /// Send one message where the header info already is set in the payload.
        /// </summary>
        /// <param name="srcAddr">Source address (address of tester).</param>
        /// <param name="txFlags">Tx Flags</param>
        /// <param name="payload">Message Payload which includes address data.</param>
        public void sendProbeMessage(uint srcAddr, int txFlags, byte[] payload)
        {
            if (this.detectedProtocol == PROTOCOL_ISO9141)
            {
                this.sendMessage(0x3f, 0x33, txFlags, payload);
            }
            else
            {
                this.sendMessage(0xf0, 0x33, txFlags, payload);
            }
            //// sendMessage(0xf1, 0x33, txFlags, payload);
        }

        /// <summary>
        /// Send one message to the given receiver address.
        /// </summary>
        /// <param name="sourceAddress">Source address.</param>
        /// <param name="destinationAddress">Destination address.</param>
        /// <param name="txFlags">TX Flags.</param>
        /// <param name="payload">Payload data.</param>
        /// <returns>Error message in case of a problem.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "3", Justification = "Reviewed.")]
        public string sendMessage(uint sourceAddress, uint destinationAddress, int txFlags, byte[] payload)
        {
            IPassThruMsg txmsg = PassThruMsg.getMaskedMsg(this.protocol);

            bool functionalTargetAddressing = false;
            switch (this.detectedProtocol)
            {
                case PROTOCOL_ISO9141:
                    destinationAddress = 0x6a;
                    break;
                case PROTOCOL_ISO14230:
                    functionalTargetAddressing = (destinationAddress == 0x33);
                    break;
            }

            // Add Address.
            this.setAddress(ref txmsg, sourceAddress, destinationAddress); // FIXME!

            this.setHeader(ref txmsg, (uint)payload.Length, functionalTargetAddressing);

            addPayload(payload, ref txmsg);

            PassThruConstants.resultCode res = this.sendMessage(txFlags, txmsg);

            // Check if error.
            string errtext = string.Empty;
            if (!this.messageHandler.errTestConnection(res, out errtext))
            {
                this.iLogging.dispMsg("Err", txmsg);
            }

            return errtext;
        }

        /// <summary>
        /// Set additional header data in addition to the address.
        /// </summary>
        /// <param name="txmsg">Message to add data to.</param>
        /// <param name="size">Size of message.</param>
        /// <param name="functionalTargetAddressing">'true' if the destination address is functional address.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed.")]
        public void setHeader(ref IPassThruMsg txmsg, uint size, bool functionalTargetAddressing)
        {
            switch (this.detectedProtocol)
            {
                case PROTOCOL_ISO9141:
                    txmsg.Data[0] = 0x68;
                    txmsg.DataSize = 3;
                    break;
                case PROTOCOL_ISO14230:
                    this.setISO14230Header(ref txmsg, size, functionalTargetAddressing);
                    break;
            }
        }

        /// <summary>
        /// Set the address(es) of the message.
        /// </summary>
        /// <param name="txmsg">Message to set data in.</param>
        /// <param name="sourceAddress">Source Address.</param>
        /// <param name="destinationAddress">Destination Address.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed.")]
        public void setAddress(ref IPassThruMsg txmsg, uint sourceAddress, uint destinationAddress)
        {
            txmsg.Data[1] = (byte)(destinationAddress & 0xff);
            txmsg.Data[2] = (byte)(sourceAddress & 0xff);

            txmsg.DataSize = 3;
        }

        /// <summary>
        /// Set the address(es) of the message.
        /// <para>
        /// This is a fully composed address, usually used by filters.
        /// </para>
        /// </summary>
        /// <param name="txmsg">Message to set data in.</param>
        /// <param name="address">Combined Address.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed.")]
        public void setAddress(ref IPassThruMsg txmsg, uint address)
        {
            txmsg.Data[1] = (byte)((address >> 8) & 0xff);
            txmsg.Data[2] = (byte)(address & 0xff);

            txmsg.DataSize = 3;
        }

        /// <summary>
        /// Get header data from message.
        /// </summary>
        /// <param name="rxmsg">Message to get header data from.</param>
        /// <param name="headerMode">Header mode value.</param>
        /// <param name="dataLength">Data length.</param>
        /// <param name="dataStart">Start position for data.</param>
        /// <param name="destination">Destination address.</param>
        /// <param name="source">Source address.</param>
        private static void getHeaderData(IPassThruMsg rxmsg, out int headerMode, out int dataLength, out int dataStart, out int destination, out int source)
        {
            headerMode = ((rxmsg.Data[0] >> 6) & 0xff);
            dataLength = (rxmsg.Data[0] & 0x3f);
            dataStart = 3;

            // If the length was zero we have a 4 byte header with the length
            // in the 4th byte.
            if (dataLength == 0)
            {
                dataLength = (rxmsg.Data[3] & 0xff);
                dataStart = 4;
            }

            destination = rxmsg.Data[1]; // Should be 'our' address when we are receiving.
            source = rxmsg.Data[2]; // Should be ECU address when we are receiving.
        }

        /// <summary>
        /// Add the payload to the message.
        /// </summary>
        /// <param name="payload">Byte array of payload to send.</param>
        /// <param name="txmsg">Message to update with payload.</param>
        /// <returns>Hex string with message, to be used for logging.</returns>
        private static string addPayload(byte[] payload, ref IPassThruMsg txmsg)
        {
            string dataStr = string.Empty;
            for (int i = 0; i < payload.Length; i++)
            {
                txmsg.Data[txmsg.DataSize++] = payload[i];
                dataStr += string.Format("{0:x2} ", payload[i]);
            }

            return dataStr;
        }

        /// <summary>
        /// Call the message handler and send the formatted message structure.
        /// </summary>
        /// <param name="txFlags">TX Flags.</param>
        /// <param name="txmsg">Message to send.</param>
        /// <returns>Status code, 0=success.</returns>
        private PassThruConstants.resultCode sendMessage(int txFlags, IPassThruMsg txmsg)
        {
            // Set message flags.
            txmsg.TxFlags = txFlags;

            this.addChecksum(ref txmsg);

            return this.messageHandler.sendMessage(txmsg);
        }

        /// <summary>
        /// Add checksum if requested.
        /// Notice that CAN and ISO 15765 doesn't need a checksum.
        /// But it's up to the user to decide, so we just check
        /// if the checkbox is checked.
        /// </summary>
        /// <param name="txmsg">Message to add checksum to.</param>
        private void addChecksum(ref IPassThruMsg txmsg)
        {
            if (this.checksum)
            {
                int cs = Utils.getChecksum(txmsg.Data, 0, txmsg.DataSize);
                txmsg.Data[txmsg.DataSize++] = (byte)(cs & 0xff);
            }
        }

        /// <summary>
        /// Set additional ISO14230 header data in addition to the address.
        /// </summary>
        /// <param name="txmsg">Message to add data to.</param>
        /// <param name="size">Size of message.</param>
        /// <param name="functionalTargetAddressing">'true' if the destination address is functional address.</param>
        private void setISO14230Header(ref IPassThruMsg txmsg, uint size, bool functionalTargetAddressing)
        {
            int headerMode;
            if (functionalTargetAddressing)
            {
                headerMode = 3;
            }
            else
            {
                headerMode = 2;
            }

            txmsg.Data[0] = (byte)((headerMode << 6) & 0xc0);
            if (size >= 64 || this.forceLongHeader)
            {
                txmsg.Data[3] = (byte)(size & 0xff);
                txmsg.DataSize = 4;
            }
            else
            {
                txmsg.Data[0] |= (byte)(size & 0x3f);
                txmsg.DataSize = 3;
            }
        }
    }
}