//-----------------------------------------------------------------------
// <copyright file="PresentationLayer.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 SimProtocol
{
    using System;
    using System.Collections.Generic;
    using SharedObjects;
    using SharedObjects.GUI;
    using SharedObjects.Protocol;
    using SharedObjects.SimData;
    using SimProtocol.SimData;

    /// <summary>
    /// Presentation layer in the OSI stack for OBD data.
    /// <para>
    /// This handles roughly the presentation layer, not strictly.
    /// </para>
    /// </summary>
    public class PresentationLayer : IPresentationLayerToSession, IDisposable, IPresentationLayer
    {
        /// <summary>
        /// Gets Record number counter.
        /// </summary>
        public int counter
        {
            get
            {
                if (this.dataDictionary != null)
                {
                    return this.dataDictionary.counter;
                }

                return 0;
            }
        }

        /// <summary>
        /// Gets Record number counter.
        /// </summary>
        public uint scope
        {
            get
            {
                if (this.dataDictionary != null)
                {
                    return this.dataDictionary.scope;
                }

                return 0;
            }
        }

        /// <summary>
        /// Gets last encountered timestamp.
        /// </summary>
        public double timestamp
        {
            get
            {
                if (this.dataDictionary != null)
                {
                    return this.dataDictionary.timestamp;
                }

                return 0;
            }
        }

        /// <summary>
        /// Gets Dictionary of all loaded modes from file.
        /// </summary>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Reviewed, intentional")]
        public IDictionary<uint, IDictionary<uint, IDictionaryItem>> modeDictionary
        {
            get
            {
                if (this.dataDictionary != null)
                {
                    return this.dataDictionary.modeDictionary;
                }

                return null;
            }
        }

        /// <summary>
        /// Event logging instance.
        /// </summary>
        private ILogging iAppender = null;

        /// <summary>
        /// Dictionary of static response data.
        /// </summary>
        private IDataDictionary dataDictionary;

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

        /// <summary>
        /// Interface for presentation layer to call on session layer.
        /// </summary>
        private ISessionLayerToPresentation iSessionLayerToPresentation;

        /// <summary>
        /// Initializes a new instance of the <see cref="PresentationLayer" /> class.
        /// </summary>
        /// <param name="iAppender">Event log appender instance.</param>
        /// <param name="iSimEngine">Simulation engine instance.</param>
        /// <param name="iSessionLayerToPresentation">Session layer instance.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "2", Justification = "Reviewed, intentional")]
        public PresentationLayer(ILogging iAppender, ISimEngine iSimEngine, ISessionLayerToPresentation iSessionLayerToPresentation)
        {
            this.iAppender = iAppender;
            this.iSimEngine = iSimEngine;
            this.iSessionLayerToPresentation = iSessionLayerToPresentation;
            this.iSessionLayerToPresentation.addPresentationLayer(this);
        }

        /// <summary>
        /// Start replay of data from captured file.
        /// </summary>
        /// <param name="iSimEndPlay">Callback interface to call when end of replay occurs.</param>
        /// <param name="replaySpeed">Replay speed scale factor.</param>
        /// <param name="startTime">Time for start of replay.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "EndPlay", Justification = "Reviewed")]
        public void playData(ISimEndPlay iSimEndPlay, double replaySpeed, uint startTime)
        {
            this.dataDictionary.playData(iSimEndPlay, replaySpeed, startTime);
        }

        /// <summary>
        /// Start replay of data from captured file.
        /// </summary>
        public void stopData()
        {
            this.dataDictionary.stopData();
        }

        /// <summary>
        /// Load data dictionary from file with responses.
        /// </summary>
        /// <param name="dataFile">Name of file to load.</param>
        public void loadStaticData(string dataFile)
        {
            this.dataDictionary = new StaticDataDictionary(this.iAppender, dataFile);
        }

        /// <summary>
        /// Load data dictionary from file with responses.
        /// </summary>
        /// <param name="dataFile">File with data to replay.</param>
        /// <param name="srcAddr">Source address for ECU.</param>
        public void loadReplayData(string dataFile, uint srcAddr)
        {
            this.dataDictionary = new ReplayDataDictionary(this.iAppender, dataFile, srcAddr);
        }

        /// <summary>
        /// Process the payload data.
        /// </summary>
        /// <param name="address">Target address.</param>
        /// <param name="outAddress">Return address for data.</param>
        /// <param name="zLen">Data length.</param>
        /// <param name="data">Payload data.</param>
        public void processPayload(uint address, uint outAddress, uint zLen, byte[] data)
        {
            try
            {
                this.processPayloadImpl(address, outAddress, zLen, data);
            }
            catch (Exception ex)
            {
                this.iAppender.appendTextLn(ex.GetType() + ": " + ex.Message + "\r\n" + ex.StackTrace);
            }
        }

        /// <summary>
        /// Dispose the instance.
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Dispose the instance.
        /// </summary>
        /// <param name="disposing">Dispose flag.</param>
        protected virtual void Dispose(bool disposing)
        {
            this.dataDictionary.Dispose();
        }

        /// <summary>
        /// Fetch response data from database.
        /// </summary>
        /// <param name="dictionaryItem">Database dictionary item.</param>
        /// <param name="response">Response byte list.</param>
        private static void getResponseData(IDictionaryItem dictionaryItem, List<byte> response)
        {
            byte[] ba = dictionaryItem.data;
            foreach (byte b1 in ba)
            {
                response.Add(b1);
            }
        }

        /// <summary>
        /// Get the PID/Address value from received data.
        /// </summary>
        /// <param name="pidDictionary">PID dictionary to look up matching item in.</param>
        /// <param name="data">Payload data.</param>
        /// <param name="p">Data offset pointer.</param>
        /// <param name="dataFormatEngine">Data format engine instance to help with parsing.</param>
        /// <param name="response">Response byte list.</param>
        /// <param name="dictionaryItem">Dictionary item fro PID.</param>
        /// <returns>PID/Address value.</returns>
        private static uint getPidValue(
            IDictionary<uint, IDictionaryItem> pidDictionary,
            byte[] data,
            ref uint p,
            IDataFormatEngine dataFormatEngine,
            List<byte> response,
            out IDictionaryItem dictionaryItem)
        {
            uint pidValue = 0;
            uint p0 = p;

            if (dataFormatEngine.pidLen == 0)
            {
                pidValue = 0xFFFFFF;
                p++;
            }
            else
            {
                for (int i = 0; i < dataFormatEngine.pidLen; i++)
                {
                    pidValue = pidValue << 8;
                    pidValue |= data[p++];
                }
            }

            dictionaryItem = null;
            if (pidDictionary.ContainsKey(pidValue))
            {
                dictionaryItem = pidDictionary[pidValue];
            }

            if (dictionaryItem == null || dictionaryItem.echoPid == 1)
            {
                for (int i = 0; i < dataFormatEngine.pidLen; i++)
                {
                    response.Add(data[p0++]);
                }
            }

            return pidValue;
        }

        /// <summary>
        /// Process the payload data.
        /// </summary>
        /// <param name="id">Address field.</param>
        /// <param name="outAddress">Return address for data.</param>
        /// <param name="zLen">Payload data length.</param>
        /// <param name="data">Payload data.</param>
        private void processPayloadImpl(uint id, uint outAddress, uint zLen, byte[] data)
        {
            uint p = 0;
            byte mode = data[p++];

            if (this.dataDictionary.modeDictionary.ContainsKey(mode))
            {
                IDictionary<uint, IDictionaryItem> pidDictionary = this.dataDictionary.modeDictionary[mode];
                IDataFormatEngine dataFormatEngine = new DataFormatEngine(mode);

                p += dataFormatEngine.padBytes;

                List<byte> response = new List<byte>();
                response.Add((byte)(mode | 0x40));

                IDictionaryItem dictionaryItem;
                uint pidValue = getPidValue(pidDictionary, data, ref p, dataFormatEngine, response, out dictionaryItem);

                this.addIndataRow(id, data, 0, mode, pidValue, zLen);

                if (mode == 0x02)
                {
                    response.Add(data[p++]); // Frame number.
                }

                bool success = dictionaryItem != null;

                int n1 = 0;
                while (dictionaryItem != null)
                {
                    n1++;

                    getResponseData(dictionaryItem, response);

                    dictionaryItem = null;

                    // this.iAppender.appendTextLn("                                         zLen=" + zLen + ", p=" + p + ", dataFormatEngine.pidLen=" + dataFormatEngine.pidLen);
                    if (((int)zLen) - ((int)p) >= dataFormatEngine.pidLen && dataFormatEngine.pidLen > 0)
                    {
                        pidValue = getPidValue(pidDictionary, data, ref p, dataFormatEngine, response, out dictionaryItem);
                    }
                }

                if (!success)
                {
                    response.Clear();
                    response.Add(0x7f);
                    response.Add(mode);
                    response.Add(0x11);
                }

                if (success || this.iSimEngine.pidErrorCodeFlag)
                {
                    uint n = (uint)response.Count;

                    string rspStr = Utils.listToHexString(response);

                    this.iSimEngine.addRow(rowMode.presentation_out, outAddress, (byte)(mode | 0x40), pidValue, n, rspStr);

                    this.sendData(outAddress, response, n);
                }
                else
                {
                    this.iSimEngine.addRow(rowMode.data_discard, 0, 0, 0, 0, "PID: No Response sent.");
                }
            }
            else
            {
                this.modeErrorResponse(outAddress, mode);
            }
        }

        /// <summary>
        /// Send data on CAN.
        /// </summary>
        /// <param name="outAddress">Target address.</param>
        /// <param name="response">Payload data.</param>
        /// <param name="dataLen">Payload data length.</param>
        private void sendData(uint outAddress, List<byte> response, uint dataLen)
        {
            this.iSessionLayerToPresentation.sendData(outAddress, response, dataLen);
        }

        /// <summary>
        /// Add one row for incoming data.
        /// </summary>
        /// <param name="id">Address field.</param>
        /// <param name="data">Raw data array.</param>
        /// <param name="p">Offset in data array to start at.</param>
        /// <param name="mode">Mode byte value.</param>
        /// <param name="pidValue">PID/Address value.</param>
        /// <param name="zLen">Length value.</param>
        private void addIndataRow(uint id, byte[] data, uint p, byte mode, uint pidValue, uint zLen)
        {
            string inData = Utils.arrayToString(data, p);
            this.iSimEngine.addRow(rowMode.presentation_in, id, mode, pidValue, zLen, inData);
        }

        /// <summary>
        /// Prepare and send response for Mode errors.
        /// </summary>
        /// <param name="outAddress">Return address for data.</param>
        /// <param name="mode">Mode byte value.</param>
        private void modeErrorResponse(uint outAddress, byte mode)
        {
            if (this.iSimEngine.modeErrorCodeFlag)
            {
                List<byte> response = new List<byte>();

                response.Add(0x7f);
                response.Add(mode);
                response.Add(0x10);

                string rspStr = Utils.listToHexString(response);
                uint n = (uint)response.Count;

                this.iSimEngine.addRow(rowMode.presentation_out, outAddress, (byte)(mode | 0x40), 0, n, rspStr);

                this.sendData(outAddress, response, n);
            }
            else
            {
                this.iSimEngine.addRow(rowMode.data_discard, 0, 0, 0, 0, "Mode: No Response sent.");
            }
        }
    }
}