//-----------------------------------------------------------------------
// <copyright file="CurrentDataPanel.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.Collections.Generic;
    using System.Globalization;
    using System.IO;
    using System.Windows.Forms;
    using System.Windows.Forms.DataVisualization.Charting;
    using global::DataSource.FileAccess;
    using global::Protocol.OBD;
    using global::SharedObjects;
    using global::SharedObjects.DataMgmt;
    using global::SharedObjects.GUI;
    using global::SharedObjects.GUI.OBD;
    using global::SharedObjects.Misc;
    using global::SharedObjects.Misc.Objects;
    using global::SharedObjects.Protocol;
    using global::SharedObjects.Protocol.OBD;
    using global::UserInterface.GUI.Objects;

    /// <summary>
    /// Panel for presentation of snapshot data items.
    /// </summary>
    public partial class CurrentDataPanel : AbstractUserControl, IDataPresentation, IProgressFeedback
    {
        /// <summary>
        /// Gets OBD data panel instance.
        /// </summary>
        public ObdDataPanel obdDataPanel
        {
            get
            {
                return this.obdDataPanel1;
            }
        }

        /// <summary>
        /// Gets poll interval when plotting.
        /// </summary>
        private int pollInterval;

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

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

        /// <summary>
        /// Data requester instance.
        /// </summary>
        private DataRequester dataRequester;

        /// <summary>
        /// Indicate if plotting is checked.
        /// </summary>
        private bool plotting = false;

        /// <summary>
        /// Indicate if logging is checked.
        /// </summary>
        private bool logging = false;

        /// <summary>
        /// Start time point for logging/plotting to get relative time.
        /// <para>
        /// Value is in milliseconds.
        /// </para>
        /// </summary>
        private long t0 = 0;

        /// <summary>
        /// Dictionary of plot panels.
        /// </summary>
        private SortedDictionary<uint, PanelTreeNode> plotPanels = new SortedDictionary<uint, PanelTreeNode>();

        /// <summary>
        /// Preferences data.
        /// </summary>
        private IPreferences iPreferences;

#if DEBUG1
        /// <summary>
        /// To only get one shot of data.
        /// </summary>
        private bool oneShot = false;
#endif

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

        /// <summary>
        /// List of requested items.
        /// </summary>
        private IList<IPidItemWrapper> requestedItems = null;

        /// <summary>
        /// Tool tip handling for disabled controls.
        /// </summary>
        private Control currentToolTipControl = null;

        /// <summary>
        /// Tool tip handling.
        /// </summary>
        private ToolTip toolTip = new ToolTip();

        /// <summary>
        /// Gets data file directory.
        /// </summary>
        protected string dataFileDir { get; private set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="CurrentDataPanel" /> class.
        /// </summary>
        /// <param name="iLogging">Logging instance.</param>
        /// <param name="iPreferences">Preferences data.</param>
        /// <param name="applicationTree">Application tree instance.</param>
        /// <param name="iMessaging">Messaging instance.</param>
        /// <param name="iDataSource">Data source interface instance.</param>
        /// <param name="vehicle">Current vehicle instance.</param>
        /// <param name="dataRequester">Data requester instance.</param>
        /// <param name="modeParser">Mode parser instance.</param>
        /// <param name="dataFileDir">Data file directory path.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1806:DoNotIgnoreMethodResults", MessageId = "CanApp.CustomToolTip", Justification = "Reviewed.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Reviewed.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "1", Justification = "Reviewed.")]
        public CurrentDataPanel(
            ILogging iLogging,
            IPreferences iPreferences,
            IApplicationTree applicationTree,
            IMessaging iMessaging,
            IDataSource iDataSource,
            XmlClass.vehicle vehicle,
            DataRequester dataRequester,
            ModeParser modeParser,
            string dataFileDir)
            : base(iLogging, vehicle, applicationTree)
        {
            this.iPreferences = iPreferences;
            this.iMessaging = iMessaging;
            this.iDataSource = iDataSource;
            this.dataRequester = dataRequester;
            this.modeParser = modeParser;
            this.dataFileDir = dataFileDir;

            this.InitializeComponent();

            this.pollInterval = this.iPreferences.defaultTimeout;
            this.pollUpDown.Value = this.pollInterval;

            this.goButton.Enabled = this.logDataCheckBox.Checked | this.plotDataCheckBox.Checked;

            this.obdDataPanel1.init(
                iLogging,
                iMessaging,
                applicationTree,
                0x01,
                iDataSource,
                vehicle,
                this.dataFileDir);

            this.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
                        | System.Windows.Forms.AnchorStyles.Left)
                        | System.Windows.Forms.AnchorStyles.Right)));

            this.logDataCheckBox.Enabled = this.iLogging.getValueDataLogWriter() != null;
            if (!this.logDataCheckBox.Enabled)
            {
                this.logDataCheckBox.Checked = false;
            }

            this.folderBrowserDialog1.SelectedPath = this.iPreferences.getPreference(PreferencesFileAccess.LAST_DATA_DIRECTORY);

            this.toolTip.SetToolTip(this.saveButton, "Save the current selection to file.");
            this.toolTip.SetToolTip(this.loadButton, "Load a saved selection setting from file.");
            this.toolTip.SetToolTip(this.getSnapshotDataButton, "Do a one shot read of data according to the selection list.");
            this.toolTip.SetToolTip(this.refreshButton, "Refresh the list of selectable items and clear all current selections.");
            this.toolTip.SetToolTip(this.plotDataCheckBox, "Data shall be plotted to charts in sub-panels.");
            this.toolTip.SetToolTip(this.logDataCheckBox, "Data shall be logged to file in CSV format.");
            this.toolTip.SetToolTip(this.pollUpDown, "Base interval between polls.\r\nNotice that parameters can be defined to a lower frequency.");
            this.toolTip.SetToolTip(this.goButton, "Start logging/plotting of data selected in table below.");
            this.toolTip.SetToolTip(this.stopButton, "Stop logging/plotting of data.");
            this.toolTip.SetToolTip(this.clearButton, "Clear all sub-panels with data and charts.");
            this.toolTip.SetToolTip(this.saveDataButton, "Save the data in the plot charts to CSV file or files.");
            this.toolTip.SetToolTip(this.saveChartsButton, "Save plotted charts as images.");
            this.toolTip.SetToolTip(this.progressBar1, "This is an animation to indicate that the data request thread is active.");
        }

        /// <summary>
        /// Close the panel.
        /// </summary>
        public void close()
        {
            if (this.dataRequester != null)
            {
                this.dataRequester.stopPlotting();
            }

            this.owningNode.Nodes.Clear();
            this.plotPanels.Clear();
        }

        /// <summary>
        /// Initialize and refresh data.
        /// </summary>
        public void init()
        {
            this.timer1.Start();
        }

        /// <summary>
        /// Trig a get data event.
        /// </summary>
        public override void getDataEvent()
        {
            this.prepareRequestData();
            this.dataRequester.requestSelectedPids();
        }

        /// <summary>
        /// Dispatch the data to the suitable receiver.
        /// </summary>
        /// <param name="presentationData">Presentation data wrapper.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Reviewed, intentional.")]
        public void simpleDataAdd(IPresentationData presentationData)
        {
            if ((presentationData.mode & 0xbf) != 0x02)
            {
                if (!this.plotting && !this.logging)
                {
                    EcuDataPanel ecuDataPanel = getDataPanelByAddress(presentationData.sourceAddress, -1);

                    ecuDataPanel.simpleDataAdd(presentationData);
                }

                if (this.logging && presentationData.pidItem != null && presentationData.sensor != null)
                {
                    this.logData(presentationData);
                }

                if (this.plotting)
                {
                    this.plotData(presentationData);
                }
            }
        }

        /// <summary>
        /// Add an item of the type Control.
        /// </summary>
        /// <param name="sourceAddress">ECU source address for data.</param>
        /// <param name="mode">Which parameter mode that is selected.</param>
        /// <param name="control">Item to add.</param>
        public void add(uint sourceAddress, byte mode, Control control)
        {
            if ((mode & 0xbf) != 0x02)
            {
                if (!this.plotting && !this.logging)
                {
                    EcuDataPanel ecuDataPanel = getDataPanelByAddress(sourceAddress, -1);
                    ecuDataPanel.add(sourceAddress, mode, control);
                }
            }
        }

        /// <summary>
        /// Update progress bar to indicate that we do something.
        /// </summary>
        /// <param name="count">Counter value.</param>
        public void tickProgress(uint count)
        {
            if (this.progressBar1.InvokeRequired)
            {
                try
                {
                    this.Invoke(new tickProgressFunc(this.tickProgress), new object[] { count });
                }
                catch (System.Reflection.TargetParameterCountException ex)
                {
                    MessageBox.Show(
                        "Exception: " + ex.Message + "\r\n",
                        "Error",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Stop);
                }
                catch (System.ObjectDisposedException)
                {
                    // Ignore.
                }
            }
            else
            {
                this.progressBar1.Value = (int)(count % 6);
            }
        }

        /// <summary>
        /// Write the file heading row.
        /// </summary>
        /// <param name="allLabels">All labels array.</param>
        /// <param name="streamWriter">Stream to write to.</param>
        /// <param name="csvSep">CSV field separator.</param>
        private static void writeHeading(string[] allLabels, StreamWriter streamWriter, string csvSep)
        {
            streamWriter.Write("t (s)");

            foreach (string str in allLabels)
            {
                streamWriter.Write(csvSep);
                streamWriter.Write("\"");
                streamWriter.Write(str);
                streamWriter.Write("\"");
            }

            streamWriter.WriteLine();
        }

        /// <summary>
        /// Write the values to the file.
        /// </summary>
        /// <param name="allMappedData">All mapped data dictionary.</param>
        /// <param name="streamWriter">Stream to write to.</param>
        /// <param name="csvSep">CSV field separator.</param>
        private static void writeData(SortedDictionary<int, DataPoint[]> allMappedData, StreamWriter streamWriter, string csvSep)
        {
            DataPoint[] previousDpa = null;
            foreach (KeyValuePair<int, DataPoint[]> kvp in allMappedData)
            {
                DataPoint[] dpa = kvp.Value;

                if (dpa[0] != null)
                {
                    if (previousDpa != null)
                    {
                        for (int i = 0; i < dpa.Length && i < previousDpa.Length; i++)
                        {
                            if (dpa[i] == null && previousDpa[i] != null)
                            {
                                dpa[i] = previousDpa[i];
                            }
                        }
                    }

                    streamWriter.Write(dpa[0].XValue.ToString(CultureInfo.CurrentCulture));

                    foreach (DataPoint dp in dpa)
                    {
                        streamWriter.Write(csvSep);
                        if (dp != null)
                        {
                            streamWriter.Write(dp.YValues[0].ToString(CultureInfo.CurrentCulture));
                        }
                    }

                    previousDpa = dpa;

                    streamWriter.WriteLine();
                }
            }
        }

        /// <summary>
        /// Handle an exception and present to the user.
        /// </summary>
        /// <param name="fileName">Name of file related.</param>
        /// <param name="ex">Exception data.</param>
        private static void handleException(string fileName, Exception ex)
        {
#if DEBUG
            MessageBox.Show(
                "Could not open file '" + fileName + "'\r\n\r\n" + ex.Message + "\r\n\r\n" + ex.StackTrace,
                "Error",
                MessageBoxButtons.OK,
                MessageBoxIcon.Hand);
#else
            MessageBox.Show(
                "Could not open file '" + fileName + "'\r\n\r\n" + ex.Message,
                "Error",
                MessageBoxButtons.OK,
                MessageBoxIcon.Hand);
#endif
        }

        /// <summary>
        /// Close writer and stream for the file.
        /// </summary>
        /// <param name="fileStream">Stream to close.</param>
        /// <param name="streamWriter">Writer to close.</param>
        private static void closeFile(Stream fileStream, StreamWriter streamWriter)
        {
            if (streamWriter != null)
            {
                try
                {
                    streamWriter.Close();
                }
                catch
                {
                }
            }

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

        /// <summary>
        /// Log data to file.
        /// </summary>
        /// <param name="presentationData">Data to log.</param>
        private void logData(IPresentationData presentationData)
        {
            uint k = 0;

            foreach (XmlClass.pidgroup.pidlist.sensordata sensor in presentationData.pidItem.sensors)
            {
                if (sensor.offset == presentationData.sensor.offset && sensor.unit == presentationData.sensor.unit)
                {
                    XmlClass.unititem thisunit = null;
                    foreach (XmlClass.unititem unit in this.iDataSource.units)
                    {
                        if (sensor.unit.Equals(unit.name))
                        {
                            thisunit = unit;
                            break;
                        }
                    }

                    if (this.iPreferences.selectedUnitCategory == 0 || (thisunit != null
                        && (thisunit.category == 0
                            || (thisunit.category > 0 && thisunit.category == this.iPreferences.selectedUnitCategory))))
                    {
                        uint? destinationAddress = DataRequester.getDestinationAddress(this.iMessaging.protocolHandler, presentationData.sourceAddress);
                        uint da = (destinationAddress != null) ? (uint)destinationAddress : 0;
                        uint[] keys = { da, (uint)(presentationData.mode & 0xbf), presentationData.pid, k };

                        if (sensor.unit == "bit")
                        {
                            this.dataRequester.iDataLog.logData(keys, presentationData.value < 0.5 ? 0 : 1);
                        }
                        else
                        {
                            this.dataRequester.iDataLog.logData(keys, presentationData.value);
                        }
                    }
                }

                k++;
            }
        }

        /// <summary>
        /// Plot the data on a chart.
        /// </summary>
        /// <param name="presentationData">Data to plot.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Reviewed, intentional.")]
        private void plotData(IPresentationData presentationData)
        {
            uint key = (uint)(((uint)(presentationData.mode & 0xff) << 24) | (uint)(presentationData.pid & 0xffffff));
            bool grouped = false;
            if (this.requestedItems != null)
            {
                foreach (PidItemWrapper item in this.requestedItems)
                {
                    if (item != null)
                    {
                        if ((item.pidMode & 0xbf) == (presentationData.mode & 0xbf)
                            && item.pidItem.pid_int == presentationData.pid
                            && item.plotGroup != 0)
                        {
                            key = (uint)item.plotGroup;
                            grouped = true;
                            break;
                        }
                    }
                }
            }

            PanelTreeNode panelTreeNode;
            if (this.plotPanels.ContainsKey(key))
            {
                panelTreeNode = this.plotPanels[key];
            }
            else
            {
                XmlClass.pidgroup.pidlist pidItem = this.getPidItem(presentationData);
                string title = "N/A";
                if (grouped)
                {
                    title = "Plot Group " + key;
                }
                else
                {
                    if (pidItem != null)
                    {
                        title = pidItem.name;
                    }
                }

                PlotDataPanel plotDataPanel = new PlotDataPanel(
                    this.iLogging,
                    this.iPreferences,
                    this.applicationTree,
                    title,
                    this.t0,
                    this.pollInterval,
                    grouped,
                    (byte)(presentationData.mode & 0xbf),
                    presentationData.pid);

                panelTreeNode = new PanelTreeNode(title, "chart_line.png", "chart_line.png", plotDataPanel);
                this.plotPanels.Add(key, panelTreeNode);
                this.addNode(panelTreeNode);
            }

            // Precaution in something odd happens.
            if (panelTreeNode.userControl is PlotDataPanel)
            {
                PlotDataPanel plotDataPanel1 = (PlotDataPanel)panelTreeNode.userControl;
                plotDataPanel1.simpleDataAdd(presentationData);
            }
        }

        /// <summary>
        /// Manually refresh the data.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void refreshButton_Click(object sender, EventArgs e)
        {
            this.obdDataPanel1.refreshModeData(this.vehicle);
            this.init();
        }

        /// <summary>
        /// Poll interval value was changed by the user.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void pollUpDown_ValueChanged(object sender, EventArgs e)
        {
            this.pollInterval = (int)this.pollUpDown.Value;
            if (this.dataRequester != null)
            {
                this.dataRequester.pollInterval = this.pollInterval;
            }
        }

        /// <summary>
        /// Present snapshot data.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void getSnapshotDataButton_Click(object sender, EventArgs e)
        {
            this.t0 = DateTime.Now.Ticks / Utils.TICKS_PER_MILLISECOND;

            // Refresh the dictionary with latest data.
            this.modeParser.configureModePidDictionary();

            this.getDataEvent();
        }

        /// <summary>
        /// Prepare the request data.
        /// </summary>
        private void prepareRequestData()
        {
            this.requestedItems = this.obdDataPanel1.getSelectedItems();

            this.dataRequester.prepareRequestData();

            foreach (PidItemWrapper item in this.requestedItems)
            {
                this.dataRequester.handlePid(
                    item.addrList,
                    (byte)(item.actualMode & 0xff),
                    0,
                    item.pidMode,
                    item.pidItem,
                    item.pidItem.pid_int);
            }

            this.dataRequester.finishPrepareDataRequest();
        }

        /// <summary>
        /// Add node in the navigation tree.
        /// </summary>
        /// <param name="panelTreeNode">Node to add.</param>
        private delegate void addNodeFunc(PanelTreeNode panelTreeNode);

        /// <summary>
        /// Add node in the navigation tree.
        /// </summary>
        /// <param name="panelTreeNode">Node to add.</param>
        private void addNode(PanelTreeNode panelTreeNode)
        {
            if (this.applicationTree.InvokeRequired)
            {
                try
                {
                    this.Invoke(new addNodeFunc(this.addNode), new object[] { panelTreeNode });
                }
                catch (System.Reflection.TargetParameterCountException ex)
                {
                    MessageBox.Show(
                        "Exception: " + ex.Message + "\r\n",
                        "Error",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Stop);
                }
                catch (System.ObjectDisposedException)
                {
                    // Ignore.
                }
            }
            else
            {
                this.owningNode.Nodes.Add(panelTreeNode);
                this.owningNode.Expand();
            }
        }

        /// <summary>
        /// Get PID item matching the data.
        /// </summary>
        /// <param name="presentationData">Data to get PID item for.</param>
        /// <returns>PID item or 'null' if not found.</returns>
        private XmlClass.pidgroup.pidlist getPidItem(IPresentationData presentationData)
        {
            XmlClass.pidgroup.pidlist pidItem = null;
            foreach (XmlClass.pidgroup pidgroup in this.iDataSource.pidgroups)
            {
                if (pidgroup.mode_int == (presentationData.mode & 0xbf))
                {
                    foreach (XmlClass.pidgroup.pidlist pid in pidgroup.pids)
                    {
                        if (pid.pid_int == presentationData.pid)
                        {
                            pidItem = pid;
                            break;
                        }
                    }

                    if (pidItem != null)
                    {
                        break;
                    }
                }
            }

            return pidItem;
        }

        /// <summary>
        /// Start logging/plotting.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void goButton_Click(object sender, EventArgs e)
        {
            DialogResult res = DialogResult.Yes;

            if (this.plotPanels.Count > 0)
            {
                res = MessageBox.Show(
                    "Select 'Yes' to continue on the current series of data"
                    + " and 'No' to start a new series on the same chart starting from zero.",
                    "Question",
                    MessageBoxButtons.YesNoCancel,
                    MessageBoxIcon.Question,
                    MessageBoxDefaultButton.Button1);

                this.t0 = DateTime.Now.Ticks / Utils.TICKS_PER_MILLISECOND;

                if (res == DialogResult.No)
                {
                    foreach (PanelTreeNode node in this.plotPanels.Values)
                    {
                        if (node.userControl is PlotDataPanel)
                        {
                            PlotDataPanel plotDataPanel = (PlotDataPanel)node.userControl;
                            plotDataPanel.restart(this.t0);
                        }
                    }
                }
            }
            else
            {
                this.t0 = DateTime.Now.Ticks / Utils.TICKS_PER_MILLISECOND;
            }

            if (res != DialogResult.Cancel)
            {
                // Refresh the dictionary with latest data.
                this.modeParser.configureModePidDictionary();

                this.setPlotActionButtonsVisible(false);
                this.stopButton.Enabled = true;
                this.goButton.Enabled = false;
                this.plotDataCheckBox.Enabled = false;
                this.logDataCheckBox.Enabled = false;
                this.getSnapshotDataButton.Enabled = false;
                this.refreshButton.Enabled = false;
                this.clearButton.Enabled = false;
                this.saveDataButton.Enabled = false;
                this.saveChartsButton.Enabled = false;

                this.dataRequester.preparePlotting(this.plotting, this.logging);

                if (!string.IsNullOrEmpty(this.iPreferences.gpsSerialPortName))
                {
                    this.dataRequester.startGpsThread();
                }

                this.prepareRequestData();
                this.dataRequester.startPlotThread(this);
            }
        }

        /// <summary>
        /// Update progress bar to indicate that we do something.
        /// </summary>
        /// <param name="count">Counter value.</param>
        private delegate void tickProgressFunc(uint count);

        /// <summary>
        /// Set the plot action buttons visibility in all the related plot panels.
        /// </summary>
        /// <param name="visible">'true' if set to visible, 'false' to hide.</param>
        private void setPlotActionButtonsVisible(bool visible)
        {
            foreach (PanelTreeNode node in this.plotPanels.Values)
            {
                if (node.userControl is PlotDataPanel)
                {
                    PlotDataPanel panel = (PlotDataPanel)node.userControl;
                    panel.setViewButtonsVisible(visible);
                }
            }
        }

        /// <summary>
        /// Stop logging/plotting.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void stopButton_Click(object sender, EventArgs e)
        {
            this.dataRequester.stopPlotting();

            this.stopButton.Enabled = false;
            this.goButton.Enabled = this.logDataCheckBox.Checked | this.plotDataCheckBox.Checked;
            this.plotDataCheckBox.Enabled = true;
            this.logDataCheckBox.Enabled = this.iLogging.getValueDataLogWriter() != null;
            this.getSnapshotDataButton.Enabled = true;
            this.refreshButton.Enabled = true;
            this.clearButton.Enabled = true;
            this.saveDataButton.Enabled = true;
            this.saveChartsButton.Enabled = true;
            this.setPlotActionButtonsVisible(true);

            if (!this.logDataCheckBox.Enabled)
            {
                this.logDataCheckBox.Checked = false;
            }
        }

        /// <summary>
        /// Select data logging.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void logDataCheckBox_CheckedChanged(object sender, EventArgs e)
        {
            this.goButton.Enabled = this.logDataCheckBox.Checked | this.plotDataCheckBox.Checked;
            this.logging = this.logDataCheckBox.Checked;
        }

        /// <summary>
        /// Select data plotting.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void plotDataCheckBox_CheckedChanged(object sender, EventArgs e)
        {
            this.goButton.Enabled = this.logDataCheckBox.Checked | this.plotDataCheckBox.Checked;
            this.plotting = this.plotDataCheckBox.Checked;
        }

        /// <summary>
        /// Clear the current set of sub-panels.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void clearButton_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show(
                "Do you want to discard the current set of sub-panels?",
                "Confirm",
                MessageBoxButtons.YesNo,
                MessageBoxIcon.Question,
                MessageBoxDefaultButton.Button1) == DialogResult.Yes)
            {
                this.owningNode.Nodes.Clear();
                this.plotPanels.Clear();
                this.ecuData.Clear();
            }
        }

        /// <summary>
        /// Log data checkbox activation.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void CurrentDataPanel_VisibleChanged(object sender, EventArgs e)
        {
            this.logDataCheckBox.Enabled = this.iLogging.getValueDataLogWriter() != null;

            if (!this.logDataCheckBox.Enabled)
            {
                this.logDataCheckBox.Checked = false;
            }
        }

        /// <summary>
        /// Log data checkbox activation.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void CurrentDataPanel_MouseEnter(object sender, EventArgs e)
        {
            this.logDataCheckBox.Enabled = this.iLogging.getValueDataLogWriter() != null;

            if (!this.logDataCheckBox.Enabled)
            {
                this.logDataCheckBox.Checked = false;
            }
        }

        /// <summary>
        /// Log data checkbox activation.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void getSnapshotDataButton_Paint(object sender, PaintEventArgs e)
        {
            this.logDataCheckBox.Enabled = this.iLogging.getValueDataLogWriter() != null;

            if (!this.logDataCheckBox.Enabled)
            {
                this.logDataCheckBox.Checked = false;
            }
        }

        /// <summary>
        /// Save current selection to file.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void saveButton_Click(object sender, EventArgs e)
        {
            this.saveFileDialog1.FileName = string.Empty;
            this.saveFileDialog1.DefaultExt = ".xml";
            this.saveFileDialog1.AddExtension = true;
            this.saveFileDialog1.ValidateNames = true;
            this.saveFileDialog1.Filter = "XML Format|*.xml";
            DialogResult res = this.saveFileDialog1.ShowDialog();
            if (res == DialogResult.OK)
            {
                ModePidSelectionFileAccess modePidSelectionFileAccess = new ModePidSelectionFileAccess(this.iLogging, this.saveFileDialog1.FileName, this.dataFileDir);
                IList<IPidItemWrapper> items = this.obdDataPanel1.getSelectedItems();
                foreach (IPidItemWrapper item in items)
                {
                    XmlClass.selectionModePid oneSelection = new XmlClass.selectionModePid();

                    List<XmlClass.selectionModePid.addressItem> addressList = new List<XmlClass.selectionModePid.addressItem>();
                    foreach (uint addr in item.addrList)
                    {
                        XmlClass.selectionModePid.addressItem addrItem = new XmlClass.selectionModePid.addressItem();
                        addrItem.address = addr;
                        addressList.Add(addrItem);
                    }

                    oneSelection.addrList = addressList;
                    oneSelection.mode_int = item.pidMode;
                    oneSelection.pid_int = item.pidItem.pid_int;
                    oneSelection.plotGroup = item.plotGroup;

                    modePidSelectionFileAccess.selections.Add(oneSelection);
                }

                modePidSelectionFileAccess.save();
            }
        }

        /// <summary>
        /// Load saved selection from file.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void loadButton_Click(object sender, EventArgs e)
        {
            this.openFileDialog1.FileName = string.Empty;
            this.openFileDialog1.DefaultExt = ".xml";
            this.openFileDialog1.AddExtension = true;
            this.openFileDialog1.ValidateNames = true;
            this.openFileDialog1.Filter = "XML Format|*.xml";
            DialogResult res = this.openFileDialog1.ShowDialog();
            if (res == DialogResult.OK)
            {
                ModePidSelectionFileAccess modePidSelectionFileAccess = new ModePidSelectionFileAccess(this.iLogging, this.openFileDialog1.FileName, this.dataFileDir);
                modePidSelectionFileAccess.load();
                this.obdDataPanel1.selectItems(modePidSelectionFileAccess.selections);
            }
        }

        /// <summary>
        /// Select a directory to save data to.
        /// </summary>
        /// <param name="path">Out value with the selected path.</param>
        /// <returns>Action preferred by the user.</returns>
        private DialogResult selectDirectory(out string path)
        {
            DialogResult res = DialogResult.No;
            path = null;
            while (res == DialogResult.No)
            {
                res = this.folderBrowserDialog1.ShowDialog();
                if (res == DialogResult.OK)
                {
                    path = this.folderBrowserDialog1.SelectedPath;
                    this.iPreferences.setPreference(PreferencesFileAccess.LAST_DATA_DIRECTORY, path);
                    if (Directory.GetFiles(path).Length > 0)
                    {
                        res = MessageBox.Show(
                            "Directory '" + path + "' is not empty, do you want to use it anyway?",
                            "Warning",
                            MessageBoxButtons.YesNoCancel,
                            MessageBoxIcon.Warning);
                    }
                }
            }

            return res;
        }

        /// <summary>
        /// Save chart data to CSV file.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void saveDataButton_Click(object sender, EventArgs e)
        {
            string path;
            DialogResult res = this.selectDirectory(out path);

            if (res != DialogResult.Cancel && path != null)
            {
                DialogResult res1 = MessageBox.Show(
                    "Do you want to save data in one single file or several individual files?\r\n"
                    + "Yes = Single file,  No = Multiple files.",
                    "Question",
                    MessageBoxButtons.YesNoCancel,
                    MessageBoxIcon.Question);

                switch (res1)
                {
                    case DialogResult.Yes:
                        this.saveSingleFile(path);
                        break;
                    case DialogResult.No:
                        this.saveMultiFile(path);
                        break;
                    default:
                        // Do nothing.
                        break;
                }
            }
        }

        /// <summary>
        /// Save data to multiple files.
        /// </summary>
        /// <param name="path">Path to save to.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Reviewed.")]
        private void saveSingleFile(string path)
        {
            SortedDictionary<int, DataPoint[]> allMappedData = new SortedDictionary<int, DataPoint[]>();

            string[] allLabels = this.joinAllData(allMappedData);

            string fileName = path + "\\AllData.csv";
            Stream fileStream = null;
            StreamWriter streamWriter = null;
            try
            {
                fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
                streamWriter = new StreamWriter(fileStream, Utils.iso_8859_1);
                string csvSep = ";";
                if (CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator == ".")
                {
                    csvSep = ",";
                }

                writeHeading(allLabels, streamWriter, csvSep);

                writeData(allMappedData, streamWriter, csvSep);
            }
            catch (Exception ex)
            {
                handleException(fileName, ex);
            }
            finally
            {
                closeFile(fileStream, streamWriter);
            }
        }

        /// <summary>
        /// Join data from all charts into one single set.
        /// </summary>
        /// <param name="allMappedData">Set to join data into.</param>
        /// <returns>Array of headings.</returns>
        private string[] joinAllData(SortedDictionary<int, DataPoint[]> allMappedData)
        {
            int totalColumns = this.getTotalColumns();
            string[] allLabels = new string[totalColumns];
            try
            {
                int columnIndex = 0;

                foreach (PanelTreeNode node in this.plotPanels.Values)
                {
                    if (node.userControl is PlotDataPanel)
                    {
                        PlotDataPanel plotDataPanel = (PlotDataPanel)node.userControl;

                        int seriesColumns = plotDataPanel.countSeriesColumns();

                        SortedDictionary<int, DataPoint[]> mappedData = new SortedDictionary<int, DataPoint[]>();
                        string[] labels = plotDataPanel.getMappedData(seriesColumns, mappedData);

                        for (int i = 0; i < seriesColumns && i < labels.Length; i++)
                        {
                            allLabels[columnIndex + i] = labels[i];
                        }

                        foreach (KeyValuePair<int, DataPoint[]> kvp in mappedData)
                        {
                            DataPoint[] allPoints;
                            if (allMappedData.ContainsKey(kvp.Key))
                            {
                                allPoints = allMappedData[kvp.Key];
                            }
                            else
                            {
                                allPoints = new DataPoint[totalColumns];
                                allMappedData.Add(kvp.Key, allPoints);
                            }

                            DataPoint[] mappedPoints = kvp.Value;
                            for (int i = 0; i < seriesColumns && i < mappedPoints.Length; i++)
                            {
                                allPoints[columnIndex + i] = mappedPoints[i];
                            }
                        }

                        columnIndex += seriesColumns;
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    ex.Message + "\r\n" + ex.StackTrace,
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Stop);
            }

            return allLabels;
        }

        /// <summary>
        /// Count total number of columns to write.
        /// </summary>
        /// <returns>Total number of columns.</returns>
        private int getTotalColumns()
        {
            int totalColumns = 0;
            foreach (PanelTreeNode node in this.plotPanels.Values)
            {
                if (node.userControl is PlotDataPanel)
                {
                    PlotDataPanel plotDataPanel = (PlotDataPanel)node.userControl;
                    int seriesColumns = plotDataPanel.countSeriesColumns();
                    totalColumns += seriesColumns;
                }
            }

            return totalColumns;
        }

        /// <summary>
        /// Save data to multiple files.
        /// </summary>
        /// <param name="path">Path to save to.</param>
        private void saveMultiFile(string path)
        {
            foreach (PanelTreeNode node in this.plotPanels.Values)
            {
                if (node.userControl is PlotDataPanel)
                {
                    PlotDataPanel plotDataPanel = (PlotDataPanel)node.userControl;
                    plotDataPanel.saveData(path);
                }
            }
        }

        /// <summary>
        /// Save chart images to CSV file.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void saveChartsButton_Click(object sender, EventArgs e)
        {
            string path;
            DialogResult res = this.selectDirectory(out path);

            if (res != DialogResult.Cancel && path != null)
            {
                foreach (PanelTreeNode node in this.plotPanels.Values)
                {
                    if (node.userControl is PlotDataPanel)
                    {
                        PlotDataPanel plotDataPanel = (PlotDataPanel)node.userControl;
                        plotDataPanel.saveChartImage(path);
                    }
                }
            }
        }

        /// <summary>
        /// Act on mouse moved.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void CurrentDataPanel_MouseMove(object sender, MouseEventArgs e)
        {
            Control control = GetChildAtPoint(e.Location);
            if (control != null)
            {
                if (!control.Enabled && this.currentToolTipControl == null)
                {
                    string toolTipString = this.toolTip.GetToolTip(control);

                    // trigger the tooltip with no delay and some basic positioning just to give you an idea
                    this.toolTip.Show(toolTipString, control, control.Width / 2, control.Height / 2);
                    this.currentToolTipControl = control;
                }
            }
            else
            {
                if (this.currentToolTipControl != null)
                {
                    this.toolTip.Hide(this.currentToolTipControl);
                }

                this.currentToolTipControl = null;
            }
        }

        /// <summary>
        /// Delayed request for data.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void timer1_Tick(object sender, EventArgs e)
        {
            this.timer1.Stop();

            IRequestData rd = new RequestData(null, TxMsg.MODE_CURRENT, null, new TxMsg(TxMsg.GET_SUPPORTED_PIDS));
            this.iMessaging.queueMsg(rd);
            this.iMessaging.sendMsg();
        }
    }
}