//-----------------------------------------------------------------------
// <copyright file="TelltaleDetails.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.ComponentModel;
    using System.Drawing;
    using System.Windows.Forms;
    using global::Gauges.TelltalePanel;
    using global::SharedObjects.DataMgmt;
    using global::SharedObjects.Misc;

    /// <summary>
    /// Class for editing details for a telltale.
    /// </summary>
    public partial class TelltaleDetails : Form
    {
        /// <summary>
        /// Gets telltale item instance.
        /// </summary>
        public XmlClass.telltaleitem telltaleitem { get; private set; }

        /// <summary>
        /// Gets PID name.
        /// </summary>
        public string pidName { get; private set; }

        /// <summary>
        /// Gets Sensor name.
        /// </summary>
        public string sensorName { get; private set; }

        /// <summary>
        /// Gets Sensor bit.
        /// </summary>
        public int sensorBit { get; private set; }

        /// <summary>
        /// Gets PID name.
        /// </summary>
        public string digitalPidName { get; private set; }

        /// <summary>
        /// List of PID groups.
        /// </summary>
        private IList<XmlClass.pidgroup> pidgrouplist;

        /// <summary>
        /// List of PIDs in PID Group with bit sensors.
        /// </summary>
        private IList<XmlClass.pidgroup.pidlist> pidgrouppids;

        /// <summary>
        /// List of sensors on current PID.
        /// </summary>
        private IList<XmlClass.pidgroup.pidlist.sensordata> pidsensors;

        /// <summary>
        /// Current PID group.
        /// </summary>
        private XmlClass.pidgroup pidgroup;

        /// <summary>
        /// Current PID.
        /// </summary>
        private XmlClass.pidgroup.pidlist pid;

        /// <summary>
        /// Current sensor.
        /// </summary>
        private XmlClass.pidgroup.pidlist.sensordata sensor;

        /// <summary>
        /// Array of used telltales, used to avoid double-booking telltales.
        /// </summary>
        private uint[] usedItems;

        /// <summary>
        /// Current data source instance.
        /// </summary>
        private IDataSource iDataSource;

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

        /// <summary>
        /// Current color palette.
        /// </summary>
        private PaletteCreator palette;

        /// <summary>
        /// Initializes a new instance of the <see cref="TelltaleDetails" /> class.
        /// </summary>
        /// <param name="dataFileDir">Data file directory.</param>
        /// <param name="iDataSource">Data source instance.</param>
        /// <param name="telltaleitem">Telltale item.</param>
        /// <param name="usedItems">Array of used telltales, used to avoid double-booking telltales.</param>
        /// <param name="palette">Initial color palette.</param>
        public TelltaleDetails(
            string dataFileDir,
            IDataSource iDataSource,
            XmlClass.telltaleitem telltaleitem,
            uint[] usedItems,
            PaletteCreator palette)
        {
            this.dataFileDir = dataFileDir;
            this.iDataSource = iDataSource;
            this.telltaleitem = telltaleitem;
            this.usedItems = usedItems;
            this.palette = palette;

            this.sensorBit = -1;
            IList<XmlClass.pidgroup> providedPidGroups = this.iDataSource.restrictedPidgroups;
            this.pidgrouplist = new List<XmlClass.pidgroup>();

            if (this.telltaleitem == null)
            {
                this.telltaleitem = new XmlClass.telltaleitem();
            }

            this.InitializeComponent();

            this.pidgrouppids = new List<XmlClass.pidgroup.pidlist>();

            for (int i1 = -99; i1 < 100; i1++)
            {
                this.priorityComboBox.Items.Add(i1.ToString());
            }

            this.priorityComboBox.SelectedIndex = 99 + this.telltaleitem.telltalePriority;

            this.telltaleGroupNumTB.Text = this.telltaleitem.telltaleGroupNumber.ToString();
            this.telltaleTextTB.Text = this.telltaleitem.telltaletext;

            this.pidGroupsCB.Items.Clear();
            this.itemCB.Items.Clear();
            this.sensorLB.Items.Clear();
            this.pidGroupsCB.SelectedIndex = -1;

            int pidGrpIx = -1;
            int i = 0;

            foreach (XmlClass.pidgroup pidGrp in providedPidGroups)
            {
                bool hasBit = false;
                if (pidGrp.pids != null)
                {
                    foreach (XmlClass.pidgroup.pidlist pid in pidGrp.pids)
                    {
                        if (pid != null)
                        {
                            foreach (XmlClass.pidgroup.pidlist.sensordata sensor in pid.sensors)
                            {
                                if (sensor.unit == "bit")
                                {
                                    hasBit = true;
                                    break;
                                }
                            }
                        }

                        if (hasBit)
                        {
                            break;
                        }
                    }
                }

                if (hasBit)
                {
                    this.pidGroupsCB.Items.Add(pidGrp.name);
                    this.pidgrouplist.Add(pidGrp);

                    if (this.telltaleitem != null
                        && this.telltaleitem.pidgroupid == pidGrp.id)
                    {
                        pidGrpIx = i;
                    }

                    i++;
                }
            }

            if (this.pidGroupsCB.Items.Count > 0)
            {
                if (pidGrpIx >= 0 && pidGrpIx < this.pidGroupsCB.Items.Count)
                {
                    this.pidGroupsCB.SelectedIndex = pidGrpIx;
                }
                else
                {
                    this.pidGroupsCB.SelectedIndex = 0;
                }
            }

            this.setIconImage(this.telltaleitem.telltaleicon);

            if (this.telltaleitem != null)
            {
                this.primaryColorBox.BackColor = string.IsNullOrEmpty(this.telltaleitem.primaryColor) ? Color.Transparent : Color.FromName(this.telltaleitem.primaryColor);
                this.secondaryColorBox.BackColor = string.IsNullOrEmpty(this.telltaleitem.secondaryColor) ? Color.Transparent : Color.FromName(this.telltaleitem.secondaryColor);
                this.flashColorBox.BackColor = string.IsNullOrEmpty(this.telltaleitem.flashColor) ? Color.Transparent : Color.FromName(this.telltaleitem.flashColor);
            }
            else
            {
                this.primaryColorBox.BackColor = Color.Transparent;
                this.secondaryColorBox.BackColor = Color.Transparent;
                this.flashColorBox.BackColor = Color.Transparent;
            }
        }

        /// <summary>
        /// Numeric validation of input data.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        /// <returns>Parsed numeric value.</returns>
        private static uint numericIntValidation(object sender, CancelEventArgs e)
        {
            TextBox tb = (TextBox)sender;
            uint scaleSteps = 0;
            try
            {
                scaleSteps = Convert.ToUInt32(tb.Text);
            }
            catch
            {
                MessageBox.Show(
                    "Field must be numeric.",
                    "Data Failure",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Exclamation);
                e.Cancel = true;
            }

            return scaleSteps;
        }

        /// <summary>
        /// Test for float value.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        /// <returns>Parsed float value.</returns>
        private static float numericFloatValidation(object sender, CancelEventArgs e)
        {
            TextBox tb = (TextBox)sender;
            float value = 0;
            try
            {
                value = Convert.ToSingle(tb.Text);
            }
            catch
            {
                MessageBox.Show(
                    "Field must be numeric.",
                    "Data Failure",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Exclamation);
                e.Cancel = true;
            }

            return value;
        }

        /// <summary>
        /// PidGroup checkbox change.
        /// </summary>
        /// <param name="pidgroup">Current PID group.</param>
        /// <param name="cb">Combobox that changed.</param>
        /// <param name="pidgrouplist">List of valid PID groups.</param>
        /// <param name="offset">Offset value in combo box index.</param>
        /// <returns>New PID group or 'null' if not applicable.</returns>
        private static XmlClass.pidgroup pidGroupChange(
            XmlClass.pidgroup pidgroup,
            ComboBox cb,
            IList<XmlClass.pidgroup> pidgrouplist,
            int offset)
        {
            if (cb.SelectedIndex >= offset && cb.SelectedIndex < cb.Items.Count)
            {
                pidgroup = pidgrouplist[cb.SelectedIndex - offset];
            }
            else
            {
                if (offset == 1)
                {
                    pidgroup = null;
                }
            }

            return pidgroup;
        }

        /// <summary>
        /// Update Item Combo Box.
        /// </summary>
        /// <param name="pidgroup">Current PID group.</param>
        /// <param name="itemCB">Items combobox.</param>
        /// <param name="telltalePid_int">PID value.</param>
        /// <param name="pidgrouppids">Actual available list of PIDs in PID group. (out data)</param>
        private static void updateItemCB(XmlClass.pidgroup pidgroup, ComboBox itemCB, uint telltalePid_int, IList<XmlClass.pidgroup.pidlist> pidgrouppids)
        {
            int pidIx = -1;
            int i = 0;
            foreach (XmlClass.pidgroup.pidlist pidItem in pidgroup.pids)
            {
                bool hasBit = false;
                foreach (XmlClass.pidgroup.pidlist.sensordata sensor in pidItem.sensors)
                {
                    if (sensor.unit == "bit")
                    {
                        hasBit = true;
                        break;
                    }
                }

                if (hasBit)
                {
                    itemCB.Items.Add(pidItem.name);
                    pidgrouppids.Add(pidItem);

                    if (telltalePid_int == pidItem.pid_int)
                    {
                        pidIx = i;
                    }

                    i++;
                }
            }

            if (pidIx >= 0 && pidIx < itemCB.Items.Count)
            {
                itemCB.SelectedIndex = pidIx;
            }
            else
            {
                if (itemCB.Items.Count > 0)
                {
                    itemCB.SelectedIndex = 0;
                }
            }
        }

        /// <summary>
        /// Change data for item combo box.
        /// </summary>
        /// <param name="cb">Item combo box instance.</param>
        /// <param name="sensorCB">Sensor combo box instance.</param>
        /// <param name="pids">List of current PIDs supporting telltales.</param>
        /// <param name="telltaleitem">Telltale item instance.</param>
        /// <param name="pid">Selected PID.</param>
        /// <param name="pidsensors">List of valid sensors for selected pid.</param>
        /// <returns>PID name.</returns>
        private static string itemCbChange(
            ComboBox cb,
            ListBox sensorCB,
            IList<XmlClass.pidgroup.pidlist> pids,
            XmlClass.telltaleitem telltaleitem,
            ref XmlClass.pidgroup.pidlist pid,
            IList<XmlClass.pidgroup.pidlist.sensordata> pidsensors)
        {
            string pidName = string.Empty;

            sensorCB.Items.Clear();
            pid = pids[cb.SelectedIndex];
            pidName = pid.name;
            int sensorIx = -1;
            int i = 0;

            foreach (XmlClass.pidgroup.pidlist.sensordata sensorItem in pid.sensors)
            {
                try
                {
                    if (sensorItem.unit == "bit")
                    {
                        string sensorInfo = string.Empty;
                        if (sensorItem.name != null)
                        {
                            sensorInfo += sensorItem.name + " ";
                        }

                        sensorInfo += "(" + sensorItem.unit + ")";
                        sensorCB.Items.Add(sensorInfo);
                        pidsensors.Add(sensorItem);
                        int sensorBit = Convert.ToInt32(sensorItem.startbit);

                        if (telltaleitem != null
                            && telltaleitem.sensor_unit != null
                            && telltaleitem.sensor_unit.Equals(sensorItem.unit)
                            && telltaleitem.sensor_offset == sensorItem.offset
                            && (sensorBit == -1 || telltaleitem.sensor_bit == sensorBit))
                        {
                            sensorIx = i;
                        }

                        i++;
                    }
                }
                catch
                {
                }
            }

            if (sensorIx >= 0 && sensorIx < sensorCB.Items.Count)
            {
                sensorCB.SelectedIndex = sensorIx;
            }
            else
            {
                if (sensorCB.Items.Count > 0)
                {
                    sensorCB.SelectedIndex = 0;
                }
            }

            return pidName;
        }

        /// <summary>
        /// OK button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void okButton_Click(object sender, EventArgs e)
        {
            if (this.primaryColorBox.BackColor != Color.Transparent
                && this.secondaryColorBox.BackColor != Color.Transparent
                && this.flashColorBox.BackColor != Color.Transparent)
            {
                this.telltaleitem.pidgroupid = this.pidgroup.id;
                this.telltaleitem.pid_int = this.pid.pid_int;
                this.telltaleitem.sensor_unit = this.sensor.unit;
                this.telltaleitem.sensor_offset = this.sensor.offset;
                this.telltaleitem.sensor_bit = this.sensorBit;
                this.telltaleitem.telltaletext = this.telltaleTextTB.Text;
                this.telltaleitem.telltalePriority = this.priorityComboBox.SelectedIndex - 99;

                this.telltaleitem.primaryColor = this.primaryColorBox.BackColor.Name;
                this.telltaleitem.secondaryColor = this.secondaryColorBox.BackColor.Name;
                this.telltaleitem.flashColor = this.flashColorBox.BackColor.Name;

                this.DialogResult = DialogResult.OK;

                this.Close();
            }
            else
            {
                MessageBox.Show("Colors must be assigned.", "Incomplete Configuration.", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }

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

        /// <summary>
        /// PID group changed.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void pidGroupsCB_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.pidgroup = pidGroupChange(
                this.pidgroup,
                (ComboBox)sender,
                this.pidgrouplist,
                0);

            this.itemCB.Items.Clear();
            this.sensorLB.Items.Clear();
            this.pidName = string.Empty;
            this.pidgrouppids = new List<XmlClass.pidgroup.pidlist>();

            if (this.pidgroup != null)
            {
                updateItemCB(this.pidgroup, this.itemCB, this.telltaleitem.pid_int, this.pidgrouppids);
            }

            this.setOkButtonEnable();
        }

        /// <summary>
        /// Check if conditions are right to enable the OK button and enable it if that's the case.
        /// </summary>
        private void setOkButtonEnable()
        {
            this.okButton.Enabled =
                (this.pidgroup != null)
                && (this.pid != null)
                && (this.sensor != null)
                && !string.IsNullOrEmpty(this.telltaleitem.telltaleicon);
        }

        /// <summary>
        /// Item combo box changed.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void itemCB_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox cb = (ComboBox)sender;
            if (this.pidgroup != null
                && cb.SelectedIndex >= 0
                && cb.SelectedIndex < cb.Items.Count
                && cb.SelectedIndex < this.pidgrouppids.Count)
            {
                this.pidsensors = new List<XmlClass.pidgroup.pidlist.sensordata>();
                this.pidName = itemCbChange(cb, this.sensorLB, this.pidgrouppids, this.telltaleitem, ref this.pid, this.pidsensors);
            }

            this.setOkButtonEnable();
        }

        /// <summary>
        /// Sensor list box changed.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void sensorLB_SelectedIndexChanged(object sender, EventArgs e)
        {
            ListBox cb = (ListBox)sender;

            if (cb.SelectedIndex >= 0 && cb.SelectedIndex < this.sensorLB.Items.Count)
            {
                this.sensor = this.pidsensors[cb.SelectedIndex];
                this.sensorName = cb.Text;
                this.sensorBit = -1;

                try
                {
                    this.sensorBit = Convert.ToInt32(this.sensor.startbit);
                }
                catch
                {
                }
            }

            this.setOkButtonEnable();
        }

        /// <summary>
        /// Sensor combo box changed.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void sensorCB_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox cb = (ComboBox)sender;

            if (cb.SelectedIndex >= 0 && cb.SelectedIndex < this.itemCB.Items.Count)
            {
                this.sensor = this.pid.sensors[cb.SelectedIndex];
                this.sensorName = cb.Text;
                this.sensorBit = -1;

                try
                {
                    this.sensorBit = Convert.ToInt32(this.sensor.startbit);
                }
                catch
                {
                }

                this.telltaleitem.sensor_bit = this.sensorBit;
            }

            this.setOkButtonEnable();
        }

        /// <summary>
        /// Select telltale.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void button1_Click(object sender, EventArgs e)
        {
            TelltaleAreaSelector gs = new TelltaleAreaSelector(this.telltaleitem.telltaleGroupNumber, this.usedItems);

            try
            {
                if (gs.ShowDialog() == System.Windows.Forms.DialogResult.OK && gs.selectedItem != null)
                {
                    this.telltaleitem.telltaleGroupNumber = (uint)gs.selectedItem;
                    this.telltaleGroupNumTB.Text = this.telltaleitem.telltaleGroupNumber.ToString();
                }
            }
            finally
            {
                gs.Dispose();
            }
        }

        /// <summary>
        /// Update the icon.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void selectIconButton_Click(object sender, EventArgs e)
        {
            TelltaleIconSelector telltaleIconSelector = new TelltaleIconSelector(this.dataFileDir, this.iDataSource, this.telltaleitem.telltaleicon);
            try
            {
                if (telltaleIconSelector.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    string newFile = telltaleIconSelector.selectedIcon;

                    try
                    {
                        this.setIconImage(newFile);
                        this.telltaleitem.telltaleicon = newFile;
                    }
                    finally
                    {
                        this.setOkButtonEnable();
                    }
                }
            }
            finally
            {
                telltaleIconSelector.Dispose();
            }
        }

        /// <summary>
        /// Set the image.
        /// </summary>
        /// <param name="newFile">Icon image file name.</param>
        private void setIconImage(string newFile)
        {
            if (newFile != null)
            {
                try
                {
                    Image img = Image.FromFile(this.dataFileDir + "Icons\\" + newFile);

                    float scale = 0.9F;
                    int height = this.iconPictureBox.Height;
                    int width = this.iconPictureBox.Width;

                    Bitmap bmp = Utils.getScaledImage(img, height, width, scale);

                    this.iconPictureBox.Image = bmp;
                }
                catch
                {
                    MessageBox.Show(
                        "Unable to open icon file '" + this.dataFileDir + "Icons\\" + newFile + "'",
                        "Error",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Hand);
                }
            }
        }

        /// <summary>
        /// Color button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void primaryColorButton_Click(object sender, EventArgs e)
        {
            using (ColorSelector colorSelector = new ColorSelector(this.primaryColorBox.BackColor, this.palette))
            {
                if (colorSelector.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    this.primaryColorBox.BackColor = colorSelector.Color;
                }
            }
        }

        /// <summary>
        /// Color button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void secondaryColorButton_Click(object sender, EventArgs e)
        {
            using (ColorSelector colorSelector = new ColorSelector(this.secondaryColorBox.BackColor, this.palette))
            {
                if (colorSelector.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    this.secondaryColorBox.BackColor = colorSelector.Color;
                }
            }
        }

        /// <summary>
        /// Color button clicked.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void flashColorButton_Click(object sender, EventArgs e)
        {
            using (ColorSelector colorSelector = new ColorSelector(this.flashColorBox.BackColor, this.palette))
            {
                if (colorSelector.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                {
                    this.flashColorBox.BackColor = colorSelector.Color;
                }
            }
        }
    }
}