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

    /// <summary>
    /// Implementation of the ISO15765 protocol.
    /// </summary>
    public class Protocol_ISO15765 : Protocol_Common, IProtocolHandler, IMsgCallback
    {
        /// <summary>
        /// Possible address bits for protocol.
        /// </summary>
        private readonly string[] possibleAddressbits = { "11", "29" };

        /// <summary>
        /// Set if 29-bit addressing is active.
        /// </summary>
        private bool is29bitFlag;

        /// <summary>
        /// Initializes a new instance of the <see cref="Protocol_ISO15765" /> 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="is29bit">Indicates if 29 bit addressing shall be used.</param>
        /// <param name="iEnableButtons">Callback interface for enabling the buttons when a protocol is fully initialized.</param>
        public Protocol_ISO15765(
            ILogging iLogging,
            Protocols protocol,
            MessageHandler messageHandler,
            uint srcAddr,
            bool checksum,
            bool is29bit,
            IEnableButtons iEnableButtons)
            : base(iLogging, protocol, messageHandler, srcAddr, checksum, iEnableButtons)
        {
            this.is29bitFlag = is29bit;

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

        /// <summary>
        /// Indicate if protocol currently is 29 bit.
        /// </summary>
        /// <returns>'true' if 29 bit active.</returns>
        public bool is29bit()
        {
            return this.is29bitFlag;
        }

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

        /// <summary>
        /// Initialize protocol.
        /// </summary>
        /// <param name="txFlags">TX Flags for any messages that are created during initialization.</param>
        public void init(int txFlags)
        {
            // No init needed for this protocol.
            this.iEnableButtons.enableButtons();
        }

        /// <summary>
        /// Start protocol.
        /// </summary>
        public void start()
        {
            // No start needed for this protocol.
        }

        /// <summary>
        /// Stop protocol.
        /// </summary>
        public void stopProtocol()
        {
            // No stop needed for this protocol.
        }

        /// <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)
        {
            if (rxmsg.DataSize >= 4)
            {
                if (rxmsg.DataSize >= 5)
                {
                    byte[] payload = extractPayload(rxmsg, 4);
                    uint srcAddress = 0;

                    for (int i = 0; i < 4; i++)
                    {
                        srcAddress = (uint)(srcAddress << 8) | rxmsg.Data[i];
                    }

                    this.dispatchMessage(rxmsg, payload, srcAddress, 0);
                }
            }
            else
            {
                this.iLogging.appendText("Message too short! rxmsg.Datasize=" + rxmsg.DataSize + "\r\n");
            }
        }

        /// <summary>
        /// Get payload part of message.
        /// </summary>
        /// <param name="msg">Message to get payload from.</param>
        /// <returns>Byte array with payload.</returns>
        public override byte[] getPayload(IPassThruMsg msg)
        {
            byte[] payload = extractPayload(msg, 4);

            return payload;
        }

        /// <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>
        public void setHeader(ref IPassThruMsg txmsg, uint size, bool functionalTargetAddressing)
        {
            // Nothing to do here - this protocol does not have any
            // other info to add.
        }

        /// <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)
        {
            if (this.is29bit())
            {
                txmsg.Data[0] = (byte)((destinationAddress >> 24) & 0xff);
                txmsg.Data[1] = (byte)((destinationAddress >> 16) & 0xff);
                txmsg.Data[2] = (byte)((destinationAddress >> 8) & 0xff);
                txmsg.Data[3] = (byte)((sourceAddress) & 0xff);
            }
            else
            {
                txmsg.Data[0] = (byte)((destinationAddress >> 24) & 0xff);
                txmsg.Data[1] = (byte)((destinationAddress >> 16) & 0xff);
                txmsg.Data[2] = (byte)((destinationAddress >> 8) & 0xff);
                txmsg.Data[3] = (byte)((destinationAddress) & 0xff);
            }

            txmsg.DataSize = 4;
        }

        /// <summary>
        /// Set the address(es) of the message.
        /// </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[0] = (byte)((address >> 24) & 0xff);
            txmsg.Data[1] = (byte)((address >> 16) & 0xff);
            txmsg.Data[2] = (byte)((address >> 8) & 0xff);
            txmsg.Data[3] = (byte)((address) & 0xff);

            txmsg.DataSize = 4;
        }

        /// <summary>
        /// Send one probe message.
        /// </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.is29bitFlag)
            {
                this.sendMessage(srcAddr, 0x18db3300, txFlags, payload);
            }
            else
            {
                this.sendMessage(0x00, 0x7df, 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>
        public string sendMessage(uint sourceAddress, uint destinationAddress, int txFlags, byte[] payload)
        {
            IPassThruMsg txmsg = PassThruMsg.getMaskedMsg(this.protocol);

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

            string dataStr = addPayload(payload, ref txmsg);

            // Add a checksum if so requested, even though this protocol
            // normally doesn't need one. Just in case we encounter an odd
            // implementation.
            this.addChecksum(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, string.Format("0x{0:x8}", destinationAddress), dataStr + ", " + errtext);
            }

            return errtext;
        }

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

            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);
            }
        }
    }
}