using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace FCC_Uber_MDX_Configurator
{
    public partial class SpeechConfigForm : Form
    {
        public SpeechConfigForm()
        {
            InitializeComponent();
            UpdateAllListsOfDoom();
            UpdateCheckedTSMI();
        }

        private void UpdateAllListsOfDoom()
        {
            LIST_SYSTEM.Items.Clear();
            TSB_SYSTEM_DELETE.Enabled = (GlobalStaticClass.Speech_StaticSetupClass.generic_system.Count > 0);
            foreach (string _s in GlobalStaticClass.Speech_StaticSetupClass.generic_system)
            {
                LIST_SYSTEM.Items.Add(_s);
            }


            LIST_SYS_DEFINITIONS_DO_GENERIC.Items.Clear();
            LIST_SYS_DEFINITIONS_DO_TURNON.Items.Clear();
            LIST_SYS_DEFINITIONS_DO_TURNOFF.Items.Clear();
            LIST_SYS_DEFINITIONS_AI_GENERIC.Items.Clear();
            LIST_SYS_DEFINITIONS_AI_GENQUERY.Items.Clear();
            TSB_SYSDEF_DELETE.Enabled = (GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output.Count +
                GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on.Count +
                GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off.Count +
                GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input.Count +
                GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read.Count > 0);
            foreach (string _s in GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output)
            {
                LIST_SYS_DEFINITIONS_DO_GENERIC.Items.Add(_s);
            }
            foreach (string _s in GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on)
            {
                LIST_SYS_DEFINITIONS_DO_TURNON.Items.Add(_s);
            }
            foreach (string _s in GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off)
            {
                LIST_SYS_DEFINITIONS_DO_TURNOFF.Items.Add(_s);
            }
            foreach (string _s in GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input)
            {
                LIST_SYS_DEFINITIONS_AI_GENERIC.Items.Add(_s);
            }
            foreach (string _s in GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read)
            {
                LIST_SYS_DEFINITIONS_AI_GENQUERY.Items.Add(_s);
            }


            LIST_CUSTOM_DEFINITIONS_DO.Items.Clear();
            LIST_CUSTOM_DEFINITIONS_VAR.Items.Clear();
            TSB_CUSTOMDEF_DELETE.Enabled = (GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs.Count + GlobalStaticClass.Speech_StaticSetupClass.custom_definition_variables.Count > 0);
            foreach (GlobalStaticClass.Speech_StaticSetupClass.customDefinition _cD in GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs)
            {
                LIST_CUSTOM_DEFINITIONS_DO.Items.Add(_cD.systemName + " -- " + _cD.spokenName);
            }
            foreach (GlobalStaticClass.Speech_StaticSetupClass.customDefinition _cD in GlobalStaticClass.Speech_StaticSetupClass.custom_definition_variables)
            {
                LIST_CUSTOM_DEFINITIONS_VAR.Items.Add(_cD.systemName + " -- " + _cD.spokenName);
            }


            LIST_CUSTOM_QUERIES.Items.Clear();
            TSB_CUSTOMQUER_DELETE.Enabled = (GlobalStaticClass.Speech_StaticSetupClass.custom_query_list.Count > 0);
            foreach (GlobalStaticClass.Speech_StaticSetupClass.customQuery _CQ in GlobalStaticClass.Speech_StaticSetupClass.custom_query_list)
            {
                LIST_CUSTOM_QUERIES.Items.Add(_CQ.monitor_type + " -> " + _CQ.monitor_id);
            }


            LIST_ALLCOMMANDS.Items.Clear();
            GlobalStaticClass.AllPossibleSpeechStrings.Clear();
            bool removeFirst_system = false;
            bool removeFirst_do_on = false;
            bool removeFirst_do_off = false;
            bool removeFirst_do = false;
            bool removeFirst_ai_read = false;
            bool removeFirst_ai = false;

            if (GlobalStaticClass.Speech_StaticSetupClass.generic_system.Count == 0 || !GlobalStaticClass.Speech_StaticSetupClass.generic_system.Contains(""))
            {
                GlobalStaticClass.Speech_StaticSetupClass.generic_system.Add("");
                removeFirst_system = true;
            }
            if (GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on.Count == 0)
            {
                GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on.Add("turn on");
                removeFirst_do_on = true;
            }
            if (GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off.Count == 0)
            {
                GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off.Add("turn off");
                removeFirst_do_off = true;
            }
            if (GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output.Count == 0)
            {
                GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output.Add("output");
                removeFirst_do = true;
            }

            if (GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read.Count == 0)
            {
                GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read.Add("What is the value of");
                removeFirst_ai_read = true;
            }
            if (GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input.Count == 0)
            {
                GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input.Add("input");
                removeFirst_ai = true;
            }

            for (int i_generic_system_count = 0; i_generic_system_count < GlobalStaticClass.Speech_StaticSetupClass.generic_system.Count; i_generic_system_count++)
            {
                for (int i_generic_digital_output_turn_on_count = 0; i_generic_digital_output_turn_on_count < GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on.Count; i_generic_digital_output_turn_on_count++)
                {
                    for (int i_generic_digital_output_count = 0; i_generic_digital_output_count < GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output.Count; i_generic_digital_output_count++)
                    {
                        for (int i_brain_count = 0; i_brain_count < GlobalStaticClass._Global_List_Brains.Count; i_brain_count++)
                        {
                            for (int i_digital_output_channel = 0; i_digital_output_channel < GlobalStaticClass._Global_List_DigitalOutputs.Count; i_digital_output_channel++)
                            {
                                if (GlobalStaticClass._Global_List_DigitalOutputs[i_digital_output_channel].BrainID.ToLower() != GlobalStaticClass._Global_List_Brains[i_brain_count]._humanName.ToLower())
                                {
                                    continue;
                                }
                                int _NUM = GlobalStaticClass._Global_List_DigitalOutputs[i_digital_output_channel].Port + (GlobalStaticClass.FUSIONBRAIN_NUMBEROF_DIGITAL_OUTPUTS * i_brain_count);
                                string possibleSpeechCommandString = GlobalStaticClass.Speech_StaticSetupClass.generic_system[i_generic_system_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on[i_generic_digital_output_turn_on_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output[i_generic_digital_output_count] + " " + _NUM.ToString();
                                GlobalStaticClass.AllPossibleSpeechStrings.Add(possibleSpeechCommandString); 
                            }
                        }
                    }
                    for (int i_custom_digital_output_count = 0; i_custom_digital_output_count < GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs.Count; i_custom_digital_output_count++)
                    {
                        for (int i_digital_output_channel = 0; i_digital_output_channel < GlobalStaticClass._Global_List_DigitalOutputs.Count; i_digital_output_channel++)
                        {
                            if (GlobalStaticClass._Global_List_DigitalOutputs[i_digital_output_channel].id.ToLower() != GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs[i_custom_digital_output_count].systemName.ToLower())
                            {
                                continue;
                            }
                            string possibleSpeechCommandString = GlobalStaticClass.Speech_StaticSetupClass.generic_system[i_generic_system_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on[i_generic_digital_output_turn_on_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs[i_custom_digital_output_count].spokenName;
                            GlobalStaticClass.AllPossibleSpeechStrings.Add(possibleSpeechCommandString);
                        }
                    }
                }
                for (int i_generic_digital_output_turn_off_count = 0; i_generic_digital_output_turn_off_count < GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off.Count; i_generic_digital_output_turn_off_count++)
                {
                    for (int i_generic_digital_output_count = 0; i_generic_digital_output_count < GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output.Count; i_generic_digital_output_count++)
                    {
                        for (int i_brain_count = 0; i_brain_count < GlobalStaticClass._Global_List_Brains.Count; i_brain_count++)
                        {
                            for (int i_digital_output_channel = 0; i_digital_output_channel < GlobalStaticClass._Global_List_DigitalOutputs.Count; i_digital_output_channel++)
                            {
                                if (GlobalStaticClass._Global_List_DigitalOutputs[i_digital_output_channel].BrainID.ToLower() != GlobalStaticClass._Global_List_Brains[i_brain_count]._humanName.ToLower())
                                {
                                    continue;
                                }
                                int _NUM = GlobalStaticClass._Global_List_DigitalOutputs[i_digital_output_channel].Port + (GlobalStaticClass.FUSIONBRAIN_NUMBEROF_DIGITAL_OUTPUTS * i_brain_count);
                                string possibleSpeechCommandString = GlobalStaticClass.Speech_StaticSetupClass.generic_system[i_generic_system_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off[i_generic_digital_output_turn_off_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output[i_generic_digital_output_count] + " " + _NUM.ToString();
                                GlobalStaticClass.AllPossibleSpeechStrings.Add(possibleSpeechCommandString);
                            }
                        }
                    }
                    for (int i_custom_digital_output_count = 0; i_custom_digital_output_count < GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs.Count; i_custom_digital_output_count++)
                    {
                        for (int i_digital_output_channel = 0; i_digital_output_channel < GlobalStaticClass._Global_List_DigitalOutputs.Count; i_digital_output_channel++)
                        {
                            if (GlobalStaticClass._Global_List_DigitalOutputs[i_digital_output_channel].id.ToLower() != GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs[i_custom_digital_output_count].systemName.ToLower())
                            {
                                continue;
                            }
                            string possibleSpeechCommandString = GlobalStaticClass.Speech_StaticSetupClass.generic_system[i_generic_system_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off[i_generic_digital_output_turn_off_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs[i_custom_digital_output_count].spokenName;
                            GlobalStaticClass.AllPossibleSpeechStrings.Add(possibleSpeechCommandString);
                        }
                    }
                }
                for (int i_generic_analogue_input_query_count = 0; i_generic_analogue_input_query_count < GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read.Count; i_generic_analogue_input_query_count++)
                {
                    for (int i_generic_analogue_input_count = 0; i_generic_analogue_input_count < GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input.Count; i_generic_analogue_input_count++)
                    {
                        for (int i_brain_count = 0; i_brain_count < GlobalStaticClass._Global_List_Brains.Count; i_brain_count++)
                        {
                            for (int i_analogue_input_channel = 0; i_analogue_input_channel < GlobalStaticClass._Global_List_AnalogueInputs.Count; i_analogue_input_channel++)
                            {
                                if (GlobalStaticClass._Global_List_AnalogueInputs[i_analogue_input_channel].BrainID.ToLower() != GlobalStaticClass._Global_List_Brains[i_brain_count]._humanName.ToLower())
                                {
                                    continue;
                                }
                                int _NUM = GlobalStaticClass._Global_List_AnalogueInputs[i_analogue_input_channel].Port + (GlobalStaticClass.FUSIONBRAIN_NUMBEROF_ANALOGUE_INPUTS * i_brain_count);
                                string possibleSpeechCommandString = GlobalStaticClass.Speech_StaticSetupClass.generic_system[i_generic_system_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read[i_generic_analogue_input_query_count] + " " + GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input[i_generic_analogue_input_count] + " " + _NUM.ToString();
                                GlobalStaticClass.AllPossibleSpeechStrings.Add(possibleSpeechCommandString);
                            }
                        }
                    }
                }
                foreach (GlobalStaticClass.Speech_StaticSetupClass.customQuery _cQ in GlobalStaticClass.Speech_StaticSetupClass.custom_query_list)
                {
                    List<string> build_queries = new List<string>();
                    if (_cQ.builder_beginnings.Count == 0) { _cQ.builder_beginnings.Add(""); }
                    if (_cQ.builder_middles.Count == 0) { _cQ.builder_middles.Add(""); }
                    if (_cQ.builder_endings.Count == 0) { _cQ.builder_endings.Add(""); }

                    foreach (string build_beginning in _cQ.builder_beginnings)
                    {
                        foreach (string build_middle in _cQ.builder_middles)
                        {
                            foreach (string build_ending in _cQ.builder_endings)
                            {
                                string build_full = GlobalStaticClass.Speech_StaticSetupClass.generic_system[i_generic_system_count] + " " + build_beginning + " " + build_middle + " " + build_ending;
                                while (build_full.Contains("  "))
                                {
                                    build_full = build_full.Replace("  ", " ");
                                }
                                build_queries.Add(build_full);
                            }
                        }
                    }

                    GlobalStaticClass.AllPossibleSpeechStrings.AddRange(build_queries);
                }
            }
            foreach (string _AllString in GlobalStaticClass.AllPossibleSpeechStrings)
            {
                LIST_ALLCOMMANDS.Items.Add(_AllString);
            }
            if (removeFirst_system) { GlobalStaticClass.Speech_StaticSetupClass.generic_system.RemoveAt(0); }
            if (removeFirst_do_on) { GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on.RemoveAt(0); }
            if (removeFirst_do_off) { GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off.RemoveAt(0); }
            if (removeFirst_do) { GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output.RemoveAt(0); }
            if (removeFirst_ai_read) { GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read.RemoveAt(0); }
            if (removeFirst_ai) { GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input.RemoveAt(0); }
        }

        private void TSB_SYSTEM_ADD_Click(object sender, EventArgs e)
        {
            TextInputForm _tIF = new TextInputForm("System Name", "", true);
            if (_tIF.ShowDialog() == DialogResult.OK)
            {
                string returnedSystemName = _tIF._returnText;
                if (returnedSystemName == null)
                {
                    return;
                }
                foreach (string _cS in GlobalStaticClass.Speech_StaticSetupClass.generic_system)
                {
                    if (_cS.ToLower() == returnedSystemName.ToLower())
                    {
                        (new ErrorForm("Duplicate System Name", "This System Name is already added to the Speech Recognition system")).ShowDialog();
                        return;
                    }
                }
                GlobalStaticClass.Speech_StaticSetupClass.generic_system.Add(returnedSystemName);
                UpdateAllListsOfDoom();
            }
        }

        private void TSB_SYSTEM_DELETE_Click(object sender, EventArgs e)
        {
            string toDeleteSystemName = "";
            if (LIST_SYSTEM.SelectedItem != null)
            {
                toDeleteSystemName = LIST_SYSTEM.SelectedItem.ToString();
            }
            else
            {
                return;
            }
            foreach (string _cS in GlobalStaticClass.Speech_StaticSetupClass.generic_system)
            {
                if (_cS.ToLower() == toDeleteSystemName.ToLower())
                {
                    GlobalStaticClass.Speech_StaticSetupClass.generic_system.Remove(_cS);
                    UpdateAllListsOfDoom();
                    return;
                }
            }
        }

        private void TSB_SYSDEF_ADD_Click(object sender, EventArgs e)
        {
            Speech_SystemDefinitionsForm _SSDF = new Speech_SystemDefinitionsForm("", "");
            if (_SSDF.ShowDialog() == DialogResult.OK)
            {
                string[] returnedData = _SSDF.GetDataBack();
                string returnedType = returnedData[0];
                string returnedDefinition = returnedData[1];
                if (returnedType == null || returnedDefinition == null || returnedType == "" || returnedDefinition == "")
                {
                    return;
                }
                List<string> _toAddTo = null;
                switch (returnedType.ToLower())
                {
                    case "digital_output_turn_on":
                        {
                            _toAddTo = GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on;
                        }
                        break;
                    case "digital_output_turn_off":
                        {
                            _toAddTo = GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off;
                        }
                        break;
                    case "digital_output_id_generic":
                        {
                            _toAddTo = GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output;
                        }
                        break;
                    case "analogue_input_query":
                        {
                            _toAddTo = GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read;
                        }
                        break;
                    case "analogue_input_id_generic":
                        {
                            _toAddTo = GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input;
                        }
                        break;
                    default:
                        //Error or Unknown
                        break;
                }
                if (_toAddTo == null) { return; }

                foreach (string _cS in _toAddTo)
                {
                    if (_cS.ToLower() == returnedDefinition.ToLower())
                    {
                        (new ErrorForm("Duplicate System Definition", "This System Definition is already added to the Speech Recognition system")).ShowDialog();
                        return;
                    }
                }
                _toAddTo.Add(returnedDefinition);
                UpdateAllListsOfDoom();
            }
        }

        private void TSB_SYSDEF_DELETE_Click(object sender, EventArgs e)
        {
            if (LIST_SYS_DEFINITIONS_DO_GENERIC.SelectedItem != null)
            {
                foreach (string _cS in GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output)
                {
                    if (_cS.ToLower() == LIST_SYS_DEFINITIONS_DO_GENERIC.SelectedItem.ToString().ToLower())
                    {
                        GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output.Remove(_cS);
                        break;
                    }
                }
            }
            else if (LIST_SYS_DEFINITIONS_DO_TURNON.SelectedItem != null)
            {
                foreach (string _cS in GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on)
                {
                    if (_cS.ToLower() == LIST_SYS_DEFINITIONS_DO_TURNON.SelectedItem.ToString().ToLower())
                    {
                        GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_on.Remove(_cS);
                        break;
                    }
                }
            }
            else if (LIST_SYS_DEFINITIONS_DO_TURNOFF.SelectedItem != null)
            {
                foreach (string _cS in GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off)
                {
                    if (_cS.ToLower() == LIST_SYS_DEFINITIONS_DO_TURNOFF.SelectedItem.ToString().ToLower())
                    {
                        GlobalStaticClass.Speech_StaticSetupClass.generic_digital_output_turn_off.Remove(_cS);
                        break;
                    }
                }
            }
            else if (LIST_SYS_DEFINITIONS_AI_GENERIC.SelectedItem != null)
            {
                foreach (string _cS in GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input)
                {
                    if (_cS.ToLower() == LIST_SYS_DEFINITIONS_AI_GENERIC.SelectedItem.ToString().ToLower())
                    {
                        GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input.Remove(_cS);
                        break;
                    }
                }
            }
            else if (LIST_SYS_DEFINITIONS_AI_GENQUERY.SelectedItem != null)
            {
                foreach (string _cS in GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read)
                {
                    if (_cS.ToLower() == LIST_SYS_DEFINITIONS_AI_GENQUERY.SelectedItem.ToString().ToLower())
                    {
                        GlobalStaticClass.Speech_StaticSetupClass.generic_analogue_input_read.Remove(_cS);
                        break;
                    }
                }
            }
            UpdateAllListsOfDoom();
        }

        private void TSB_CUSTOMDEF_ADD_Click(object sender, EventArgs e)
        {
            Speech_CustomDefinitionsForm _SCDF = new Speech_CustomDefinitionsForm("", "");
            if (_SCDF.ShowDialog() == DialogResult.OK)
            {
                string[] returnedData = _SCDF.GetDataBack();
                string returnedType = returnedData[0];
                string returnedID = returnedData[1];
                string returnedDefinition = returnedData[2];
                if (returnedType == null || returnedDefinition == null || returnedID == null ||
                    returnedType == "" || returnedDefinition == "" || returnedID == "")
                {
                    return;
                }
                List<GlobalStaticClass.Speech_StaticSetupClass.customDefinition> _toAddTo = null;
                switch (returnedType.ToLower())
                {
                    case "digital output":
                        {
                            _toAddTo = GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs;
                        }
                        break;
                    case "variable":
                        {
                            _toAddTo = GlobalStaticClass.Speech_StaticSetupClass.custom_definition_variables;
                        }
                        break;
                    case "analogue input":
                        {
                            //_toAddTo = GlobalStaticClass.Speech_StaticSetupClass.;
                        }
                        break;
                    default:
                        //Error or Unknown
                        break;
                }
                if (_toAddTo == null) { return; }

                foreach (GlobalStaticClass.Speech_StaticSetupClass.customDefinition _cS in _toAddTo)
                {
                    if (_cS.spokenName.ToLower() == returnedDefinition.ToLower() && _cS.systemName.ToLower() == returnedID)
                    {
                        (new ErrorForm("Duplicate Custom Definition", "This Custom Definition is already added to the Speech Recognition system")).ShowDialog();
                        return;
                    }
                }
                GlobalStaticClass.Speech_StaticSetupClass.customDefinition _CD = new GlobalStaticClass.Speech_StaticSetupClass.customDefinition();
                _CD.systemName = returnedID;
                _CD.spokenName = returnedDefinition;
                _toAddTo.Add(_CD);
                UpdateAllListsOfDoom();
            }
        }
        private void TSB_CUSTOMDEF_DELETE_Click(object sender, EventArgs e)
        {
            if (LIST_CUSTOM_DEFINITIONS_DO.SelectedItem != null)
            {
                if (GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs.Count > LIST_CUSTOM_DEFINITIONS_DO.SelectedIndex && LIST_CUSTOM_DEFINITIONS_DO.SelectedIndex >= 0)
                {
                    GlobalStaticClass.Speech_StaticSetupClass.custom_definition_digital_outputs.RemoveAt(LIST_CUSTOM_DEFINITIONS_DO.SelectedIndex);
                }
            }
            else if (LIST_CUSTOM_DEFINITIONS_VAR.SelectedItem != null)
            {
                if (GlobalStaticClass.Speech_StaticSetupClass.custom_definition_variables.Count > LIST_CUSTOM_DEFINITIONS_VAR.SelectedIndex && LIST_CUSTOM_DEFINITIONS_VAR.SelectedIndex >= 0)
                {
                    GlobalStaticClass.Speech_StaticSetupClass.custom_definition_variables.RemoveAt(LIST_CUSTOM_DEFINITIONS_VAR.SelectedIndex);
                }
            }
            UpdateAllListsOfDoom();
        }

        private void TSB_CUSTOMQUER_ADD_Click(object sender, EventArgs e)
        {
            Speech_CustomQueryForm _CQF = new Speech_CustomQueryForm();
            if (_CQF.ShowDialog() == DialogResult.OK)
            {
                GlobalStaticClass.Speech_StaticSetupClass.customQuery _cQ = new GlobalStaticClass.Speech_StaticSetupClass.customQuery();
                _cQ.builder_beginnings = _CQF.GET_Query_Beginnings();
                _cQ.builder_middles = _CQF.GET_Query_Middles();
                _cQ.builder_endings = _CQF.GET_Query_Endings();
                _cQ.possible_responses = _CQF.GET_Responses();
                _cQ.monitor_type = _CQF.GET_MONITOR_TYPE();
                _cQ.monitor_id = _CQF.GET_MONITOR_ID();
                GlobalStaticClass.Speech_StaticSetupClass.custom_query_list.Add(_cQ);
                UpdateAllListsOfDoom();
            }
        }

        private void TSB_CUSTOMQUER_DELETE_Click(object sender, EventArgs e)
        {
            if (GlobalStaticClass.Speech_StaticSetupClass.custom_query_list.Count > LIST_CUSTOM_QUERIES.SelectedIndex && LIST_CUSTOM_QUERIES.SelectedIndex >= 0)
            {
                GlobalStaticClass.Speech_StaticSetupClass.custom_query_list.RemoveAt(LIST_CUSTOM_QUERIES.SelectedIndex);
                UpdateAllListsOfDoom();
            }
        }

        private void UpdateCheckedTSMI()
        {
            TSMI_ME_Enabled.Checked = GlobalStaticClass.Speech_MasterEnable;
            TSMI_ME_Disabled.Checked = !GlobalStaticClass.Speech_MasterEnable;
            TSMI_PE_Enabled.Checked = GlobalStaticClass.Speech_EnableGlobalPolite;
            TSMI_PE_Disabled.Checked = !GlobalStaticClass.Speech_EnableGlobalPolite;
        }

        private void TSMI_ME_Enable_Click(object sender, EventArgs e)
        {
            GlobalStaticClass.Speech_MasterEnable = true;
            UpdateCheckedTSMI();
        }

        private void TSMI_ME_Disabled_Click(object sender, EventArgs e)
        {
            GlobalStaticClass.Speech_MasterEnable = false;
            UpdateCheckedTSMI();
        }

        private void TSMI_PE_Enabled_Click(object sender, EventArgs e)
        {
            GlobalStaticClass.Speech_EnableGlobalPolite = true;
            UpdateCheckedTSMI();
        }

        private void TSMI_PE_Disabled_Click(object sender, EventArgs e)
        {
            GlobalStaticClass.Speech_EnableGlobalPolite = false;
            UpdateCheckedTSMI();
        }
    }
}