//-----------------------------------------------------------------------
// <copyright file="Protocol_Common.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.Collections.Generic;
    using global::SharedObjects;
    using global::SharedObjects.Api;
    using global::SharedObjects.GUI;
    using global::SharedObjects.Protocol;
    using global::SharedObjects.Protocol.OBD;

    /// <summary>
    /// Common functionality for all protocol implementations.
    /// </summary>
    public abstract class Protocol_Common
    {
        /// <summary>
        /// Gets Current protocol.
        /// </summary>
        public Protocols protocol { get; private set; }

        /// <summary>
        /// Gets Source address.
        /// </summary>
        public uint srcAddr { get; private set; }

        /// <summary>
        /// Gets Logging interface.
        /// </summary>
        protected ILogging iLogging { get; private set; }

        /// <summary>
        /// Gets Current message handler instance.
        /// </summary>
        protected MessageHandler messageHandler { get; private set; }

        /// <summary>
        /// Gets a value indicating whether checksum is enabled.
        /// </summary>
        protected bool checksum { get; private set; }

        /// <summary>
        /// Gets callback interface for enabling the buttons when a protocol is fully initialized.
        /// </summary>
        protected IEnableButtons iEnableButtons { get; private set; }

        /// <summary>
        /// List of registered mode parsers.
        /// </summary>
        private IList<IModeParser> modeParsers = new List<IModeParser>();

        /// <summary>
        /// Initializes a new instance of the <see cref="Protocol_Common" /> 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>
        protected Protocol_Common(
            ILogging iLogging,
            Protocols protocol,
            MessageHandler messageHandler,
            uint srcAddr,
            bool checksum,
            IEnableButtons iEnableButtons)
        {
            this.iLogging = iLogging;
            this.protocol = protocol;
            this.messageHandler = messageHandler;
            this.srcAddr = srcAddr;
            this.checksum = checksum;
            this.iEnableButtons = iEnableButtons;
        }

        /// <summary>
        /// Callback to protocol specific method of fetching the payload part.
        /// </summary>
        /// <param name="msg">Message to get payload from.</param>
        /// <returns>Payload part.</returns>
        public abstract byte[] getPayload(IPassThruMsg msg);

        /// <summary>
        /// Add a new mode parser instance.
        /// </summary>
        /// <param name="modeParser">Mode Parser Instance to add.</param>
        public void addModeParser(IModeParser modeParser)
        {
            this.modeParsers.Add(modeParser);
        }

        /// <summary>
        /// Remove mode parser instance.
        /// </summary>
        /// <param name="modeParser">Mode Parser Instance to remove.</param>
        public void removeModeParser(IModeParser modeParser)
        {
            this.modeParsers.Remove(modeParser);
        }

        /// <summary>
        /// Extract payload from message.
        /// </summary>
        /// <param name="msg">Message source.</param>
        /// <param name="dataStart">Start position for data.</param>
        /// <returns>Byte array with payload part.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed.")]
        protected static byte[] extractPayload(IPassThruMsg msg, int dataStart)
        {
            int sz = msg.DataSize - dataStart;
            byte[] payload;
            if (sz >= 0)
            {
                payload = new byte[sz];
                for (int i = 0; i < sz; i++)
                {
                    payload[i] = msg.Data[i + dataStart];
                }
            }
            else
            {
                payload = new byte[0];
            }

            return payload;
        }

        /// <summary>
        /// Dispatch received message to mode parser(s).
        /// </summary>
        /// <param name="rxmsg">Message instance.</param>
        /// <param name="payload">Message payload.</param>
        /// <param name="srcAddress">Source address of message.</param>
        /// <param name="detectedProtocol">Detected protocol by ELM/AGV adapter.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed.")]
        protected void dispatchMessage(IPassThruMsg rxmsg, byte[] payload, uint srcAddress, uint detectedProtocol)
        {
            if (payload != null && payload.Length > 0)
            {
                if (this.modeParsers == null || this.modeParsers.Count == 0)
                {
                    this.iLogging.appendText("No parser initialized yet.\r\n", LogLevel.LOG_WARN);
                }
                else
                {
                    // Skip loopback messages.
                    if ((rxmsg.RxStatus & PassThruConstants.rxflags.TX_MSG_TYPE) == 0)
                    {
                        // Distribute message to all listeners.
                        foreach (IModeParser modeParser in this.modeParsers)
                        {
                            modeParser.receiveMessageData(payload, srcAddress, detectedProtocol);
                        }
                    }
                }
            }
        }
    }
}