//-----------------------------------------------------------------------
// <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 DataParser : IDataParser
    {
        /// <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>
        /// Checksum Byte.
        /// </summary>
        private byte checkSum = 0;

        /// <summary>
        /// Next byte shall be checksum.
        /// </summary>
        private bool dataComplete = false;

        /// <summary>
        /// Event logging instance.
        /// </summary>
        private ILogging iLogging;

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

        /// <summary>
        /// Data bytes to expect for complete command.
        /// </summary>
        private int dataBytes = 0;

        /// <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>
        /// Data packet logging.
        /// </summary>
        private IDataLogging iDataLogging;

        /// <summary>
        /// Session layer list.
        /// </summary>
        private IList<ISessionLayer> iSessionLayerList;

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

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

        /// <summary>
        /// Handle dispose of object.
        /// </summary>
        /// <param name="disposing"></param>
        public void Dispose(bool disposing)
        {
        }

        /// <summary>
        /// Parse data.
        /// </summary>
        /// <param name="ch">Character to use in parser.</param>
        public void parse(byte ch)
        {
            this.dataRecord.Add(ch);
            if (this.expectChecksum && this.dataComplete)
            {
                if (this.checkSum != ch)
                {
                    this.iLogging.appendText("Invalid checksum, calculated=0x" + this.checkSum.ToString("x2") + ", expected=0x" + ch.ToString("x2"));
                }
                else
                {
                    this.activateServiceParser();
                }
            }
            else
            {
                this.checkSum += ch;
                if (this.buf.Length == 0 && ch == 0x68)
                {
                    this.checkSum = ch;
                    this.buf += ch.ToString("X2");
                }
                else
                {
                    if (this.buf.Length == 2 && ch == 0x6a)
                    {
                        this.buf += ch.ToString("X2");
                    }
                    else
                    {
                        if (this.buf.Length == 4 && ch == 0xf1)
                        {
                            this.buf += ch.ToString("X2");
                        }
                        else
                        {
                            if (this.buf.Length >= 6)
                            {
                                this.buf += ch.ToString("X2");
                                this.rxData.Add(ch);

                                if (this.dataBytes == 0)
                                {
                                    this.selectService(ch);
                                }

                                if (this.buf.Length == ((this.dataBytes * 2) + 6))
                                {
                                    this.dataComplete = true;
                                }
                            }
                            else
                            {
                                this.buf = string.Empty;
                                this.rxData.Clear();
                                this.dataBytes = 0;
                                this.dataComplete = false;
                            }
                        }
                    }
                }

                if (!this.expectChecksum && this.dataComplete)
                {
                    this.activateServiceParser();
                }
            }
        }

        /// <summary>
        /// Select service depending on byte value.
        /// </summary>
        /// <param name="ch">Service to select.</param>
        private void selectService(byte ch)
        {
            switch (ch)
            {
                case 0x01:
                    this.dataBytes = 2;
                    break;

                case 0x02:
                    this.dataBytes = 3;
                    break;

                case 0x03:
                    this.dataBytes = 1;
                    break;

                case 0x04:
                    this.dataBytes = 1;
                    break;

                case 0x05:
                    this.dataBytes = 3;
                    break;

                case 0x06:
                    this.dataBytes = 2;
                    break;

                case 0x07:
                    this.dataBytes = 1;
                    break;

                case 0x08:
                    this.dataBytes = 7;
                    break;

                case 0x09:
                    this.dataBytes = 2;
                    break;

                case 0x0a:
                    this.dataBytes = 1;
                    break;

                case 0x22:
                    this.dataBytes = 3;
                    break;

                case 0xAA:
                    this.dataBytes = 1;
                    break;

                default:
                    this.buf = string.Empty;
                    this.rxData.Clear();
                    this.dataBytes = 0;
                    this.dataComplete = false;
                    break;
            }
        }

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

                foreach (ISessionLayer sessionLayer in this.iSessionLayerList)
                {
                    sessionLayer.receiveData(0x00, payload, 0x00, 0x00, 0x00);
                }
            }

            this.buf = string.Empty;
            this.rxData.Clear();
            this.dataBytes = 0;
            this.dataComplete = false;
        }
    }
}