//-----------------------------------------------------------------------
// <copyright file="DataParser.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 ObdSimulator.Protocol
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using global::SharedObjects;
    using global::SharedObjects.Protocol;

    /// <summary>
    /// Implements the ISO9141 protocol.
    /// </summary>
    public class SerialSessionLayer : AbstractSessionLayer
    {
        /// <summary>
        /// Data buffer.
        /// </summary>
        private string buf = string.Empty;

        /// <summary>
        /// Received data without header (payload part).
        /// </summary>
        private List<byte> rxData = new List<byte>();

        /// <summary>
        /// Event logging instance.
        /// </summary>
        private IDataLogging iDataLogging;

        /// <summary>
        /// 'true' if checksum shall be expected.
        /// </summary>
        private bool expectChecksum;

        /// <summary>
        /// List of received data bytes.
        /// </summary>
        private List<byte> dataRecord = new List<byte>();

        /// <summary>
        /// Array of transmitted data.
        /// </summary>
        private byte[] txDataArray = null;

        /// <summary>
        /// Lock object to avoid race conditions.
        /// </summary>
        private object lockObject = new object();

        /// <summary>
        /// List of data receivers.
        /// </summary>
        private IList<IPresentationLayerToSession> iPresentationLayerList = new List<IPresentationLayerToSession>();

        /// <summary>
        /// Communicator instance.
        /// </summary>
        private IObdCommunicator iObdCommunicator;

        /// <summary>
        /// Simulation engine instance.
        /// </summary>
        private ISimEngine iSimEngine;

        /// <summary>
        /// Initializes a new instance of the <see cref="DataParser" /> class.
        /// </summary>
        /// <param name="iDataLogging">Event logging instance.</param>
        /// <param name="expectChecksum">'true' if checksum shall be expected.</param>
        /// <param name="iDataTransmitter">Data transmitter instance.</param>
        public SerialSessionLayer(IDataLogging iDataLogging, bool expectChecksum)
        {
            this.iDataLogging = iDataLogging;
            this.expectChecksum = expectChecksum;
        }

        /// <summary>
        /// Set the simulation engine.
        /// </summary>
        /// <param name="iSimEngine">Simulation engine instance.</param>
        public override void setSimEngine(ISimEngine iSimEngine)
        {
            this.iSimEngine = iSimEngine;
        }

        /// <summary>
        /// Handle dispose of object.
        /// </summary>
        public override void Dispose()
        {
            this.Dispose(true);
        }

        /// <summary>
        /// Handle dispose of object.
        /// </summary>
        /// <param name="disposing"></param>
        public void Dispose(bool disposing)
        {
            if (this.iPresentationLayerList != null)
            {
                this.iPresentationLayerList.Clear();
            }
        }

        /// <summary>
        /// Send data.
        /// </summary>
        /// <param name="id">Target address.</param>
        /// <param name="payload">Data to send.</param>
        public override void sendData(uint outAddress, IList<byte> response, uint dataLen)
        {
            if (response != null)
            {
                if (this.iSimEngine != null)
                {
                    this.iSimEngine.addRow(rowMode.session_out, outAddress, 0, 0, 0, Utils.listToHexString(response));
                }

                byte[] payload = ((List<byte>)response).ToArray();

                this.iObdCommunicator.send(outAddress, payload);
            }
        }

        /// <summary>
        /// Set CAN bus communicator instance.
        /// </summary>
        /// <param name="iObdCommunicator">CAN bus communicator instance.</param>
        public override void setObdCommunicator(IObdCommunicator iObdCommunicator)
        {
            if (iObdCommunicator == null && this.iObdCommunicator != null)
            {
                this.iObdCommunicator.removeDataReceiver(this);
            }

            this.iObdCommunicator = iObdCommunicator;

            if (iObdCommunicator != null)
            {
                this.iObdCommunicator.addDataReceiver(this);
            }
        }

        /// <summary>
        /// Receive one data packet.
        /// </summary>
        /// <param name="id">Address value.</param>
        /// <param name="data0">Payload data.</param>
        /// <param name="flags">Flags value.</param>
        /// <param name="res1">RES1 Value.</param>
        /// <param name="res2">RES2 Value.</param>
        public override void receiveData(uint id, byte[] data0, ushort flags, ulong res1, ulong res2)
        {
            if (this.iSimEngine != null)
            {
                this.iSimEngine.addRow(rowMode.transport_in, id, 0x00, 0, 0, Utils.arrayToString(data0, 0) + ", flags=0x" + flags.ToString("X2") + ", res1=0x" + res1.ToString("X2") + ", res2=0x" + res2.ToString("X2"));
            }

            foreach (IPresentationLayerToSession dataRx in this.iPresentationLayerList)
            {
                dataRx.processPayload(id, 0x00, (uint)data0.Length, data0);
            }
        }

        /// <summary>
        /// Unregister as a data receiver instance
        /// </summary>
        /// <param name="iDataReceiver">Data receiver instance.</param>
        public override void removePresentationLayer(IPresentationLayerToSession iDataReceiver)
        {
            if (this.iPresentationLayerList.Contains(iDataReceiver))
            {
                this.iPresentationLayerList.Remove(iDataReceiver);
            }
        }

        /// <summary>
        /// Register as a data receiver instance
        /// </summary>
        /// <param name="iDataReceiver">Data receiver instance.</param>
        public override void addPresentationLayer(IPresentationLayerToSession iDataReceiver)
        {
            if (!this.iPresentationLayerList.Contains(iDataReceiver))
            {
                this.iPresentationLayerList.Add(iDataReceiver);
            }
        }

        /// <summary>
        /// Activate service parser and parse payload data.
        /// </summary>
        private void activateServiceParser()
        {
            byte[] ba = this.dataRecord.ToArray<byte>();
            this.dataRecord.Clear();

            lock (this.lockObject)
            {
                if (this.txDataArray != null)
                {
                    int n = ba.Length - this.txDataArray.Length;
                    if (n > 0)
                    {
                        byte[] ba2 = new byte[n];
                        Array.Copy(ba, this.txDataArray.Length, ba2, 0, n);
                        ba = ba2;
                    }
                }

                this.iDataLogging.appendRow("In", ba);
            }

            if (this.rxData.Count > 0)
            {
                byte[] payload = this.rxData.ToArray();
                byte[] ba2 = new byte[payload.Length + 1];
                Array.Copy(payload, 0, ba2, 1, payload.Length);
                ba2[0] = (byte)payload.Length;

                this.receiveData(0x00, ba2, 0x00, 0x00, 0x00);
            }

            this.buf = string.Empty;
            this.rxData.Clear();
        }
    }
}