using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.IO;
using System.Runtime.InteropServices;
using PVOID = System.IntPtr;
using DWORD = System.UIntPtr;
using Microsoft.Win32;
using System.Net;

namespace Fusion_Control_Centre_UberMDX
{
    public partial class MainMDX : Form
    {
        #region ToDo Logic Area
        public static bool DoSomethingWithLogicCommand(string INPUT_function, string INPUT_functionTarget, string INPUT_voteOpinion,
                                                Vote_Priority INPUT_votePriority, string INPUT_voteType, object INPUT_extra1,
                                                DateTime INPUT_LastVote, int INPUT_MinDeltaTime)
        {
            TimeSpan _tempTimeSpan = DateTime.Now.Subtract(INPUT_LastVote);
            if (_tempTimeSpan.TotalMilliseconds < INPUT_MinDeltaTime)
            {
                return false;
            }
            switch (INPUT_function)
            {
                #region Trigger an Output
                case "trigger output":
                    {
                        foreach (DigitalOutputChannel DOC in AllDigitalOutputs)
                        {
                            if (INPUT_functionTarget == DOC.id)
                            {
                                LogicalVote tLV = new LogicalVote();
                                tLV.MyLogicalPriority = INPUT_votePriority;
                                if (INPUT_voteType == "detached")
                                {
                                    if (INPUT_voteOpinion == "on")
                                    {
                                        if ((bool)INPUT_extra1)
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                        }
                                        else
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                        }
                                    }
                                    else if (INPUT_voteOpinion == "off")
                                    {
                                        if ((bool)INPUT_extra1)
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                        }
                                        else
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                        }
                                    }
                                    else if (INPUT_voteOpinion == "toggle")
                                    {
                                        if (DOC.CurrentEnabledState)
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                        }
                                        else
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                        }
                                    }
                                    else
                                    {
                                        tLV.MyLogicalOpinion = Vote_Opinion.MEH;
                                    }
                                }
                                else if (INPUT_voteType == "attached")
                                {
                                    if (INPUT_voteOpinion == "on")
                                    {
                                        if (DOC.CurrentEnabledState)
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                        }
                                        else
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                        }
                                    }
                                    else if (INPUT_voteOpinion == "off")
                                    {
                                        if (DOC.CurrentEnabledState)
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                        }
                                        else
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                        }
                                    }
                                    else if (INPUT_voteOpinion == "toggle")
                                    {
                                        if (DOC.CurrentEnabledState)
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                        }
                                        else
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                        }
                                    }
                                    else
                                    {
                                        tLV.MyLogicalOpinion = Vote_Opinion.MEH;
                                    }
                                }
                                else if (INPUT_voteType == "absolute")
                                {
                                    if (INPUT_voteOpinion == "on")
                                    {
                                        tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                    }
                                    else if (INPUT_voteOpinion == "off")
                                    {
                                        tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                    }
                                    else if (INPUT_voteOpinion == "toggle")
                                    {
                                        if (DOC.CurrentEnabledState)
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                        }
                                        else
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                        }
                                    }
                                    else
                                    {
                                        tLV.MyLogicalOpinion = Vote_Opinion.MEH;
                                    }
                                }
                                else
                                {
                                    if (INPUT_voteOpinion == "on")
                                    {
                                        tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                    }
                                    else if (INPUT_voteOpinion == "off")
                                    {
                                        tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                    }
                                    else if (INPUT_voteOpinion == "toggle")
                                    {
                                        if (DOC.CurrentEnabledState)
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.NON;
                                        }
                                        else
                                        {
                                            tLV.MyLogicalOpinion = Vote_Opinion.OUI;
                                        }
                                    }
                                    else
                                    {
                                        tLV.MyLogicalOpinion = Vote_Opinion.MEH;
                                    }
                                }
                                DOC.ShouldIChangeState.Add(tLV);
                                return true;
                            }
                        }
                        return false;
                    }
                #endregion

                #region Enable or Disable a DisplayButton
                case "enable or disable":
                    {
                        foreach (DisplayButton FindButtonChangeEnable in AllDisplayButtons)
                        {
                            if (FindButtonChangeEnable.id == INPUT_functionTarget)
                            {
                                LogicalVote LV = new LogicalVote();
                                LV.MyLogicalPriority = INPUT_votePriority;
                                if (INPUT_voteOpinion == "toggle")
                                {
                                    if (FindButtonChangeEnable.isEnabled)
                                    {
                                        LV.MyLogicalOpinion = Vote_Opinion.NON;
                                    }
                                    else
                                    {
                                        LV.MyLogicalOpinion = Vote_Opinion.OUI;
                                    }
                                }
                                else if (INPUT_voteOpinion == "enable")
                                {
                                    LV.MyLogicalOpinion = Vote_Opinion.OUI;
                                }
                                else if (INPUT_voteOpinion == "disable")
                                {
                                    LV.MyLogicalOpinion = Vote_Opinion.NON;
                                }
                                else
                                {
                                    LV.MyLogicalOpinion = Vote_Opinion.MEH;
                                }
                                FindButtonChangeEnable.ShouldIBeEnabled.Add(LV);
                                return true;
                            }
                        }
                        return false;
                    }
                #endregion

                #region Change Variable
                case "change variable":
                    {
                        for (int checkVariable_i = 0; checkVariable_i < AllVariables.Count; checkVariable_i++)
                        {
                            if (AllVariables[checkVariable_i].variableReferenceName == INPUT_functionTarget)
                            {
                                if (INPUT_functionTarget == "variable_deltashelf" && INPUT_votePriority == Vote_Priority.HIGH_PRIORITY)
                                {

                                }
                                object changeto = AllVariables[checkVariable_i].variableValue;
                                if (INPUT_voteOpinion.StartsWith("d"))
                                {
                                    double dChange = 0.0;
                                    double.TryParse(INPUT_voteOpinion.Substring(1), out dChange);
                                    changeto = (object)((double)changeto + dChange);
                                }
                                else if (INPUT_voteOpinion.Equals("true"))
                                {
                                    changeto = (object)true;
                                }
                                else if (INPUT_voteOpinion.Equals("false"))
                                {
                                    changeto = (object)false;
                                }
                                else
                                {
                                    double tryChangeDouble = 0.0;
                                    if (double.TryParse(INPUT_voteOpinion, out tryChangeDouble))
                                    {
                                        changeto = (object)tryChangeDouble;
                                    }
                                }

                                LogicalVote newLV = new LogicalVote();
                                newLV.MyLogicalPriority = INPUT_votePriority;
                                newLV.toWhat = (object)changeto;
                                AllVariables[checkVariable_i].WhatShouldMyValueBe.Add(newLV);
                                return true;
                            }
                        }
                        return false;
                    }
                #endregion

                #region Change Page
                case "change page":
                    {
                        int changetoINT = -1;
                        if (INPUT_voteOpinion.StartsWith("+") || INPUT_voteOpinion.StartsWith("-"))
                        {
                            int dChange = 0;
                            int.TryParse(INPUT_voteOpinion, out dChange);
                            changetoINT = CurrentPage + dChange;
                        }
                        else
                        {
                            int tryChangeInt = -1;
                            if (int.TryParse(INPUT_voteOpinion, out tryChangeInt))
                            {
                                changetoINT = tryChangeInt;
                            }
                        }
                        if (changetoINT < 0)
                        {
                            return false;
                        }
                        LogicalVote LVPage = new LogicalVote();
                        LVPage.MyLogicalPriority = INPUT_votePriority;
                        LVPage.toWhat = (object)changetoINT;
                        CanDo_ShouldIChangePage.Add(LVPage);
                        return true;
                    }
                #endregion

                #region Change A Timer
                case "change timer":
                    {
                        int changetoINT = -1;
                        int CurrentTimerValue = 0;
                        if (INPUT_voteOpinion.StartsWith("+") || INPUT_voteOpinion.StartsWith("-"))
                        {
                            switch (INPUT_functionTarget)
                            {
                                case "gui":
                                    CurrentTimerValue = GUI_Timer.Interval;
                                    break;
                                case "logic":
                                    CurrentTimerValue = LogicTimer.Interval;
                                    break;
                                case "input":
                                    //CurrentTimerValue = InputTimer.Interval;
                                    //break;
                                case "output":
                                    //CurrentTimerValue = OutputTimer.Interval;
                                    //break;
                                case "io":
                                    CurrentTimerValue = IO_Timer.Interval;
                                    break;
                                default:
                                    //Error or Unknown
                                    break;
                            }
                            int dChange = 0;
                            int.TryParse(INPUT_voteOpinion, out dChange);
                            changetoINT = CurrentTimerValue + dChange;
                        }
                        else
                        {
                            int tryChangeInt = -1;
                            if (int.TryParse(INPUT_voteOpinion, out tryChangeInt))
                            {
                                changetoINT = tryChangeInt;
                            }
                        }
                        if (changetoINT < 0)
                        {
                            return false;
                        }
                        LogicalVote LVTimer = new LogicalVote();
                        LVTimer.MyLogicalPriority = INPUT_votePriority;
                        LVTimer.toWhat = (object)changetoINT;
                        switch (INPUT_functionTarget)
                        {
                            case "gui":
                            case "gui timer":
                                CanDo_ShouldIChangeGUITimer.Add(LVTimer);
                                break;
                            case "logic":
                            case "logic timer":
                                CanDo_ShouldIChangeLogicTimer.Add(LVTimer);
                                break;
                            case "input":
                            case "input timer":
                                //CanDo_ShouldIChangeInputTimer.Add(LVTimer);
                                //break;
                            case "output":
                            case "output timer":
                                //CanDo_ShouldIChangeOutputTimer.Add(LVTimer);
                                //break;
                            case "io":
                            case "io timer":
                                CanDo_ShouldIChangeIOTimer.Add(LVTimer);
                                break;
                            default:
                                //Error or Unknown
                                break;
                        }
                        return true;
                    }
                #endregion

                #region Change Logging
                case "change logging":
                    {
                        bool changeToBool = false;
                        LogicalVote logging_Vote = new LogicalVote();
                        logging_Vote.MyLogicalPriority = INPUT_votePriority;
                        logging_Vote.MyLogicalOpinion = Vote_Opinion.MEH;

                        foreach (LogClass LoC in AllLogClasses)
                        {
                            if (LoC.logReferenceName == INPUT_functionTarget)
                            {
                                switch (INPUT_voteOpinion)
                                {
                                    case "toggle":
                                        changeToBool = !LoC.monitorState;
                                        break;
                                    case "start":
                                        changeToBool = true;
                                        break;
                                    case "stop":
                                        changeToBool = false;
                                        break;
                                    default:
                                        //Error or Unknown
                                        break;
                                }
                                if (changeToBool)
                                {
                                    logging_Vote.MyLogicalOpinion = Vote_Opinion.OUI;
                                }
                                else
                                {
                                    logging_Vote.MyLogicalOpinion = Vote_Opinion.NON;
                                }
                                LoC.ShouldIBeLogging.Add(logging_Vote);
                                return true;
                            }
                        }
                    }
                    break;
                #endregion

                #region Send A Key or Key Sequence
                case "send key":
                    {
                        string TitleString = "", ClassString = "", SubTitle = "", SubClass = "";
                        bool usesubclass = true;

                        string[] SplitTitleClassSubsArray = INPUT_functionTarget.Split(':');
                        if (SplitTitleClassSubsArray.Length == 1)
                        {
                            // Then just a single thing...
                            /*
                            if (INPUT_functionTarget.ToLower() == "winamp")
                            {
                                //For Winamp
                                ClassString = "Winamp v1.x";
                                TitleString = "";
                            }
                            else 
                            */

                            if (INPUT_functionTarget.ToLower().Equals("wmp") || INPUT_functionTarget.ToLower().Equals("windows media player"))
                            {
                                //For Windows Media Player
                                ClassString = "WMPlayerApp";
                                TitleString = "";
                            }
                            else
                            {
                                TitleString = INPUT_functionTarget.ToLower();
                            }
                        }
                        else if (SplitTitleClassSubsArray.Length == 2)
                        {
                            //Then just class and title
                            TitleString = SplitTitleClassSubsArray[0];
                            ClassString = SplitTitleClassSubsArray[1];
                        }
                        else if (SplitTitleClassSubsArray.Length == 4)
                        {
                            //Title, class, subtitle, and subclass
                            TitleString = SplitTitleClassSubsArray[0];
                            ClassString = SplitTitleClassSubsArray[1];
                            SubTitle = SplitTitleClassSubsArray[2];
                            SubClass = SplitTitleClassSubsArray[3];
                        }
                        else
                        {
                            //Too many or not enough parameters here, so retrun
                            return false;
                        }
                        int hwnd = 0;
                        IntPtr hwndChild = IntPtr.Zero;

                        //Get a handle for the Application main window
                        if (TitleString != "")
                        {
                            hwnd = FindWindow(null, TitleString);
                        }
                        if (hwnd == 0)
                        {
                            if (ClassString != "")
                            {
                                hwnd = FindWindow(ClassString, null);
                            }
                        }
                        if (hwnd == 0)
                        {
                            //Not found by either class or title name
                            hwnd = (int)EnumWindowsToFindHandle(TitleString);
                            if (hwnd == 0)
                            {
                                return false;
                            }
                        }

                        //Get the subclass
                        if (SubClass != "")
                        {
                            hwndChild = FindWindowEx((IntPtr)hwnd, IntPtr.Zero, SubClass, null);
                        }
                        if (hwndChild == IntPtr.Zero)
                        {
                            if (SubTitle != "")
                            {
                                hwndChild = FindWindowEx((IntPtr)hwnd, IntPtr.Zero, null, SubTitle);
                            }
                        }
                        if (hwndChild == IntPtr.Zero)
                        {
                            //No subclass found
                            usesubclass = false;
                        }
                        else
                        {
                            usesubclass = true;
                        }

                        string[] SendKey_SplitArray = { "::" };
                        string[] SendKey_StringSplit = INPUT_voteOpinion.Split(SendKey_SplitArray, StringSplitOptions.RemoveEmptyEntries);
                        IntPtr lParam_control = new IntPtr((int)0x401D0001);
                        IntPtr lParam_zero = IntPtr.Zero;

                        for (int i = 0; i < SendKey_StringSplit.Length; i++)
                        {
                            if (SendKey_StringSplit[i] == " ")
                            {
                                //Skip Spaces
                                continue;
                            }
                            int keytosend = SendKey_StringToVK(SendKey_StringSplit[i]);
                            IntPtr lParam_USE = lParam_zero;
                            if (keytosend == 0x11)
                            {
                                lParam_USE = lParam_control;
                            }
                            if ((int)hwnd != 0)
                            {
                                if (usesubclass)
                                {
                                    SendMessage((int)hwndChild, WM_KEYDOWN, keytosend, lParam_USE);
                                }
                                else
                                {
                                    SendMessage((int)hwnd, WM_KEYDOWN, keytosend, lParam_USE);
                                }
                            }
                        }
                        for (int i = SendKey_StringSplit.Length - 1; i >= 0; i--)
                        {
                            if (SendKey_StringSplit[i] == " ")
                            {
                                //Skip Spaces
                                continue;
                            }
                            int keytosend = SendKey_StringToVK(SendKey_StringSplit[i]);
                            IntPtr lParam_USE = lParam_zero;
                            if (keytosend == 0x11)
                            {
                                lParam_USE = lParam_control;
                            }
                            if ((int)hwnd != 0)
                            {
                                if (usesubclass)
                                {
                                    SendMessage((int)hwndChild, WM_KEYUP, keytosend, lParam_USE);
                                }
                                else
                                {
                                    SendMessage((int)hwnd, WM_KEYUP, keytosend, lParam_USE);
                                }
                            }
                        }
                        return true;
                    }
                    break;
                #endregion

                #region Send Key to Foreground
                case "send key to foreground":
                    {
                        string[] SendKey_StringSplit = INPUT_voteOpinion.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries);

                        for (int i = 0; i < SendKey_StringSplit.Length; i++)
                        {
                            int keytosend = SendKey_StringToVK(SendKey_StringSplit[i]);
                            keybd_event((byte)keytosend, 0x45, 0, 0);
                            keybd_event((byte)keytosend, 0x45, KEYEVENTF_KEYUP, 0);
                        }
                        break;
                    }
                #endregion

                #region Play a *.wav File
                case "play sound":
                    {
                        if (File.Exists(INPUT_functionTarget))
                        {
                            PlaySound(INPUT_functionTarget, IntPtr.Zero, SoundFlags.SND_FILENAME | SoundFlags.SND_ASYNC | SoundFlags.SND_NOSTOP);
                        }
                    }
                    break;
                #endregion

                case "display warning":

                    break;

                #region Send Email
                case "send email":
                    {
                        string _to = INPUT_voteOpinion;
                        string _subject = "";
                        string _body_beg = "";
                        string _body_end = "";
                        string _monitor_type = "";
                        string _monitor_id = "";

                        string[] _opts = INPUT_functionTarget.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries);
                        if (_opts.Length >= 1)
                        {
                            _subject = _opts[0];
                            if (_opts.Length >= 2)
                            {
                                _body_beg = _opts[1];
                                if (_opts.Length >= 3)
                                {
                                    _body_end = _opts[2];
                                    if (_opts.Length >= 4)
                                    {
                                        _monitor_type = _opts[3];
                                        if (_opts.Length >= 5)
                                        {
                                            _monitor_id = _opts[4];
                                        }
                                    }
                                }
                            }
                        }

                        string _value = "";

                        switch (_monitor_type.ToLower())
                        {
                            case "analogue input":
                                {
                                    foreach (AnalogueInputChannel _aic in AllAnalogueInputs)
                                    {
                                        if (_aic.id.ToLower() == _monitor_id.ToLower())
                                        {
                                            _value = _aic.CurrentValue.ToString();
                                            break;
                                        }
                                    }
                                }
                                break;
                            case "variable":
                                {
                                    foreach (Variable _var in AllVariables)
                                    {
                                        if (_var.variableReferenceName.ToLower() == _monitor_id.ToLower())
                                        {
                                            _value = _var.variableValue.ToString();
                                        }
                                    }
                                }
                                break;
                            case "digital output":
                                {
                                    foreach (DigitalOutputChannel _doc in AllDigitalOutputs)
                                    {
                                        if (_doc.id.ToLower() == _monitor_id.ToLower())
                                        {
                                            _value = _doc.CurrentEnabledState.ToString();
                                        }
                                    }
                                }
                                break;
                            default:
                                {
                                    //Error
                                }
                                break;
                        }
                        
                        string _emailString = "http://www.fusioncontrolcentre.com/MDX/email/email.php?to=" + _to + "&subject=" + _subject + "&body=" + _body_beg + " " + _value + " " + _body_end;
                        
                        try
                        {
                            WebRequest Email_WebRequest = WebRequest.Create(_emailString);
                            StreamReader Email_ReceivedStream = new StreamReader(Email_WebRequest.GetResponse().GetResponseStream());
                            System.Text.StringBuilder Email_StringBuilder = new System.Text.StringBuilder();
                            string temp_Email_ReadLine;
                            while ((temp_Email_ReadLine = Email_ReceivedStream.ReadLine()) != null)
                            {
                                if (temp_Email_ReadLine.Length > 0)
                                {
                                    Email_StringBuilder.Append(temp_Email_ReadLine);
                                }
                            }
                            Email_ReceivedStream.Close();
                            string Email_ReturnedString = Email_StringBuilder.ToString();
                            if (Email_ReturnedString == "0")
                            {
                                //failed
                            }
                            else if (Email_ReturnedString == "2")
                            {
                                //invalid email
                            }
                            else if (Email_ReturnedString == "1")
                            {
                                //yay
                            }

                        }
                        catch (Exception e)
                        {

                        }
                    }
                    break;
                #endregion

                #region Send Executable Instruction to Application
                case "external instruction":
                case "external command":
                    {
                        foreach (COM_Execution_Object_Class _comExecutableInstruction in COM_Execution_Commands_List)
                        {
                            COM_Execution_Object_Class.COM_Check_Return_Class _comReturn = _comExecutableInstruction.Check_Command_Availability(INPUT_functionTarget);
                            if (_comReturn.isFound)
                            {
                                return _comExecutableInstruction.Do_Command(_comReturn.foundItem);
                            }
                        }
                        return false;
                    }
                #endregion

                default:

                    return false;
            }
            return false;
        }
        #endregion

        #region Convert Vote to Integer
        public static int Vote_Opinion_To_Integer(Vote_Opinion VO)
        {
            switch (VO)
            {
                case Vote_Opinion.NON:
                    return -1;
                case Vote_Opinion.OUI:
                    return 1;
                case Vote_Opinion.MEH:
                default:
                    return 0;
            }
        }

        public static int Vote_Priority_To_Integer(Vote_Priority VP)
        {
            switch (VP)
            {
                case Vote_Priority.LOW_PRIORITY:
                    return 0;
                case Vote_Priority.HIGH_PRIORITY:
                    return 2;
                case Vote_Priority.MEDIUM_PRIORITY:
                default:
                    return 1;
            }
        }
        #endregion

        #region Get All Windows
        //EnumWindows CALLBACK function
        private static bool EvalWindow(int hWnd, int lParam)
        {
            if (!IsWindowVisible(hWnd))
            {
                return (true);
            }

            StringBuilder title = new StringBuilder(256);
            StringBuilder module = new StringBuilder(256);

            GetWindowModuleFileName(hWnd, module, 256);
            GetWindowText(hWnd, title, 256);

            if (title.Length == 0)
            {
                return (true);
            }
            wndArrayComplete.Add(new wndArrayClass((IntPtr)hWnd, title.ToString()));
            return (true);
        }
        #endregion

        #region Enumerate Through Windows
        public static IntPtr EnumWindowsToFindHandle(string input_toFind)
        {
            wndArrayComplete.Clear();
            EnumWindowsProc ewp = new EnumWindowsProc(EvalWindow);
            EnumWindows(ewp, 0);

            foreach (wndArrayClass _arCL in wndArrayComplete)
            {
                Console.WriteLine("[" + _arCL.hWnd.ToString() + "]  --  " + _arCL.title);
                if (_arCL.title.ToLower().Contains(input_toFind.ToLower()))
                {
                    return _arCL.hWnd;
                }
            }
            return IntPtr.Zero;
        }
        #endregion
    }
}