//-----------------------------------------------------------------------
// <copyright file="PreferencesPanel.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
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.IO.Ports;
    using System.Linq;
    using System.Management;
    using System.Windows.Forms;
    using global::DataSource;
    using global::DataSource.FileAccess;
    using global::SharedObjects;
    using global::SharedObjects.DataMgmt;
    using global::SharedObjects.Misc;
    using global::UserInterface.GUI.Popup;

    /// <summary>
    /// Preferences panel declaration.
    /// </summary>
    public partial class PreferencesPanel : UserControl, IPreferences
    {
        /// <summary>
        /// Refresh interval alternatives.
        /// </summary>
        private static readonly string[] refreshIntervalArray =
        {
            "1:1",
            "1:10",
            "1:30",
            "1:60",
            "1:300",
        };

        /// <summary>
        /// Gets Refresh interval alternatives.
        /// </summary>
        public IList<string> refreshIntervals
        {
            get
            {
                return refreshIntervalArray.ToList<string>();
            }
        }

        /// <summary>
        /// Gets The currently selected unit category. (0=General, 1=Metric, 2=Imperial.)
        /// <para>
        /// Notice that "General" means that data will be presented in both metric and imperial.
        /// </para>
        /// </summary>
        public int selectedUnitCategory { get; private set; }

        /// <summary>
        /// Gets default timeout value.
        /// </summary>
        public int defaultTimeout { get; private set; }

        /// <summary>
        /// Gets threshold for when a secondary Y axis shall be used in charts.
        /// </summary>
        public int secondaryYThreshold { get; private set; }

        /// <summary>
        /// Gets OBD code database URI string.
        /// </summary>
        public string obdCodeDatabase { get; private set; }

        /// <summary>
        /// Gets a value indicating whether hints shall be enabled (when false) or disabled (when true).
        /// </summary>
        public bool advancedMode { get; private set; }

        /// <summary>
        /// Gets a value indicating whether features useful for development shall be available.
        /// <para>
        /// Notice that some of the features may be dangerous.
        /// </para>
        /// </summary>
        public bool developerMode { get; private set; }

        /// <summary>
        /// Gets Time in milliseconds to pause after sending a message.
        /// </summary>
        public int sendDelay { get; private set; }

        /// <summary>
        /// Gets Number of blocks accepted from peer before sending CTS.
        /// </summary>
        public byte blockSize { get; private set; }

        /// <summary>
        /// Gets Time in milliseconds to request that peer spaces it's frames with.
        /// </summary>
        public byte frameSpacing { get; private set; }

        /// <summary>
        /// Gets Name of GPS port.
        /// </summary>
        public string gpsSerialPortName { get; private set; }

        /// <summary>
        /// Preferences file access instance.
        /// </summary>
        private PreferencesFileAccess preferencesFileAccess;

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

        /// <summary>
        /// The beginners hint engine.
        /// </summary>
        private HintEngine hintEngine;

        /// <summary>
        /// Event logging instance.
        /// </summary>
        private ILogging iLogging;

        /// <summary>
        /// Gets preferences list instance.
        /// </summary>
        public IDictionary<string, XmlClass.preference> preferences
        {
            get
            {
                return this.preferencesFileAccess.preferences;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PreferencesPanel" /> class.
        /// </summary>
        /// <param name="iLogging">Current logging instance.</param>
        /// <param name="dataFileDir">Data file directory path.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Reviewed.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1806:DoNotIgnoreMethodResults", MessageId = "CanApp.CustomToolTip", Justification = "Reviewed.")]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1118:ParameterMustNotSpanMultipleLines", Justification = "Reviewed.")]
        public PreferencesPanel(ILogging iLogging, string dataFileDir)
        {
            this.iLogging = iLogging;
            this.selectedUnitCategory = 0;
            this.advancedMode = false;

            this.InitializeComponent();

            this.preferencesFileAccess = new PreferencesFileAccess(iLogging, DataSourceImplementation.PREFERENCES_FILE, dataFileDir);
            this.preferencesFileAccess.load();
            this.loadPreferences();

            this.initPreferredUnits();

            this.gpsSerialPortName = this.getPreference(Utils.GPS_SERIAL_PORT);
            this.iLogging.appendText("this.gpsSerialPortName='" + this.gpsSerialPortName + "'\r\n");

            string[] portNames = SerialPort.GetPortNames();

            List<string> portInfo = new List<string>();
            using (ManagementObjectSearcher searcher = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_PnPEntity WHERE ClassGuid = '{4d36e978-e325-11ce-bfc1-08002be10318}'"))
            {
                foreach (ManagementObject queryObj in searcher.Get())
                {
                    portInfo.Add(queryObj["Caption"].ToString());
                }
            }

            Array.Sort(portNames, new Utils.ComPortComparer());

            int ix = 1;
            int selIx = -1;
            this.gpsSerialPortNameComboBox.Items.Clear();

            this.gpsSerialPortNameComboBox.Items.Add(" Disabled ");

            foreach (string portName in portNames)
            {
                string dispName = portName;
                foreach (string caption in portInfo)
                {
                    if (caption.Contains("(" + portName + ")"))
                    {
                        dispName = caption;
                        break;
                    }
                }

                this.gpsSerialPortNameComboBox.Items.Add(dispName);

                if (this.gpsSerialPortName != null && this.gpsSerialPortName.Trim().Length > 0 && dispName.Contains("(" + this.gpsSerialPortName + ")"))
                {
                    selIx = ix;
                }

                ix++;
            }

            if (selIx >= 0)
            {
                this.gpsSerialPortNameComboBox.SelectedIndex = selIx;
            }
            else
            {
                this.gpsSerialPortNameComboBox.SelectedIndex = 0;
            }

            this.toolTip1.SetToolTip(this.advancedModeCB, "Disables the application hint balloons.");
            this.toolTip1.SetToolTip(
                this.sendDelayNumericUpDown,
                "Time to wait after sending one message to the ECU.\r\n"
                    + "Some ECUs can't handle full speed data traffic from the test tool.");
        }

        /// <summary>
        /// Register the hint engine so it can be turned on or off.
        /// </summary>
        /// <param name="hintEngine">Hint engine instance.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "hintEngine", Justification = "Reviewed, intentional.")]
        public void registerHintEngine(HintEngine hintEngine)
        {
            this.hintEngine = hintEngine;
        }

        /// <summary>
        /// Set the data source instance.
        /// </summary>
        /// <param name="iDataSource">Data source interface instance.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "iDataSource", Justification = "Reviewed, intentional.")]
        public void setDataSource(IDataSource iDataSource)
        {
            this.iDataSource = iDataSource;
        }

        /// <summary>
        /// Get integer preference value.
        /// </summary>
        /// <param name="preferenceName">Name of preference.</param>
        /// <returns>Integer value of preference, returns 0 at failure.</returns>
        public int getIntPreference(string preferenceName)
        {
            string value = this.getPreference(preferenceName);
            int intValue = 0;
            try
            {
                intValue = Convert.ToInt32(value);
            }
            catch
            {
            }

            return intValue;
        }

        /// <summary>
        /// Get Preference value by name.
        /// </summary>
        /// <param name="preferenceName">Name of preference to get value for.</param>
        /// <returns>String preference value.</returns>
        public string getPreference(string preferenceName)
        {
            string value = null;
            if (this.preferencesFileAccess.preferences.ContainsKey(preferenceName))
            {
                XmlClass.preference pref = this.preferencesFileAccess.preferences[preferenceName];
                value = pref.value;
            }

            return value;
        }

        /// <summary>
        /// Set Preference value.
        /// </summary>
        /// <param name="preferenceName">Name of preference.</param>
        /// <param name="value">Preference value.</param>
        public void setPreference(string preferenceName, string value)
        {
            XmlClass.preference pref;
            if (this.preferencesFileAccess.preferences.ContainsKey(preferenceName))
            {
                pref = this.preferencesFileAccess.preferences[preferenceName];
                pref.value = value;
            }
            else
            {
                pref = new XmlClass.preference();
                pref.name = preferenceName;
                pref.value = value;
                this.preferencesFileAccess.preferences.Add(preferenceName, pref);
            }

            this.preferencesFileAccess.save();
        }

        /// <summary>
        /// Load the preferences from file.
        /// </summary>
        private void loadPreferences()
        {
            this.selectedUnitCategory = this.getIntPreference(PreferencesFileAccess.UNITS);

            string site = this.getPreference(PreferencesFileAccess.OBDINFOSITE);
            if (site == null || site.Trim().Length == 0)
            {
                site = Utils.DEFAULT_OBD_CODE_SITE;
            }

            this.obdCodeDatabaseURI.Text = site;
            this.obdCodeDatabase = site;

            this.defaultTimeout = this.getIntPreference(PreferencesFileAccess.DEFAULT_TIMEOUT);
            if (this.defaultTimeout < this.timeoutUD.Minimum || this.defaultTimeout > this.timeoutUD.Maximum)
            {
                this.defaultTimeout = 1000;
                this.setPreference(PreferencesFileAccess.DEFAULT_TIMEOUT, this.defaultTimeout.ToString());
            }

            if (this.defaultTimeout >= this.timeoutUD.Minimum && this.defaultTimeout <= this.timeoutUD.Maximum)
            {
                this.timeoutUD.Value = this.defaultTimeout;
            }

            this.secondaryYThreshold = this.getIntPreference(PreferencesFileAccess.SECONDARY_Y_THRESHOLD);
            if (this.secondaryYThreshold >= this.secondaryYThresholdUD.Minimum && this.secondaryYThreshold <= this.secondaryYThresholdUD.Maximum)
            {
                this.secondaryYThresholdUD.Value = this.secondaryYThreshold;
            }

            int flag = this.getIntPreference(PreferencesFileAccess.ADVANCED_MODE);
            this.advancedMode = flag != 0;
            this.advancedModeCB.Checked = this.advancedMode;

            if (this.hintEngine != null)
            {
                this.hintEngine.activate(!this.advancedMode);
            }

            this.sendDelay = this.getIntPreference(PreferencesFileAccess.SEND_DELAY);

            // Error means that we probably are out of range.
            try
            {
                this.sendDelayNumericUpDown.Value = this.sendDelay;
            }
            catch
            {
                // Default to 20ms.
                this.sendDelayNumericUpDown.Value = 20;
            }

            this.blockSize = (byte)this.getIntPreference(PreferencesFileAccess.BLOCK_SIZE);

            // Error means that we probably are out of range.
            try
            {
                this.blockSizeNumericUpDown.Value = this.blockSize;
            }
            catch
            {
                // Default to 3 frames.
                this.blockSizeNumericUpDown.Value = 3;
                this.blockSize = 3;
            }

            this.frameSpacing = (byte)this.getIntPreference(PreferencesFileAccess.FRAME_SPACING);

            // Error means that we probably are out of range.
            try
            {
                this.frameSpacingNumericUpDown.Value = this.frameSpacing;
            }
            catch
            {
                // Default to 20 milliseconds.
                this.frameSpacingNumericUpDown.Value = 20;
                this.frameSpacing = 20;
            }
        }

        /// <summary>
        /// Preferred units changed event.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void preferredUnits_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox cb = (ComboBox)sender;
            this.selectedUnitCategory = cb.SelectedIndex;
            this.setPreference(PreferencesFileAccess.UNITS, this.selectedUnitCategory.ToString());

            if (this.iDataSource != null)
            {
                this.iDataSource.loadPidgroups();
            }
        }

        /// <summary>
        /// Initialize the preferred units.
        /// </summary>
        private void initPreferredUnits()
        {
            this.preferredUnits.Items.Clear();
            foreach (string str in Utils.unitCategories)
            {
                this.preferredUnits.Items.Add(str);
            }

            if (this.selectedUnitCategory >= 0 && this.selectedUnitCategory < this.preferredUnits.Items.Count)
            {
                this.preferredUnits.SelectedIndex = this.selectedUnitCategory;
            }
        }

        /// <summary>
        /// Timeout value has been changed by the user.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void timeoutUD_ValueChanged(object sender, EventArgs e)
        {
            this.defaultTimeout = (int)this.timeoutUD.Value;
            this.setPreference(PreferencesFileAccess.DEFAULT_TIMEOUT, this.defaultTimeout.ToString());
        }

        /// <summary>
        /// Validate the URI.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1806:DoNotIgnoreMethodResults", MessageId = "System.Uri", Justification = "Reviewed, intentional.")]
        private void obdCodeDatabaseURI_Validating(object sender, CancelEventArgs e)
        {
            string txt = this.obdCodeDatabaseURI.Text;
            try
            {
                new Uri(txt);
            }
            catch (UriFormatException ex)
            {
                string errtxt = ex.Message + "\r\n";
                errtxt += "Click OK to go back to old (default) value, Cancel to edit the current invalid value.";
                if (MessageBox.Show(
                    errtxt,
                    "Error",
                    MessageBoxButtons.OKCancel,
                    MessageBoxIcon.Error,
                    MessageBoxDefaultButton.Button2) == DialogResult.Cancel)
                {
                    e.Cancel = true;
                }
                else
                {
                    this.obdCodeDatabaseURI.Text = this.obdCodeDatabase;
                }
            }
        }

        /// <summary>
        /// When URI has been validated.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void obdCodeDatabaseURI_Validated(object sender, EventArgs e)
        {
            this.obdCodeDatabase = this.obdCodeDatabaseURI.Text;
        }

        /// <summary>
        /// Test the URI.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void uriTestButton_Click(object sender, EventArgs e)
        {
            try
            {
                System.Diagnostics.Process.Start(this.obdCodeDatabase + "P0420");
            }
            catch (Win32Exception ex)
            {
                MessageBox.Show(
                    "'" + this.obdCodeDatabase + "'\r\n" + ex.Message,
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// Changes of the Secondary Y axis threshold.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void secondaryYThresholdUD_ValueChanged(object sender, EventArgs e)
        {
            this.secondaryYThreshold = (int)this.secondaryYThresholdUD.Value;
            this.setPreference(PreferencesFileAccess.SECONDARY_Y_THRESHOLD, this.secondaryYThreshold.ToString());
        }

        /// <summary>
        /// Handle checkbox toggle.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void advancedModeCB_CheckedChanged(object sender, EventArgs e)
        {
            this.advancedMode = this.advancedModeCB.Checked;
            this.setPreference(PreferencesFileAccess.ADVANCED_MODE, this.advancedMode ? "1" : "0");

            if (this.hintEngine != null)
            {
                this.hintEngine.activate(!this.advancedMode);
            }
        }

        /// <summary>
        /// Handle change of GPS serial port name.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void gpsSerialPortNameComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            string str = this.gpsSerialPortNameComboBox.Text;
            string s2 = null;
            if (str.StartsWith(" "))
            {
                s2 = string.Empty;
            }
            else
            {
                int ix = str.IndexOf("(COM");
                if (ix >= 0)
                {
                    s2 = str.Substring(ix + 1);
                    int ix2 = s2.IndexOf(')');
                    s2 = s2.Substring(0, ix2);
                }
                else
                {
                    if (str.StartsWith("COM"))
                    {
                        s2 = str;
                    }
                }

                this.iLogging.appendText("Port='" + s2 + "'\r\n");
            }

            if (s2 != null)
            {
                this.gpsSerialPortName = s2;
                this.setPreference(Utils.GPS_SERIAL_PORT, this.gpsSerialPortName);
            }
        }

        /// <summary>
        /// Toggle developer mode.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void developerModeCB_CheckedChanged(object sender, EventArgs e)
        {
            this.developerMode = this.developerModeCB.Checked;
            this.setPreference(PreferencesFileAccess.DEVELOPER_MODE, this.developerMode ? "1" : "0");
        }

        /// <summary>
        /// Handle change of send delay.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void sendDelayNumericUpDown_ValueChanged(object sender, EventArgs e)
        {
            NumericUpDown numericUpDown = (NumericUpDown)sender;
            this.sendDelay = (int)numericUpDown.Value;
            this.setPreference(PreferencesFileAccess.SEND_DELAY, this.sendDelay.ToString());
        }

        /// <summary>
        /// Handle change of block size.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void blockSizeNumericUpDown_ValueChanged(object sender, EventArgs e)
        {
            NumericUpDown numericUpDown = (NumericUpDown)sender;
            this.blockSize = (byte)numericUpDown.Value;
            this.setPreference(PreferencesFileAccess.BLOCK_SIZE, this.blockSize.ToString());
        }

        /// <summary>
        /// Handle change of frame spacing.
        /// </summary>
        /// <param name="sender">Sending object.</param>
        /// <param name="e">Event data.</param>
        private void frameSpacingNumericUpDown_ValueChanged(object sender, EventArgs e)
        {
            NumericUpDown numericUpDown = (NumericUpDown)sender;
            this.frameSpacing = (byte)numericUpDown.Value;
            this.setPreference(PreferencesFileAccess.FRAME_SPACING, this.frameSpacing.ToString());
        }
    }
}