//-----------------------------------------------------------------------
// <copyright file="ProbePidsPanel.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 UserInterface.GUI.OBD
{
    using System;
    using System.ComponentModel;
    using System.Drawing;
    using System.IO;
    using System.Threading;
    using System.Windows.Forms;
    using global::Protocol.OBD;
    using global::SharedObjects;
    using global::SharedObjects.DataMgmt;
    using global::SharedObjects.GUI;
    using global::SharedObjects.Misc;
    using global::SharedObjects.Misc.Objects;
    using global::SharedObjects.Protocol;
    using global::SharedObjects.Protocol.OBD;

    /// <summary>
    /// Panel for probing of possible PID values in a Mode.
    /// </summary>
    public partial class ProbePidsPanel : AbstractUserControl, IDataPanel
    {
        /// <summary>
        /// Color for items that was detected with a decent response.
        /// </summary>
        private static readonly Color OK_COLOR = Color.LightGreen;

        /// <summary>
        /// Color for items that did an error response.
        /// </summary>
        private static readonly Color ERR_COLOR = Color.LightPink;

        /// <summary>
        /// Color for items that timed out.
        /// </summary>
        private static readonly Color TIMEOUT_COLOR = Color.LightYellow;

        /// <summary>
        /// Thread for probing.
        /// </summary>
        private Thread probeThread = null;

        /// <summary>
        /// Flag to indicate if thread shall be executing.
        /// </summary>
        private bool doRun = true;

        /// <summary>
        /// Lock object for synchronizing.
        /// </summary>
        private object lockObject = new object();

        /// <summary>
        /// Timeout flag.
        /// </summary>
        private bool timeout = true;

        /// <summary>
        /// Error flag.
        /// </summary>
        private bool error = false;

        /// <summary>
        /// Messaging interface instance.
        /// </summary>
        private IMessaging iMessaging;

        /// <summary>
        /// Data source instance.
        /// </summary>
        private IDataSource iDataSource;

        /// <summary>
        /// Mode parser instance.
        /// </summary>
        private ModeParser modeParser;

        /// <summary>
        /// Current mode.
        /// </summary>
        private byte mode = 0x00;

        /// <summary>
        /// First PID to scan.
        /// </summary>
        private uint startPid = 0x00;

        /// <summary>
        /// Last PID to scan.
        /// </summary>
        private uint endPid = 0x00;

        /// <summary>
        /// Mode value valid.
        /// </summary>
        private bool modeValid = false;

        /// <summary>
        /// Start PID valid.
        /// </summary>
        private bool startValid = false;

        /// <summary>
        /// End PID valid.
        /// </summary>
        private bool endValid = false;

        /// <summary>
        /// Flag indicating that all items shall be displayed regardless of they are found or not.
        /// </summary>
        private bool showAll = false;

        /// <summary>
        /// Initializes a new instance of the <see cref="ProbePidsPanel" /> class.
        /// </summary>
        /// <param name="iLogging">Event logging instance.</param>
        /// <param name="vehicle">Current Vehicle.</param>
        /// <param name="applicationTree">Current Application Tree instance.</param>
        /// <param name="iMessaging">Messaging interface instance.</param>
        /// <param name="iDataSource">Data source instance.</param>
        /// <param name="modeParser">Mode parser instance.</param>
        public ProbePidsPanel(
            ILogging iLogging,
            XmlClass.vehicle vehicle,
            IApplicationTree applicationTree,
            IMessaging iMessaging,
            IDataSource iDataSource,
            ModeParser modeParser)
            : base(iLogging, vehicle, applicationTree)
        {
            this.iMessaging = iMessaging;
            this.iDataSource = iDataSource;
            this.modeParser = modeParser;

            this.InitializeComponent();

            this.showAll = this.showCheckbox.Checked;

            foreach (XmlClass.modeitem modeitem in this.iDataSource.modes)
            {
                this.modeComboBox.Items.Add("0x" + modeitem.mode_int.ToString("x2") + " " + modeitem.name);
            }
        }

        /// <summary>
        /// Perform parsing of data.
        /// </summary>
        /// <param name="mode">Message mode.</param>
        /// <param name="payload">Actual data payload.</param>
        /// <param name="requestData">Related transmitted message to help with parsing.</param>
        /// <param name="popNext">Pop next request and send.</param>
        /// <param name="srcAddress">Source address of received data.</param>
        /// <param name="detectedProtocol">Detected protocol by ELM/AGV adapter.</param>
        /// <returns>'true' if successfully parsed by panel.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "payload", Justification = "Reviewed.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "mode", Justification = "Reviewed.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "error", Justification = "Reviewed.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1045:DoNotPassTypesByReference", MessageId = "3#", Justification = "Reviewed.")]
        public bool parse(uint mode, byte[] payload, IRequestData requestData, ref bool popNext, uint srcAddress, uint detectedProtocol)
        {
#if TRACE
            this.iLogging.appendText("mode=0x" + mode.ToString("x2") + "\r\n");
#endif

            bool error = false;
            if (mode == 0x7f)
            {
                error = true;
            }
            else
            {
            }

            lock (this.lockObject)
            {
                this.error = error;
                this.timeout = false;
                Monitor.PulseAll(this.lockObject);
            }

            return true;
        }

        /// <summary>
        /// Start button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void startButton_Click(object sender, EventArgs e)
        {
            this.startButtonEnabled(false);
            this.stopButtonEnabled(true);
            this.modeParser.probePids = true;
            this.listView1.Items.Clear();

            this.probeThread = new Thread(this.probeThreadImpl);
            this.doRun = true;

            this.probeThread.Start();
        }

        /// <summary>
        /// Stop button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void stopButton_Click(object sender, EventArgs e)
        {
            this.stopButtonEnabled(false);
            this.doRun = false;
            this.probeThread.Abort();
            this.probeThread.Interrupt();
            this.probeThread.Join(4000);
            this.startButtonEnabled(true);
            this.modeParser.probePids = false;
        }

        /// <summary>
        /// Implementation of Thread for probing.
        /// </summary>
        private void probeThreadImpl()
        {
            foreach (XmlClass.modeitem modeitem in this.iDataSource.modes)
            {
                if (modeitem.mode_int == this.mode)
                {
                    for (uint i = this.startPid; i <= this.endPid && this.doRun; i++)
                    {
                        XmlClass.pidgroup.pidlist pid = new XmlClass.pidgroup.pidlist();
                        pid.name = "PID 0x" + i.ToString("x2");
                        pid.pidIsMap = false;
                        pid.plotHeight = 150;
                        pid.refresh = "1:1";
                        pid.pid_int = i;

                        RequestData msg;

                        switch (this.mode)
                        {
                            case 0x02:
                                msg = new RequestData(null, (byte)this.mode, pid, new TxMsg(new byte[] { (byte)this.mode, (byte)(pid.pid_int & 0xff), 0x00 }));
                                break;
                            case 0x22:
                                msg = new RequestData(null, (byte)this.mode, pid, new TxMsg(new byte[] { (byte)this.mode, (byte)((pid.pid_int >> 8) & 0xff), (byte)(pid.pid_int & 0xff) }));
                                break;
                            case 0xa0:
                                msg = new RequestData(null, (byte)this.mode, pid, new TxMsg(new byte[] { (byte)this.mode, 0x00, (byte)((pid.pid_int >> 16) & 0xff), (byte)((pid.pid_int >> 8) & 0xff), (byte)(pid.pid_int & 0xff), (byte)(pid.pid_bytes) }));
                                break;
                            case 0xa8:
                                msg = new RequestData(null, (byte)this.mode, pid, new TxMsg(new byte[] { (byte)this.mode, 0x00, (byte)((pid.pid_int >> 16) & 0xff), (byte)((pid.pid_int >> 8) & 0xff), (byte)(pid.pid_int & 0xff) }));
                                break;
                            default:
                                msg = new RequestData(null, (byte)this.mode, pid, new TxMsg(new byte[] { (byte)this.mode, (byte)(pid.pid_int & 0xff) }));
                                break;
                        }

                        this.iMessaging.queueMsg(msg);
                        this.iMessaging.sendMsg();

                        lock (this.lockObject)
                        {
                            this.timeout = true;

                            Monitor.Wait(this.lockObject, 200);

                            ListViewItem listViewItem = new ListViewItem();

                            if (!this.timeout)
                            {
                                if (!this.error)
                                {
                                    listViewItem.BackColor = OK_COLOR;
                                    listViewItem.Text = "A 0x" + i.ToString("x2");
                                }
                                else
                                {
                                    listViewItem.BackColor = ERR_COLOR;
                                    listViewItem.Text = "E 0x" + i.ToString("x2");
                                }
                            }
                            else
                            {
                                listViewItem.BackColor = TIMEOUT_COLOR;
                                listViewItem.Text = "N 0x" + i.ToString("x2");
                            }

                            if (this.showAll || (!this.error && !this.timeout))
                            {
                                this.addItem(listViewItem);
                            }
                        }
                    }
                }

                if (!this.doRun)
                {
                    break;
                }
            }

            Thread.Sleep(1000);

            this.stopButtonEnabled(false);
            this.startButtonEnabled(true);
            this.modeParser.probePids = false;
        }

        /// <summary>
        /// Set Stop Button enable state.
        /// </summary>
        /// <param name="enabled">'true' if set to enabled.</param>
        private delegate void stopButtonEnabledFunc(bool enabled);

        /// <summary>
        /// Set Stop Button enable state.
        /// </summary>
        /// <param name="enabled">'true' if set to enabled.</param>
        private void stopButtonEnabled(bool enabled)
        {
            if (this.InvokeRequired)
            {
                try
                {
                    this.Invoke(new stopButtonEnabledFunc(this.stopButtonEnabled), new object[] { enabled });
                }
                catch (System.Reflection.TargetParameterCountException ex)
                {
                    MessageBox.Show(
                        "Exception: " + ex.Message + "\r\n",
                        "Error",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Stop);
                }
                catch (System.ObjectDisposedException)
                {
                    // Ignore.
                }
            }
            else
            {
                this.stopButton.Enabled = enabled;
            }
        }

        /// <summary>
        /// Add one item to the List View.
        /// </summary>
        /// <param name="listViewItem">Item to add.</param>
        private delegate void addItemFunc(ListViewItem listViewItem);

        /// <summary>
        /// Add one item to the List View.
        /// </summary>
        /// <param name="listViewItem">Item to add.</param>
        private void addItem(ListViewItem listViewItem)
        {
            if (this.InvokeRequired)
            {
                try
                {
                    this.Invoke(new addItemFunc(this.addItem), new object[] { listViewItem });
                }
                catch (System.Reflection.TargetParameterCountException ex)
                {
                    MessageBox.Show(
                        "Exception: " + ex.Message + "\r\n",
                        "Error",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Stop);
                }
                catch (System.ObjectDisposedException)
                {
                    // Ignore.
                }
            }
            else
            {
                this.listView1.Items.Add(listViewItem);
            }
        }

        /// <summary>
        /// Selected index in Mode combo box updated.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void modeComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox tb = (ComboBox)sender;
            if (tb.Text.Trim().Length > 0)
            {
                try
                {
                    this.mode = (byte)Utils.hexParse(tb.Text);
                    this.modeValid = true;
                    this.startButtonEnabled(true);
                }
                catch
                {
                }
            }
        }

        /// <summary>
        /// Validate range start value.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void rangeStartTB_Validating(object sender, CancelEventArgs e)
        {
            TextBox tb = (TextBox)sender;
            if (tb.Text.Trim().Length > 0)
            {
                try
                {
                    this.startPid = Utils.hexParse(tb.Text);
                    this.startValid = true;
                    this.startButtonEnabled(true);
                }
                catch (Exception ex)
                {
                    if (MessageBox.Show(
                        "Invalid data '" + tb.Text + "'\r\n" + ex.Message,
                        "Error",
                        MessageBoxButtons.OKCancel,
                        MessageBoxIcon.Hand) == DialogResult.OK)
                    {
                        e.Cancel = true;
                        tb.BackColor = Color.LightPink;
                    }
                    else
                    {
                        tb.Text = string.Empty;
                    }
                }
            }
        }

        /// <summary>
        /// Validate range end value.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void rangeEndTB_Validating(object sender, CancelEventArgs e)
        {
            TextBox tb = (TextBox)sender;
            if (tb.Text.Trim().Length > 0)
            {
                try
                {
                    this.endPid = Utils.hexParse(tb.Text);
                    this.endValid = true;
                    this.startButtonEnabled(true);
                }
                catch (Exception ex)
                {
                    if (MessageBox.Show(
                        "Invalid data '" + tb.Text + "'\r\n" + ex.Message,
                        "Error",
                        MessageBoxButtons.OKCancel,
                        MessageBoxIcon.Hand) == DialogResult.OK)
                    {
                        e.Cancel = true;
                        tb.BackColor = Color.LightPink;
                    }
                    else
                    {
                        tb.Text = string.Empty;
                    }
                }
            }
        }

        /// <summary>
        /// Set Start button enabled.
        /// </summary>
        /// <param name="enabled">'true' if enabled.</param>
        private delegate void startButtonEnabledFunc(bool enabled);

        /// <summary>
        /// Set Start button enabled.
        /// </summary>
        /// <param name="enabled">'true' if enabled.</param>
        private void startButtonEnabled(bool enabled)
        {
            if (this.InvokeRequired)
            {
                try
                {
                    this.Invoke(new startButtonEnabledFunc(this.startButtonEnabled), new object[] { enabled });
                }
                catch (System.Reflection.TargetParameterCountException ex)
                {
                    MessageBox.Show(
                        "Exception: " + ex.Message + "\r\n",
                        "Error",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Stop);
                }
                catch (System.ObjectDisposedException)
                {
                    // Ignore.
                }
            }
            else
            {
                this.startButton.Enabled = enabled && this.endValid && this.startValid && this.modeValid;
                this.saveButton.Enabled = this.startButton.Enabled && this.listView1.Items.Count > 0;
            }
        }

        /// <summary>
        /// Save button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "Reviewed.")]
        private void saveButton_Click(object sender, EventArgs e)
        {
            this.saveFileDialog1.FileName = string.Empty;
            this.saveFileDialog1.DefaultExt = ".txt";
            this.saveFileDialog1.AddExtension = true;
            this.saveFileDialog1.ValidateNames = true;
            this.saveFileDialog1.Filter = "Text File|*.txt";

            if (this.saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                if (!string.IsNullOrEmpty(this.saveFileDialog1.FileName))
                {
                    System.IO.FileStream fileStream = null;
                    StreamWriter streamWriter = null;
                    try
                    {
                        fileStream = (System.IO.FileStream)this.saveFileDialog1.OpenFile();
                        streamWriter = new StreamWriter(fileStream, Utils.iso_8859_1);
                        foreach (ListViewItem listViewItem in this.listView1.Items)
                        {
                            streamWriter.WriteLine(listViewItem.Text);
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(
                            ex.Message,
                            "Error",
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Stop);
                    }
                    finally
                    {
                        if (streamWriter != null)
                        {
                            try
                            {
                                streamWriter.Close();
                            }
                            catch
                            {
                            }
                        }

                        if (fileStream != null)
                        {
                            try
                            {
                                fileStream.Close();
                            }
                            catch
                            {
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Checkbox for "Show All" changed state.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void showCheckbox_CheckedChanged(object sender, EventArgs e)
        {
            CheckBox cb = (CheckBox)sender;
            this.showAll = cb.Checked;
        }
    }
}