//-----------------------------------------------------------------------
// <copyright file="GaugeManager.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 Gauges
{
    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Threading;
    using System.Windows.Forms;
    using global::Gauges.TelltalePanel;
    using global::SharedObjects;
    using global::SharedObjects.DataMgmt;
    using global::SharedObjects.Misc;
    using global::SharedObjects.Misc.Objects;
    using global::SharedObjects.Protocol;
    using global::SharedObjects.Protocol.OBD;
    using global::SharedObjects.Protocol.OBD.SSM;

    /// <summary>
    /// Class for setting up which gauges to display.
    /// </summary>
    public partial class GaugeManager : Form, IGaugePresentation
    {
        /// <summary>
        /// Logger instance.
        /// </summary>
        private ILogging iLogging;

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

        /// <summary>
        /// Current Mode parser.
        /// </summary>
        private IModeParser modeParser;

        /// <summary>
        /// Current SSM parser.
        /// </summary>
        private ISsmParser ssmParser;

        /// <summary>
        /// Current Gauge Form.
        /// </summary>
        private GaugeForm1 gaugeForm1 = null;

        /// <summary>
        /// Current sensor map.
        /// </summary>
        private List<SensorMapItem> sensorMap;

        /// <summary>
        /// Indicates if data needs to be saved.
        /// </summary>
        private bool dirty = false;

        /// <summary>
        /// List of requests to issue to get data for gauges.
        /// </summary>
        private List<IRequestData> requests;

        /// <summary>
        /// Current data poll thread.
        /// </summary>
        private Thread pollThread = null;

        /// <summary>
        /// Current gauge update thread.
        /// </summary>
        private Thread refreshThread = null;

        /// <summary>
        /// Array of current gauge values.
        /// </summary>
        private float[] values;

        /// <summary>
        /// Array of current gauge values.
        /// </summary>
        private float[] digitalValues;

        /// <summary>
        /// Telltale toggle states.
        /// </summary>
        private IDictionary<XmlClass.telltaleitem, TelltaleWrapper> telltaleValues = new Dictionary<XmlClass.telltaleitem, TelltaleWrapper>();

        /// <summary>
        /// Time to sleep between each update.
        /// </summary>
        private int sleepTime;

        /// <summary>
        /// Flag indicating that values has been updated.
        /// <para>
        /// This is used to avoid updating the gauges if no change has occurred since it is a performance-hungry operation.
        /// </para>
        /// </summary>
        private bool updatedValues = true;

        /// <summary>
        /// Flag indicating that values has been updated.
        /// <para>
        /// This is used to avoid updating the gauges if no change has occurred since it is a performance-hungry operation.
        /// </para>
        /// </summary>
        private bool updatedTelltale = true;

        /// <summary>
        /// Poll loop active.
        /// </summary>
        private bool doPoll = false;

        /// <summary>
        /// Refresh loop active.
        /// </summary>
        private bool doRefresh = false;

        /// <summary>
        /// Lock object to avoid colliding update/read data between threads.
        /// </summary>
        private object valueUpdateLockObject = new object();

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

        /// <summary>
        /// Data file directory path.
        /// </summary>
        private string dataFileDir;

        /// <summary>
        /// Palette instances container.
        /// </summary>
        private PaletteCreator paletteCreator = new PaletteCreator();

        /// <summary>
        /// Initializes a new instance of the <see cref="GaugeManager" /> class.
        /// </summary>
        /// <param name="iLogging">Logger instance.</param>
        /// <param name="iDataSource">Data source interface instance.</param>
        /// <param name="iMessaging">Current Messaging instance.</param>
        /// <param name="modeParser">Current Mode parser.</param>
        /// <param name="ssmParser">Current SSM parser.</param>
        /// <param name="dataFileDir">Current data file directory.</param>
        public GaugeManager(
            ILogging iLogging,
            IDataSource iDataSource,
            IMessaging iMessaging,
            IModeParser modeParser,
            ISsmParser ssmParser,
            string dataFileDir)
        {
            this.iLogging = iLogging;
            this.iDataSource = iDataSource;
            this.iMessaging = iMessaging;
            this.modeParser = modeParser;
            this.ssmParser = ssmParser;
            this.dataFileDir = dataFileDir;

            this.InitializeComponent();

            this.refreshData();
        }

        /// <summary>
        /// Stop polling for data.
        /// </summary>
        public void stopPoll()
        {
            this.modeParser.pidParser.setGaugePresentation(null);
            this.ssmParser.setGaugePresentation(null);

            this.doPoll = false;
            this.doRefresh = false;

            if (this.refreshThread != null)
            {
                this.refreshThread.Abort();
                this.refreshThread.Interrupt();
                this.refreshThread.Join(4000);
                this.refreshThread = null;
            }

            if (this.pollThread != null)
            {
                this.pollThread.Abort();
                this.pollThread.Interrupt();
                this.pollThread.Join(4000);
                this.pollThread = null;
            }

            this.telltaleValues.Clear();
        }

        /// <summary>
        /// Set gauge value.
        /// </summary>
        /// <param name="mode">Mode for value</param>
        /// <param name="pid">PID for value</param>
        /// <param name="sensor">Sensor for value</param>
        /// <param name="value">Value to set</param>
        /// <returns>'true' if successfully presented the data.</returns>
        public bool setGaugeValue(byte mode, uint pid, XmlClass.pidgroup.pidlist.sensordata sensor, float value)
        {
            bool success = false;

            if (sensor != null)
            {
#if TRACE
                this.iLogging.appendText("");
#endif

                this.handleDataSet(1, mode, pid, sensor, value);
                this.handleDataSet(2, mode, pid, sensor, value);
                this.handleDataSet(3, mode, pid, sensor, value);

                success = true;
            }
            else
            {
                this.iLogging.appendText("'null' Sensor.\r\n");
            }

            return success;
        }

        /// <summary>
        /// Find the sensor for the gauge.
        /// </summary>
        /// <param name="sensor_unit">Sensor unit string.</param>
        /// <param name="sensor_offset">Sensor byte offset.</param>
        /// <param name="pid">PID with sensor list to look in.</param>
        /// <param name="sensor_bit">Sensor bit number string.</param>
        /// <returns>Sensor description data.</returns>
        private static XmlClass.pidgroup.pidlist.sensordata findSensorItem(string sensor_unit, uint sensor_offset, XmlClass.pidgroup.pidlist pid, string sensor_bit)
        {
            XmlClass.pidgroup.pidlist.sensordata sensor = null;
            foreach (XmlClass.pidgroup.pidlist.sensordata sensorItem in pid.sensors)
            {
                if (string.IsNullOrEmpty(sensor_bit)
                    && sensorItem.unit.Equals(sensor_unit)
                    && sensorItem.offset == sensor_offset)
                {
                    sensor = sensorItem;
                    break;
                }

                if (!string.IsNullOrEmpty(sensor_bit)
                    && !string.IsNullOrEmpty(sensorItem.startbit)
                    && sensorItem.unit.Equals(sensor_unit)
                    && sensorItem.offset == sensor_offset
                    && sensor_bit.Trim() == sensorItem.startbit.Trim())
                {
                    sensor = sensorItem;
                    break;
                }
            }

            return sensor;
        }

        /// <summary>
        /// Find the PID item given the gauge item.
        /// </summary>
        /// <param name="pid_int">PID id</param>
        /// <param name="pidgroup">Pid group with pid items.</param>
        /// <returns>Matching PID item or 'null' if not found.</returns>
        private static XmlClass.pidgroup.pidlist findPidItem(uint pid_int, XmlClass.pidgroup pidgroup)
        {
            XmlClass.pidgroup.pidlist pid = null;
            foreach (XmlClass.pidgroup.pidlist pidItem in pidgroup.pids)
            {
                if (pidItem.pid_int == pid_int)
                {
                    pid = pidItem;
                    break;
                }
            }

            return pid;
        }

        /// <summary>
        /// Get PID and sensor from the given data.
        /// </summary>
        /// <param name="pidgroup">Current PID group.</param>
        /// <param name="pid_int">Current PID id.</param>
        /// <param name="sensor_unit">Current sensor unit string.</param>
        /// <param name="sensor_offset">Current sensor offset.</param>
        /// <param name="sensor_bit">Current sensor bit.</param>
        /// <param name="pid">PID instance. (out)</param>
        /// <param name="sensor">Sensor instance. (out)</param>
        private static void getSensor(
            XmlClass.pidgroup pidgroup,
            uint pid_int,
            string sensor_unit,
            uint sensor_offset,
            string sensor_bit,
            out XmlClass.pidgroup.pidlist pid,
            out XmlClass.pidgroup.pidlist.sensordata sensor)
        {
            pid = null;
            sensor = null;
            if (pidgroup != null)
            {
                pid = findPidItem(pid_int, pidgroup);

                if (pid != null)
                {
                    sensor = findSensorItem(sensor_unit, sensor_offset, pid, sensor_bit);
                }
            }
        }

        /// <summary>
        /// Handle presentation of one data set.
        /// </summary>
        /// <param name="dataSet">Data set to handle.</param>
        /// <param name="mode">Data mode value.</param>
        /// <param name="pid">Data PID value.</param>
        /// <param name="sensor">Sensor instance.</param>
        /// <param name="value">Actual value to present.</param>
        private void handleDataSet(uint dataSet, byte mode, uint pid, XmlClass.pidgroup.pidlist.sensordata sensor, float value)
        {
            int gauge = -1;
            XmlClass.telltaleitem telltaleItemValue = null;
            Image icon = null;

            for (int i = 0; i < this.sensorMap.Count; i++)
            {
                SensorMapItem s1 = this.sensorMap[i];
                if (s1.mode == (mode & 0xBF)
                    && s1.pid == pid
                    && s1.sensor.unit == sensor.unit
                    && s1.sensor.offset == sensor.offset
                    && s1.dataSet == dataSet)
                {
                    gauge = (int)s1.gauge;
                    telltaleItemValue = s1.telltaleItemValue;
                    icon = s1.icon;
                    break;
                }
            }

            if (gauge >= 0)
            {
#if TRACE
                this.iLogging.appendText("dataSet=" + dataSet + ", gauge=" + gauge + ",  mode=0x" + mode.ToString("x2") + ", pid=0x" + pid.ToString() + ", sensor=" + sensor.unit + "\r\n");
#endif

                lock (this.valueUpdateLockObject)
                {
                    switch (dataSet)
                    {
                        case 2:
                            this.digitalValues[gauge] = value;
                            break;

                        case 3:
                            this.setTelltale(value, telltaleItemValue);
                            break;

                        default:
                            this.values[gauge] = value;
                            break;
                    }

                    this.updatedValues = true;
                }
            }
        }

        /// <summary>
        /// Set the telltales.
        /// </summary>
        /// <param name="value">Value for telltale.</param>
        /// <param name="telltaleItemValue">Which telltale.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Reviewed, intentional.")]
        private void setTelltale(float value, XmlClass.telltaleitem telltaleItemValue)
        {
            if (telltaleItemValue != null)
            {
                bool active = (value > 0.5);

                if (!this.telltaleValues.ContainsKey(telltaleItemValue))
                {
#if TRACE
                    this.iLogging.appendText("New Telltale: " + telltaleItemValue.telltaleicon + "\r\n");
#endif
                    Image img = Image.FromFile(this.dataFileDir + "Icons\\" + telltaleItemValue.telltaleicon);
                    Color primaryColor = Color.FromName(telltaleItemValue.primaryColor);
                    Color secondaryColor = Color.FromName(telltaleItemValue.secondaryColor);
                    Color flashColor = Color.FromName(telltaleItemValue.flashColor);
                    TellTale tellTaleOn = new TellTale(img, 40, primaryColor, secondaryColor, flashColor, this.paletteCreator.paletteFlashOn, BorderStyle.None);
                    TellTale tellTaleOff = new TellTale(img, 40, Color.Black, Color.Black, Color.Black, this.paletteCreator.paletteFlashOn, BorderStyle.None);
                    TelltaleWrapper telltaleWrapper = new TelltaleWrapper(tellTaleOn, tellTaleOff, active);

                    this.updatedTelltale = true;

                    this.telltaleValues.Add(telltaleItemValue, telltaleWrapper);
                }
                else
                {
                    if (this.telltaleValues[telltaleItemValue].active != active)
                    {
                        this.telltaleValues[telltaleItemValue].active = active;
                        this.telltaleValues[telltaleItemValue].changed = true;
                        this.updatedTelltale = true;
                    }
                }
            }
        }

        /// <summary>
        /// Refresh the data form.
        /// </summary>
        private void refreshData()
        {
            DataGridViewRowCollection rowCollection = this.gaugesDataGridView.Rows;
            rowCollection.Clear();
            foreach (XmlClass.gaugeitem item in this.iDataSource.gauges)
            {
                string pidName = this.getPidName(item.pidgroupid, item.pid_int);
                string digitalPidName = this.getPidName(item.digitalPidgroupid, item.digitalPid_int);

                int n0 = rowCollection.Add(1);
                DataGridViewRow row = rowCollection[n0];
                DataGridViewCellCollection cellCollection = row.Cells;

                cellCollection["gaugeItem"].Value = item;
                cellCollection["gaugeNumber"].Value = item.gaugeNumber;
                cellCollection["displayedItem"].Value = pidName;
                cellCollection["gaugeText"].Value = item.gaugetext;
                cellCollection["digitalItem"].Value = digitalPidName;
                cellCollection["digitalText"].Value = item.digitalGaugetext;
                cellCollection["digitalFormatMask"].Value = item.digitalFormat;
            }

            DataGridViewRowCollection rowCollection1 = this.telltalesDataGridView.Rows;
            rowCollection1.Clear();
            foreach (XmlClass.telltaleitem item in this.iDataSource.telltales)
            {
                string pidName = this.getPidName(item.pidgroupid, item.pid_int);
                string sensorName = this.getSensorName(item);

                int n0 = rowCollection1.Add(1);
                DataGridViewRow row = rowCollection1[n0];
                DataGridViewCellCollection cellCollection = row.Cells;

                cellCollection["telltaleItem"].Value = item;
                cellCollection["telltaleFieldNumber"].Value = item.telltaleGroupNumber;
                cellCollection["telltalePrio"].Value = item.telltalePriority;
                cellCollection["telltaleItemName"].Value = pidName;
                cellCollection["telltaleText"].Value = item.telltaletext;
                cellCollection["telltalePrimaryColor"].Style.BackColor = Color.FromName(item.primaryColor);
                cellCollection["telltaleSecondaryColor"].Style.BackColor = Color.FromName(item.secondaryColor);
                cellCollection["telltaleFlashColor"].Style.BackColor = Color.FromName(item.flashColor);
                cellCollection["telltaleSensor"].Value = sensorName;
                cellCollection["telltaleSensorBit"].Value = item.sensor_bit;

                this.setImage(cellCollection, item.telltaleicon);
            }
        }

        /// <summary>
        /// Fill in the icon column.
        /// </summary>
        /// <param name="dgvcc">Current column collection.</param>
        /// <param name="filename">Name of icon file.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Reviewed, intentional.")]
        private void setImage(DataGridViewCellCollection dgvcc, string filename)
        {
            float hLimit = 30;
            float wLimit = 50;
            Image img = Image.FromFile(this.dataFileDir + "Icons\\" + filename);
            float proportion = (float)img.Height / (float)img.Width;
            float w = hLimit / proportion;
            float h = wLimit * proportion;
            if (h > hLimit)
            {
                h = hLimit;
            }
            else
            {
                w = wLimit;
            }

            int w0 = (int)w;
            int h0 = (int)h;
            Bitmap bmp = new Bitmap(w0, h0);
            using (Graphics g = Graphics.FromImage(bmp))
            {
                g.DrawImage(img, new Rectangle(5, 5, bmp.Width - 5, bmp.Height - 5));
            }

            dgvcc["telltaleIcon"].Value = bmp;
        }

        /// <summary>
        /// Get PID name.
        /// </summary>
        /// <param name="pidgroupid">PID group to look in.</param>
        /// <param name="pid_int">PID to get name for.</param>
        /// <returns>PID name.</returns>
        private string getPidName(int pidgroupid, uint pid_int)
        {
            string name = null;
            foreach (XmlClass.pidgroup pidGrp in this.iDataSource.pidgroups)
            {
                if (pidGrp.id.Equals(pidgroupid))
                {
                    foreach (XmlClass.pidgroup.pidlist pid in pidGrp.pids)
                    {
                        // if (pid.pid.Equals(item.pid))
                        if (pid.pid_int == pid_int)
                        {
                            name = pid.name;
                            break;
                        }
                    }
                }

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

            if (name == null)
            {
                name = string.Empty;
            }

            return name;
        }

        /// <summary>
        /// Get sensor name.
        /// </summary>
        /// <param name="item">Telltale item instance.</param>
        /// <returns>Sensor name</returns>
        private string getSensorName(XmlClass.telltaleitem item)
        {
            string name = null;

            foreach (XmlClass.pidgroup pidGrp in this.iDataSource.pidgroups)
            {
                if (pidGrp.id == item.pidgroupid)
                {
                    foreach (XmlClass.pidgroup.pidlist pid in pidGrp.pids)
                    {
                        if (pid.pid_int == item.pid_int)
                        {
                            foreach (XmlClass.pidgroup.pidlist.sensordata sensor in pid.sensors)
                            {
                                int startbit = -1;
                                try
                                {
                                    if (sensor.unit == "bit")
                                    {
                                        startbit = Convert.ToInt32(sensor.startbit);
                                    }
                                }
                                catch
                                {
                                }

                                if (sensor.offset == item.sensor_offset
                                    && (item.sensor_bit == -1 || item.sensor_bit == startbit))
                                {
                                    name = sensor.name;
                                    break;
                                }
                            }
                        }

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

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

            if (name == null)
            {
                name = string.Empty;
            }

            return name;
        }

        /// <summary>
        /// Handle double-click on cell.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void gaugesDataGridView_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            DataGridView dataGridView = (DataGridView)sender;
            int ix = e.RowIndex;
            DataGridViewRowCollection rows = dataGridView.Rows;
            List<uint> usedGaugeList = new List<uint>();
            IList<uint> allGauges = GaugeSelector.allGauges();

            foreach (DataGridViewRow row in rows)
            {
                XmlClass.gaugeitem item = (XmlClass.gaugeitem)row.Cells["gaugeItem"].Value;
                if (item != null)
                {
                    usedGaugeList.Add(item.gaugeNumber);
                    allGauges.Remove(item.gaugeNumber);
                }
            }

            uint[] usedGauges = usedGaugeList.ToArray();

            try
            {
                if (ix >= 0 && ix < rows.Count)
                {
                    DataGridViewRow row = rows[ix];
                    DataGridViewCellCollection cellCollection = row.Cells;
                    XmlClass.gaugeitem oldGaugeitem = (XmlClass.gaugeitem)cellCollection["gaugeItem"].Value;
                    bool newRow = row.IsNewRow;
                    uint gaugeNumber1;
                    if (newRow || oldGaugeitem == null)
                    {
                        if (allGauges.Count == 0)
                        {
                            throw new Exception("No available gauges.");
                        }

                        gaugeNumber1 = allGauges[0];
                        int n0 = rows.Add(1);
                        row = rows[n0];
                        cellCollection = row.Cells;
                        dataGridView.CurrentCell = cellCollection["displayedItem"];
                    }
                    else
                    {
                        gaugeNumber1 = oldGaugeitem.gaugeNumber;
                    }

                    if (oldGaugeitem != null || (newRow && allGauges.Count > 0))
                    {
                        using (GaugeDetails gaugeDetails = new GaugeDetails(this.iDataSource.restrictedPidgroups, oldGaugeitem, gaugeNumber1, usedGauges))
                        {
                            if (gaugeDetails.ShowDialog() == DialogResult.OK)
                            {
                                XmlClass.gaugeitem newGaugeitem = gaugeDetails.gaugeitem;

                                // newGaugeitem.gaugeNumber = (uint)ix;
                                cellCollection["gaugeItem"].Value = newGaugeitem;
                                cellCollection["gaugeNumber"].Value = newGaugeitem.gaugeNumber;
                                cellCollection["displayedItem"].Value = gaugeDetails.pidName;
                                cellCollection["gaugeText"].Value = newGaugeitem.gaugetext;
                                cellCollection["digitalItem"].Value = gaugeDetails.digitalPidName;
                                cellCollection["digitalText"].Value = newGaugeitem.digitalGaugetext;
                                cellCollection["digitalFormatMask"].Value = newGaugeitem.digitalFormat;

                                this.iDataSource.gauges.Remove(oldGaugeitem);
                                this.iDataSource.gauges.Add(newGaugeitem);
                                this.dirty = true;
                            }
                            else
                            {
                                if (newRow)
                                {
                                    rows.Remove(row);
                                }
                            }
                        }
                    }
                    else
                    {
                        if (newRow)
                        {
                            rows.Remove(row);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    "Unable to create/update Gauge.\r\n" + ex.Message,
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Hand);
            }
        }

        /// <summary>
        /// Close button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void closeButton_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        /// <summary>
        /// Save button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void saveButton_Click(object sender, EventArgs e)
        {
            this.iDataSource.saveGauges();
            this.iDataSource.saveTelltales();
            this.dirty = false;
        }

        /// <summary>
        /// Show gauges button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void showGaugesButton_Click(object sender, EventArgs e)
        {
            this.sensorMap = new List<SensorMapItem>();
            DataGridViewRowCollection gaugeRows = this.gaugesDataGridView.Rows;
            DataGridViewRowCollection telltaleRows = this.telltalesDataGridView.Rows;

            if (this.gaugeForm1 == null || !this.gaugeForm1.CanFocus)
            {
                this.gaugeForm1 = new GaugeForm1(this, this.paletteCreator);
            }

            this.requests = new List<IRequestData>();

            this.values = new float[8];
            this.digitalValues = new float[8];
            for (int i = 0; i < this.values.Length; i++)
            {
                this.values[i] = 0;
                this.digitalValues[i] = 0;
            }

            foreach (DataGridViewRow row in telltaleRows)
            {
                DataGridViewCellCollection cellCollection = row.Cells;
                if (cellCollection["telltaleItem"].Value != null)
                {
                    XmlClass.telltaleitem telltaleItemValue = (XmlClass.telltaleitem)cellCollection["telltaleItem"].Value;
                    Image icon = (Image)cellCollection["telltaleIcon"].Value;
                    XmlClass.pidgroup pidgroup = this.getPidGroup(telltaleItemValue.pidgroupid);
                    XmlClass.pidgroup.pidlist pid;
                    XmlClass.pidgroup.pidlist.sensordata sensor;
                    getSensor(
                        pidgroup,
                        telltaleItemValue.pid_int,
                        telltaleItemValue.sensor_unit,
                        telltaleItemValue.sensor_offset,
                        telltaleItemValue.sensor_bit.ToString(),
                        out pid,
                        out sensor);

                    if (pid != null && sensor != null)
                    {
                        this.addSensorMapItem(3, telltaleItemValue.telltaleGroupNumber, pidgroup, pid, sensor, telltaleItemValue, icon);

                        this.buildRequest(null, pid, pidgroup.mode_int);
                    }
                }
            }

            foreach (DataGridViewRow row in gaugeRows)
            {
                DataGridViewCellCollection cellCollection = row.Cells;
                if (cellCollection["gaugeItem"].Value != null)
                {
                    XmlClass.gaugeitem item = (XmlClass.gaugeitem)cellCollection["gaugeItem"].Value;
                    XmlClass.pidgroup pidgroup = this.getPidGroup(item.pidgroupid);
                    XmlClass.pidgroup digitalPidgroup = this.getPidGroup(item.digitalPidgroupid);

                    XmlClass.pidgroup.pidlist pid;
                    XmlClass.pidgroup.pidlist.sensordata sensor;
                    getSensor(
                        pidgroup,
                        item.pid_int,
                        item.sensor_unit,
                        item.sensor_offset,
                        null,
                        out pid,
                        out sensor);

                    if (pid != null && sensor != null)
                    {
                        this.gaugeForm1.configureGauge(item, sensor);

                        this.addSensorMapItem(1, item.gaugeNumber, pidgroup, pid, sensor, null, null);

                        this.buildRequest(null, pid, pidgroup.mode_int);

                        XmlClass.pidgroup.pidlist pid2;
                        XmlClass.pidgroup.pidlist.sensordata sensor2;
                        getSensor(
                            digitalPidgroup,
                            item.digitalPid_int,
                            item.digitalSensor_unit,
                            item.digitalSensor_offset,
                            null,
                            out pid2,
                            out sensor2);

                        if (pid2 != null && sensor2 != null)
                        {
                            this.addSensorMapItem(2, item.gaugeNumber, digitalPidgroup, pid2, sensor2, null, null);

                            this.buildRequest(null, pid2, digitalPidgroup.mode_int);
                        }
                    }
                }
            }

            this.gaugeForm1.Show();
            this.sleepTime = (int)this.pollUpDown.Value;

            this.doPoll = true;
            this.doRefresh = true;

            this.modeParser.pidParser.setGaugePresentation(this);
            this.ssmParser.setGaugePresentation(this);

            this.refreshThread = new Thread(new ThreadStart(this.refreshThreadImplementation));
            this.refreshThread.Name = "Gauge Draw";
            this.refreshThread.Start();

            // To get the threads out of sync to begin with.
            Thread.Sleep(this.sleepTime / 2);

            this.pollThread = new Thread(new ThreadStart(this.pollThreadImplementation));
            this.pollThread.Name = "Gauge Poll";
            this.pollThread.Start();
        }

        /// <summary>
        /// Add one sensor map item.
        /// </summary>
        /// <param name="dataSet">Data set number, 1=Analogue Gauge, 2=Digital Gauge, 3=Telltale</param>
        /// <param name="gaugeNumber1">Gauge number.</param>
        /// <param name="pidgroup">PID group instance.</param>
        /// <param name="pid">Current PID instance.</param>
        /// <param name="sensor">Current sensor instance.</param>
        /// <param name="telltaleItemValue">Telltale item data.</param>
        /// <param name="icon">Telltale icon.</param>
        private void addSensorMapItem(
            uint dataSet,
            uint gaugeNumber1,
            XmlClass.pidgroup pidgroup,
            XmlClass.pidgroup.pidlist pid,
            XmlClass.pidgroup.pidlist.sensordata sensor,
            XmlClass.telltaleitem telltaleItemValue,
            Image icon)
        {
            SensorMapItem smi = new SensorMapItem(dataSet, gaugeNumber1, (byte)pidgroup.mode_int, pid.pid_int, sensor, telltaleItemValue, icon);
            if (!this.sensorMap.Contains(smi))
            {
                this.sensorMap.Add(smi);
            }
        }

        /// <summary>
        /// Get the PID group using the ID.
        /// </summary>
        /// <param name="pidgroupid">Current PID group ID.</param>
        /// <returns>PID group instance.</returns>
        private XmlClass.pidgroup getPidGroup(int pidgroupid)
        {
            XmlClass.pidgroup pidgroup = null;
            foreach (XmlClass.pidgroup pg in this.iDataSource.pidgroups)
            {
                if (pg.id.Equals(pidgroupid))
                {
                    pidgroup = pg;
                    break;
                }
            }

            return pidgroup;
        }

        /// <summary>
        /// Build a data request and add it to the list.
        /// </summary>
        /// <param name="destinationAddress">Destination address to send to.</param>
        /// <param name="pid">PID item.</param>
        /// <param name="modeInt">Mode byte value.</param>
        private void buildRequest(uint? destinationAddress, XmlClass.pidgroup.pidlist pid, uint modeInt)
        {
            IRequestData rd = null;
            switch (modeInt)
            {
                case 0x01:
                    rd = new RequestData(destinationAddress, (byte)modeInt, pid, new TxMsg(new byte[] { (byte)modeInt, (byte)(pid.pid_int & 0xff) }));
                    break;
                case 0x22:
                    rd = new RequestData(destinationAddress, (byte)modeInt, pid, new TxMsg(new byte[] { (byte)modeInt, (byte)((pid.pid_int >> 8) & 0xff), (byte)(pid.pid_int & 0xff) }));
                    break;
                case 0xA0:
                    rd = new RequestData(destinationAddress, (byte)modeInt, pid, new TxMsg(new byte[] { (byte)modeInt, 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:
                    rd = new RequestData(destinationAddress, (byte)modeInt, pid, new TxMsg(new byte[] { (byte)modeInt, 0x00, (byte)((pid.pid_int >> 16) & 0xff), (byte)((pid.pid_int >> 8) & 0xff), (byte)(pid.pid_int & 0xff) }));
                    break;
            }

            if (rd != null && !this.requests.Contains(rd))
            {
                this.requests.Add(rd);
            }
        }

        /// <summary>
        /// Form is closing.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void GaugeManager_FormClosing(object sender, FormClosingEventArgs e)
        {
            this.stopPoll();
            if (this.dirty)
            {
                DialogResult res = MessageBox.Show(
                    "Do you want to save updated data?",
                    "Confirm",
                    MessageBoxButtons.YesNoCancel,
                    MessageBoxIcon.Question,
                    MessageBoxDefaultButton.Button1);

                switch (res)
                {
                    case DialogResult.Yes:
                        this.iDataSource.saveGauges();
                        this.dirty = false;
                        break;
                    case DialogResult.No:
                        // Do nothing.
                        break;
                    case DialogResult.Cancel:
                        e.Cancel = true;
                        break;
                }
            }

            if (this.gaugeForm1 != null)
            {
                this.gaugeForm1.Close();
            }
        }

        /// <summary>
        /// Row deleted by user.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void dataGridView1_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
        {
            DataGridViewRow row = e.Row;
            DataGridViewCellCollection rowcells = row.Cells;
            XmlClass.gaugeitem item = (XmlClass.gaugeitem)rowcells["gaugeItem"].Value;

            if (item != null)
            {
                string name = rowcells["gaugeText"].Value.ToString();

                if (MessageBox.Show(
                    "Do you want to delete '" + name + "'?",
                    "Confirm",
                    MessageBoxButtons.YesNo,
                    MessageBoxIcon.Warning,
                    MessageBoxDefaultButton.Button2) == DialogResult.No)
                {
                    e.Cancel = true;
                }
                else
                {
                    this.dirty = true;
                    this.iDataSource.gauges.Remove(item);
                }
            }
        }

        /// <summary>
        /// Refresh gauges thread.
        /// </summary>
        private void refreshThreadImplementation()
        {
            this.refreshThread.Priority = ThreadPriority.BelowNormal;
            List<int> refreshPanels = new List<int>();

            while (this.doRefresh && this.refreshThread != null)
            {
                bool needRefresh = false;
                float[] values1 = null;
                float[] digitalValues1 = null;
                KeyValuePair<XmlClass.telltaleitem, TelltaleWrapper>[] telltales = null;

                lock (this.valueUpdateLockObject)
                {
                    if (this.updatedValues)
                    {
                        this.updatedValues = false;

                        if (this.values != null)
                        {
                            values1 = new float[this.values.Length];
                            Array.Copy(this.values, values1, this.values.Length);
                        }

                        if (this.digitalValues != null)
                        {
                            digitalValues1 = new float[this.digitalValues.Length];
                            Array.Copy(this.digitalValues, digitalValues1, this.digitalValues.Length);
                        }
                    }

                    if (this.updatedTelltale)
                    {
                        this.updatedTelltale = false;
                        telltales = new KeyValuePair<XmlClass.telltaleitem, TelltaleWrapper>[this.telltaleValues.Count];
                        this.telltaleValues.CopyTo(telltales, 0);
                    }
                }

                if (telltales != null)
                {
                    foreach (KeyValuePair<XmlClass.telltaleitem, TelltaleWrapper> kvp in telltales)
                    {
                        TelltaleWrapper wrapper = kvp.Value;
#if TRACE
                        this.iLogging.appendText("Telltale=" + kvp.Key.telltaletext + ", changed=" + wrapper.changed + ", active=" + wrapper.active + "\r\n");
#endif

                        if (wrapper.changed)
                        {
                            wrapper.changed = false;
                            needRefresh = true;
                            XmlClass.telltaleitem item = kvp.Key;
                            int iconArea = (int)item.telltaleGroupNumber;
                            if (!refreshPanels.Contains(iconArea))
                            {
                                refreshPanels.Add(iconArea);
                            }

                            if (wrapper.active)
                            {
                                this.gaugeForm1.removeIcon(iconArea, wrapper.tellTaleOff);
                                this.gaugeForm1.addIcon(iconArea, wrapper.tellTaleOn);
                            }
                            else
                            {
                                this.gaugeForm1.removeIcon(iconArea, wrapper.tellTaleOn);
                                this.gaugeForm1.addIcon(iconArea, wrapper.tellTaleOff);
                            }
                        }
                    }
                }

                if (values1 != null && digitalValues1 != null)
                {
#if TRACE
                    this.iLogging.appendText("Refresh Gauges.\r\n");
#endif
                    this.gaugeForm1.setValues(values1, digitalValues1);
                }

                // To redraw the panels with icons.
                if (needRefresh)
                {
                    foreach (int iconArea in refreshPanels)
                    {
                        this.gaugeForm1.refreshIconPanels(iconArea);
                    }

                    refreshPanels.Clear();
                }

                Thread.Sleep(this.sleepTime);
            }
        }

        /// <summary>
        /// Poll thread.
        /// </summary>
        private void pollThreadImplementation()
        {
#if TRACE
            this.iLogging.appendText("Poll thread start. this.requests=" + this.requests.Count + "\r\n");
#endif

            this.sleepTime = (int)this.pollUpDown.Value;

            uint n = 0;
            while (this.doPoll && this.pollThread != null)
            {
                foreach (IRequestData msg in this.requests)
                {
                    // Limit the frequency for slow changing data like ambient temperature.
                    if ((n % msg.divisor) == 0)
                    {
                        bool flag = this.iMessaging.queueMsg(msg);

#if TRACE
                        logPayloadData(msg, flag);
#endif
                    }
                }

                this.iMessaging.sendMsg(true);

                Thread.Sleep(this.sleepTime);
                n++;
            }

            this.iLogging.appendText("Poll thread end.\r\n");
        }

        /// <summary>
        /// Log sent payload data.
        /// </summary>
        /// <param name="msg">Message with payload data.</param>
        /// <param name="flag">Flag to display with message, indicating if message was queued or not.</param>
        private void logPayloadData(IRequestData msg, bool flag)
        {
            string payloadStr = string.Empty;
            foreach (byte data in msg.message.payload)
            {
                if (!string.IsNullOrEmpty(payloadStr))
                {
                    payloadStr += " ";
                }

                payloadStr += data.ToString("x2");
            }

            this.iLogging.appendText("Queued msg='" + flag + "': " + payloadStr + "\r\n");
        }

        /// <summary>
        /// Poll frequency changed.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void pollUpDown_ValueChanged(object sender, EventArgs e)
        {
            NumericUpDown ud = (NumericUpDown)sender;
            this.sleepTime = (int)ud.Value;
        }

        /// <summary>
        /// Handle double-click on cell.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void telltalesDataGridView_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            DataGridView dataGridView = (DataGridView)sender;
            int ix = e.RowIndex;
            DataGridViewRowCollection rows = dataGridView.Rows;
            if (ix >= 0 && ix < rows.Count)
            {
                DataGridViewRow row = rows[ix];
                DataGridViewCellCollection cellCollection = row.Cells;
                XmlClass.telltaleitem oldTelltaleItem = (XmlClass.telltaleitem)cellCollection["telltaleItem"].Value;
                bool newRow = row.IsNewRow;
                if (newRow)
                {
                    int n0 = rows.Add(1);
                    row = rows[n0];
                    cellCollection = row.Cells;
                    dataGridView.CurrentCell = cellCollection["telltaleItemName"];
                }

                if (oldTelltaleItem != null || newRow)
                {
                    uint[] used = new uint[0];
                    using (TelltaleDetails telltaleDetails = new TelltaleDetails(this.dataFileDir, this.iDataSource, oldTelltaleItem, used, this.paletteCreator))
                    {
                        if (telltaleDetails.ShowDialog() == DialogResult.OK)
                        {
                            XmlClass.telltaleitem newTelltaleItem = telltaleDetails.telltaleitem;
                            cellCollection["telltaleItem"].Value = newTelltaleItem;
                            cellCollection["telltaleFieldNumber"].Value = newTelltaleItem.telltaleGroupNumber;
                            cellCollection["telltalePrio"].Value = newTelltaleItem.telltalePriority;
                            cellCollection["telltaleItemName"].Value = telltaleDetails.pidName;
                            cellCollection["telltaleText"].Value = newTelltaleItem.telltaletext;
                            cellCollection["telltalePrimaryColor"].Style.BackColor = Color.FromName(newTelltaleItem.primaryColor);
                            cellCollection["telltaleSecondaryColor"].Style.BackColor = Color.FromName(newTelltaleItem.secondaryColor);
                            cellCollection["telltaleFlashColor"].Style.BackColor = Color.FromName(newTelltaleItem.flashColor);
                            cellCollection["telltaleSensor"].Value = telltaleDetails.sensorName;
                            cellCollection["telltaleSensorBit"].Value = telltaleDetails.sensorBit >= 0 ? telltaleDetails.sensorBit.ToString() : string.Empty;

                            this.setImage(cellCollection, newTelltaleItem.telltaleicon);

                            if (oldTelltaleItem != null && this.iDataSource.telltales.Contains(oldTelltaleItem))
                            {
                                this.iDataSource.telltales.Remove(oldTelltaleItem);
                            }

                            this.iDataSource.telltales.Add(newTelltaleItem);
                            this.dirty = true;
                        }
                        else
                        {
                            if (newRow)
                            {
                                try
                                {
                                    rows.Remove(row);
                                }
                                catch
                                {
                                    // Ignore.
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Handle deletion of row.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void telltalesDataGridView_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
        {
            DataGridViewRow row = e.Row;
            DataGridViewCellCollection rowcells = row.Cells;
            XmlClass.telltaleitem item = (XmlClass.telltaleitem)rowcells["telltaleItem"].Value;

            if (item != null)
            {
                string name = rowcells["telltaleText"].Value.ToString();

                if (MessageBox.Show(
                    "Do you want to delete '" + name + "'?",
                    "Confirm",
                    MessageBoxButtons.YesNo,
                    MessageBoxIcon.Warning,
                    MessageBoxDefaultButton.Button2) == DialogResult.No)
                {
                    e.Cancel = true;
                }
                else
                {
                    this.dirty = true;
                    this.iDataSource.telltales.Remove(item);
                }
            }
        }

        /// <summary>
        /// One sensor map item.
        /// </summary>
        private class TelltaleWrapper
        {
            /// <summary>
            /// Gets Telltale that is 'on'.
            /// </summary>
            public TellTale tellTaleOn { get; private set; }

            /// <summary>
            /// Gets Telltale that is 'off'.
            /// </summary>
            public TellTale tellTaleOff { get; private set; }

            /// <summary>
            /// Gets or sets a value indicating whether Current telltale status is active or not, 'true' for 'on'.
            /// </summary>
            public bool active { get; set; }

            /// <summary>
            /// Gets or sets a value indicating whether state changed for telltale, 'true' if telltale has changed state and needs to be redrawn.
            /// </summary>
            public bool changed { get; set; }

            /// <summary>
            /// Initializes a new instance of the <see cref="TelltaleWrapper" /> class.
            /// </summary>
            /// <param name="tellTaleOn">Telltale that is 'on'.</param>
            /// <param name="tellTaleOff">Telltale that is 'off'.</param>
            /// <param name="active">Current telltale status, 'true' for 'on'.</param>
            public TelltaleWrapper(TellTale tellTaleOn, TellTale tellTaleOff, bool active)
            {
                this.tellTaleOn = tellTaleOn;
                this.tellTaleOff = tellTaleOff;
                this.active = active;
                this.changed = true;
            }
        }

        /// <summary>
        /// One sensor map item.
        /// </summary>
        private class SensorMapItem
        {
            /// <summary>
            /// Gets Which data set part.
            /// </summary>
            public uint dataSet { get; private set; }

            /// <summary>
            /// Gets Mode for item.
            /// </summary>
            public byte mode { get; private set; }

            /// <summary>
            /// Gets PID for item.
            /// </summary>
            public uint pid { get; private set; }

            /// <summary>
            /// Gets Sensor for item.
            /// </summary>
            public XmlClass.pidgroup.pidlist.sensordata sensor { get; private set; }

            /// <summary>
            /// Gets Gauge number.
            /// </summary>
            public uint gauge { get; private set; }

            /// <summary>
            /// Gets Telltale item value.
            /// </summary>
            public XmlClass.telltaleitem telltaleItemValue { get; private set; }

            /// <summary>
            /// Gets Telltale icon.
            /// </summary>
            public Image icon { get; private set; }

            /// <summary>
            /// Initializes a new instance of the <see cref="SensorMapItem" /> class.
            /// </summary>
            /// <param name="dataSet">Data set number. (selects between analog, digital display or telltale)</param>
            /// <param name="gauge">Gauge number.</param>
            /// <param name="mode">Mode for item.</param>
            /// <param name="pid">PID for item.</param>
            /// <param name="sensor">Sensor for item.</param>
            /// <param name="telltaleItemValue">Telltale item description instance. (only for telltales.)</param>
            /// <param name="icon">Assigned telltale icon. (only for telltales.)</param>
            public SensorMapItem(
                uint dataSet,
                uint gauge,
                byte mode,
                uint pid,
                XmlClass.pidgroup.pidlist.sensordata sensor,
                XmlClass.telltaleitem telltaleItemValue,
                Image icon)
            {
                this.dataSet = dataSet;
                this.mode = mode;
                this.pid = pid;
                this.sensor = sensor;
                this.gauge = gauge;
                this.telltaleItemValue = telltaleItemValue;
                this.icon = icon;
            }

            /// <summary>
            /// Compute hashcode for item.
            /// </summary>
            /// <returns>Calculated hashcode.</returns>
            public override int GetHashCode()
            {
                int hc = (int)this.dataSet;
                hc = hc << 4 ^ hc >> 28;
                hc = hc ^ this.mode;
                hc = hc << 7 ^ hc >> 25;
                hc = hc ^ this.sensor.unit.GetHashCode();
                hc = hc << 7 ^ hc >> 25;
                hc = hc ^ (int)(this.sensor.offset & 0xffff);
                hc = hc << 7 ^ hc >> 25;
                hc = hc ^ (int)this.pid;

                if (!string.IsNullOrEmpty(this.sensor.startbit))
                {
                    hc = hc << 7 ^ hc >> 25;
                    hc = hc ^ (int)this.sensor.startbit.GetHashCode();
                }

                return hc;
            }

            /// <summary>
            /// Compare with another object.
            /// </summary>
            /// <param name="obj">Object to compare with.</param>
            /// <returns>'true' if match.</returns>
            public override bool Equals(object obj)
            {
                SensorMapItem sm1 = (SensorMapItem)obj;
                return sm1.dataSet == this.dataSet
                    && sm1.mode == this.mode
                    && sm1.pid == this.pid
                    && sm1.sensor.unit == this.sensor.unit
                    && sm1.sensor.offset == this.sensor.offset;
            }
        }
    }
}