//-----------------------------------------------------------------------
// <copyright file="DataListForm.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 CanApp.CAN
{
    using System;
    using System.Collections;
    using System.IO;
    using System.Threading;
    using System.Windows.Forms;
    using global::DeviceApi;
    using global::SharedObjects;
    using global::SharedObjects.Api;
    using global::SharedObjects.Misc;
    using global::SharedObjects.Protocol;

    /// <summary>
    /// Form for presentation of raw CAN data frames and logging of them to file.
    /// </summary>
    public partial class DataListForm : Form, IRawReceiver
    {
        /// <summary>
        /// Logger instance.
        /// </summary>
        private ILogging iLogging;

        /// <summary>
        /// Functions instance.
        /// </summary>
        private IMiscFunc iMiscFunc;

        /// <summary>
        /// Table with known CAN addresses.
        /// </summary>
        private Hashtable addressTable = new Hashtable();

        /// <summary>
        /// Strings for seconds.
        /// </summary>
        private string secondsStr = string.Empty;

        /// <summary>
        /// Lock object to manage concurrent writes to CAN log file.
        /// </summary>
        private object lockObject = new object();

        /// <summary>
        /// Message counter.
        /// </summary>
        private long messageCounter = 0;

        /// <summary>
        /// Message handler instance.
        /// </summary>
        private IMessageHandler messageHandler;

        /// <summary>
        /// Filter Handler instance.
        /// </summary>
        private IFilterHandler filterHandler;

        /// <summary>
        /// Thread injecting test messages, only for application testing.
        /// </summary>
        private Thread testMsgThread = null;

        /// <summary>
        /// Flag indicating that the test thread shall run.
        /// </summary>
        private bool doRun;

        /// <summary>
        /// If the data in the log window shall be appended instead of refreshed for each address encountered.
        /// </summary>
        private bool appendLogging = false;

        /// <summary>
        /// Initializes a new instance of the <see cref="DataListForm" /> class.
        /// </summary>
        /// <param name="iLogging">Logger instance</param>
        /// <param name="iMiscFunc">Functions instance.</param>
        /// <param name="filterHandler">Current filter handler instance.</param>
        /// <param name="messageHandler">Message handler instance.</param>
        public DataListForm(
            ILogging iLogging,
            IMiscFunc iMiscFunc,
            IFilterHandler filterHandler,
            IMessageHandler messageHandler)
        {
            this.iLogging = iLogging;
            this.iMiscFunc = iMiscFunc;
            this.filterHandler = filterHandler;
            this.messageHandler = messageHandler;

            this.InitializeComponent();

            this.appendLoggingCB.Checked = this.appendLogging;

            this.messageHandler.setRawReceiver(this);
        }

        /// <summary>
        /// Receive one message from the message handler.
        /// </summary>
        /// <param name="rxmsg">Received message.</param>
        /// <returns>Return false to inhibit further processing.</returns>
        public bool rawHandler(IPassThruMsg rxmsg)
        {
            this.dispMsg(this.messageCounter++, rxmsg);

            // We are the only one receiving these messages.
            return false;
        }

        /// <summary>
        /// Add data to the trace data data grid view table.
        /// </summary>
        /// <param name="counter">Counter value.</param>
        /// <param name="timestamp">Timestamp value.</param>
        /// <param name="msgIdStr">Message ID (Address)</param>
        /// <param name="valueData">Data String.</param>
        /// <param name="dataSize1">Data size value.</param>
        /// <param name="extraDataIndex1">Index of extra data.</param>
        /// <returns>'true' if successful.</returns>
        private bool setData(long counter, string timestamp, string msgIdStr, string valueData, int dataSize1, int extraDataIndex1)
        {
            bool success = false;
            if (this.InvokeRequired)
            {
                try
                {
                    success = (bool)Invoke(new setDataFunc(this.setData), new object[] { counter, timestamp, msgIdStr, valueData, dataSize1, extraDataIndex1 });
                }
                catch (System.Reflection.TargetParameterCountException ex)
                {
                    MessageBox.Show(
                        "Exception: " + ex.Message + "\r\nmsgIdStr='" + msgIdStr + "'",
                        "Error",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Stop);
                }
                catch (System.ObjectDisposedException)
                {
                    // Ignore.
                }
            }
            else
            {
                try
                {
                    DataGridViewRowCollection dgvrc = this.tracedata.Rows;
                    if (dgvrc.Count > 1000)
                    {
                        dgvrc.RemoveAt(0);
                    }

                    int n = 0;
                    if (!this.appendLogging && this.addressTable.ContainsKey(msgIdStr))
                    {
                        n = (int)this.addressTable[msgIdStr];
                    }
                    else
                    {
                        n = dgvrc.Add(1);
                        if (!this.appendLogging)
                        {
                            this.addressTable.Add(msgIdStr, n);
                        }
                    }

                    DataGridViewRow dgvr = dgvrc[n];
                    DataGridViewCellCollection dgvcc = dgvr.Cells;
                    dgvcc[0].Value = counter;
                    dgvcc[1].Value = timestamp;
                    dgvcc[2].Value = msgIdStr;
                    dgvcc[3].Value = dataSize1.ToString("x2");
                    dgvcc[4].Value = extraDataIndex1.ToString("x2");
                    dgvcc[5].Value = valueData;
                    success = true;
                }
                catch
                {
                }
            }

            return success;
        }

        /// <summary>
        /// Handle closing of form.
        /// </summary>
        /// <param name="sender">Trig object.</param>
        /// <param name="e">Event data.</param>
        private void DataListForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            this.stopHandler();
        }

        /// <summary>
        /// Add data to the trace data data grid view table.
        /// </summary>
        /// <param name="counter">Counter value.</param>
        /// <param name="timestamp">Timestamp value.</param>
        /// <param name="msgIdStr">Message ID (Address)</param>
        /// <param name="valueData">Data String.</param>
        /// <param name="dataSize">Data size value.</param>
        /// <param name="extraDataIndex">Index of extra data.</param>
        /// <returns>'true' if successful.</returns>
        private delegate bool setDataFunc(long counter, string timestamp, string msgIdStr, string valueData, int dataSize, int extraDataIndex);

        /// <summary>
        /// Display one message.
        /// </summary>
        /// <param name="msgCount">Message counter.</param>
        /// <param name="rxmsg">Message to display.</param>
        /// <returns>Indicates if the action was a success.</returns>
        private bool dispMsg(long msgCount, IPassThruMsg rxmsg)
        {
            bool success = false;
            if ((rxmsg.RxStatus & PassThruConstants.rxflags.START_OF_MESSAGE) != 0)
            {
                return true;
            }

            if (rxmsg.DataSize >= 4)
            {
                int msgId = 0;
                string timestamp = rxmsg.Timestamp.ToString();
                string msgIdStr = string.Empty;
                for (int i = 0; i < 4; i++)
                {
                    msgId = msgId << 8 | (int)(rxmsg.Data[i] & 0xff);
                    msgIdStr += string.Format("{0:x2} ", (int)(rxmsg.Data[i] & 0xff));
                }

                string rxData = string.Empty;
                for (int i = 4; i < rxmsg.DataSize; i++)
                {
                    if (i > 4)
                    {
                        rxData += " ";
                    }

                    rxData += string.Format("{0:x2}", (int)(rxmsg.Data[i] & 0xff));
                }

                success = this.setData(msgCount, timestamp, msgIdStr, rxData, rxmsg.DataSize, rxmsg.ExtraDataIndex);
                if (success)
                {
                    TextWriter out1 = this.iLogging.getCanDataLogWriter();
                    if (out1 != null)
                    {
                        long t1 = DateTime.Now.Ticks;
                        this.secondsStr = this.iMiscFunc.getSecondsStr(t1);

                        // Make sure that we don't get mixed data.
                        lock (this.lockObject)
                        {
                            out1.Write(this.secondsStr);
                            out1.Write(" 1  "); // CAN Channel number, always 1.
                            out1.Write(string.Format("{0:x}", msgId).PadRight(16, ' '));
                            out1.Write("Tx   "); // Always 'Tx' for now.
                            out1.Write("d "); // 'd' for Data.
                            out1.Write(string.Format("{0:x}", rxmsg.DataSize - 4) + " "); // Number of data bytes.
                            out1.WriteLine(rxData); // Data
                            out1.Flush(); // If we crash.
                        }
                    }
                }
            }

            return success;
        }

        /// <summary>
        /// Handle a button click.
        /// </summary>
        /// <param name="sender">Sending button.</param>
        /// <param name="e">Event data.</param>
        private void addTxtBT_Click(object sender, EventArgs e)
        {
            TextWriter out1 = this.iLogging.getCanDataLogWriter();
            if (out1 != null)
            {
                // Make sure that we don't get mixed data.
                lock (this.lockObject)
                {
                    out1.WriteLine(this.secondsStr + "    Comment: 0 " + this.textBox1.Text); // Should work in ASC file, needs to be tested.
                }
            }
        }

        /// <summary>
        /// Handle a button click.
        /// </summary>
        /// <param name="sender">Sending button.</param>
        /// <param name="e">Event data.</param>
        private void startBT_Click(object sender, EventArgs e)
        {
            this.filterHandler.setRawLoggerFilter();

            this.messageHandler.startThread();

            this.iLogging.appendText("Thread started.\r\n");

            this.startBT.Enabled = false;
            this.stopBT.Enabled = true;
        }

        /// <summary>
        /// Handle a button click.
        /// </summary>
        /// <param name="sender">Sending button.</param>
        /// <param name="e">Event data.</param>
        private void stopBT_Click(object sender, EventArgs e)
        {
            this.stopHandler();

            this.iLogging.appendText("Thread stopped.\r\n");

            this.startBT.Enabled = true;
            this.stopBT.Enabled = false;
        }

        /// <summary>
        /// Handle shut down of module.
        /// </summary>
        private void stopHandler()
        {
            this.messageHandler.stopThread();
        }

        /// <summary>
        /// Insert a test message.
        /// <para>
        /// In reality only useful for development of the application.
        /// </para>
        /// </summary>
        /// <param name="e1">Counter value.</param>
        /// <param name="timeout">Timeout value.</param>
        private void testMessage(long e1, int timeout)
        {
            IPassThruMsg rxmsg1 = PassThruMsg.getMaskedMsg(Protocols.CAN);
            rxmsg1.Timestamp = 1663505644;
            rxmsg1.DataSize = 7;
            Random random = new Random();
            int randomNumber = random.Next(0, 6);

            rxmsg1.Data[3] = (byte)(randomNumber);
            rxmsg1.Data[4] = (byte)1;
            rxmsg1.Data[5] = (byte)2;
            rxmsg1.Data[6] = (byte)3;
            this.dispMsg(e1, rxmsg1);
            Thread.Sleep(timeout);

            return;
        }

        /// <summary>
        /// Thread that generates test messages.
        /// </summary>
        private void testThread()
        {
            this.doRun = true;
            long e1 = 0;
            while (this.doRun)
            {
                int timeout = (int)this.timeoutUD.Value;
                this.testMessage(e1++, timeout);
            }
        }

        /// <summary>
        /// Handle checkbox change.
        /// </summary>
        /// <param name="sender">Sender object.</param>
        /// <param name="e">Event data.</param>
        private void testCB_CheckedChanged(object sender, EventArgs e)
        {
            CheckBox cb = (CheckBox)sender;
            if (cb.Checked)
            {
                this.testMsgThread = new Thread(new ThreadStart(this.testThread));
                this.testMsgThread.Name = "Test Msg";
                this.testMsgThread.Start();
            }
            else
            {
                this.doRun = false;
                this.testMsgThread.Abort();
                this.testMsgThread.Interrupt();
                this.testMsgThread.Join(4000);
                this.testMsgThread = null;
            }
        }

        /// <summary>
        /// Handle changes of the checkbox state.
        /// </summary>
        /// <param name="sender">Sender object.</param>
        /// <param name="e">Event data.</param>
        private void appendLoggingCB_CheckedChanged(object sender, EventArgs e)
        {
            this.appendLogging = this.appendLoggingCB.Checked;
        }
    }
}