MainWindow.xaml.cs

using GongSolutions.Wpf.DragDrop;
using Microsoft.Win32;
using NOOBS_CMDR.Extensions;
using NOOBS_CMDR.Commands;
using OBSWebsocketDotNet;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;
using System.Security.Principal;

namespace NOOBS_CMDR
{
    public partial class NOOBS_CMDR_Homepage : Window, IDropTarget, INotifyPropertyChanged
    {

        #region INotifyPropertyChanged

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        #endregion INotifyPropertyChanged

        #region Properties

        public string WindowTitle
        {
            get
            {
                Version version = Assembly.GetExecutingAssembly().GetName().Version;
                return "NOOBS CMDR v" + version;
            }
        }

        #endregion Properties

        #region Variables

        private OBSWebsocket _obs;
        public OBSWebsocket obs
        {
            get { return _obs; }
            set
            {
                if (value != _obs)
                {
                    _obs = value;
                    OnPropertyChanged();
                }
            }
        }

        private ObservableCollection<CommandType> CommandTypes = new ObservableCollection<CommandType>();
        private ObservableCollection<Command> Commands = new ObservableCollection<Command>();
        private ObservableCollection<Command> CommandsCopyStack = new ObservableCollection<Command>();

        #endregion Variables

        #region Constructors

        public NOOBS_CMDR_Homepage()
        {
            InitializeComponent();
            this.DataContext = this;

            // Check that all OBSCommand files exist and that environment PATH variable is set up
            if (!OBSCommandExists())
            {

                // OBSCommand not found, so need to install it but this needs to be done in admin mode
                if (!IsAdministrator())
                {
                    MessageBox.Show(@"Please restart in admin mode to install OBSCommand.", "OBSCommand Not Installed", MessageBoxButton.OK, MessageBoxImage.Warning);
                    System.Environment.Exit(1);
                }
                else
                {
                    // Ask user to select directory
                    const string message ="Before using NOOBS CMDR, you must install OBSCommand. Choose a directory to install OBSCommand.";
                    const string caption = "NOOBS CMDR Install";
                    var result = MessageBox.Show(message, caption,
                                                 MessageBoxButton.OKCancel,
                                                 MessageBoxImage.Question);

                    if (result == MessageBoxResult.OK)
                    {
                        // Check that all OBSCommand files exist in NOOBS CMDR folder
                        string sourcePath = $"{System.AppDomain.CurrentDomain.BaseDirectory}OBSCommand";

                        // If they don't exist, we can't install OBSCommand
                        if (!File.Exists($"{sourcePath}\\OBSCommand.exe") || !File.Exists($"{sourcePath}\\Newtonsoft.Json.dll") || !File.Exists($"{sourcePath}\\obs-websocket-dotnet.dll") || !File.Exists($"{sourcePath}\\websocket-sharp.dll"))
                        {
                            MessageBox.Show(@"Could not find OBSCommand Files. Please re-download NOOBS CMDR.", "OBSCommand Files Missing", MessageBoxButton.OK, MessageBoxImage.Warning);
                            System.Environment.Exit(1);
                        }

                        // Ask user to select directory
                        System.Windows.Forms.FolderBrowserDialog dlg = new System.Windows.Forms.FolderBrowserDialog();
                        
                        // Default to the Program Files directory
                        dlg.SelectedPath = Environment.Is64BitOperatingSystem ? Environment.GetEnvironmentVariable("ProgramFiles(x86)") : Environment.GetEnvironmentVariable("ProgramFiles");

                        // User selects OK
                        if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                        {
                            string selectedPath = $"{dlg.SelectedPath}\\OBSCommand";

                            // Create OBSCommand folder automatically + copy all OBSCommand files
                            Directory.CreateDirectory($"{dlg.SelectedPath}\\OBSCommand");
                            File.Copy($"{sourcePath}\\OBSCommand.exe", $"{selectedPath}\\OBSCommand.exe", true);
                            File.Copy($"{sourcePath}\\Newtonsoft.Json.dll", $"{selectedPath}\\Newtonsoft.Json.dll", true);
                            File.Copy($"{sourcePath}\\obs-websocket-dotnet.dll", $"{selectedPath}\\obs-websocket-dotnet.dll", true);
                            File.Copy($"{sourcePath}\\websocket-sharp.dll", $"{selectedPath}\\websocket-sharp.dll", true);

                            // Check the environment PATH variable
                            string enviromentPath = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine);
                            
                            // If the selected directory does not exist in the PATH variable, we need to add it
                            if (!enviromentPath.Contains(selectedPath))
                            {
                                Environment.SetEnvironmentVariable("PATH", $"{enviromentPath};{selectedPath}", EnvironmentVariableTarget.Machine);
                            }

                            MessageBox.Show(@"NOOBS CMDR is now ready to use. If you are launching NOOBS CMDR scripts via Stream Deck, Lioranboard, Touch Portal etc., you MUST restart that application first.", "OBSCommand Successfully Installed", MessageBoxButton.OK, MessageBoxImage.Information);
                        }
                        else
                        {
                            System.Environment.Exit(1);
                        }
                    }
                    else
                    {
                        System.Environment.Exit(1);
                    }
                }
            }

            ServerText.Text = ConfigurationManager.AppSettings.Get("Server");
            PortText.Text = ConfigurationManager.AppSettings.Get("Port");
            PasswordText.Password = ConfigurationManager.AppSettings.Get("Password");

            obs = new OBSWebsocket();
            obs.Connected += Obs_Connected;
            obs.Disconnected += Obs_Disconnected;

            Connect();

            CommandTypeList.ItemsSource = CommandTypes;
            CommandListBox.ItemsSource = Commands;

            CollectionView view = CollectionViewSource.GetDefaultView(CommandTypeList.ItemsSource) as CollectionView;
            view.Filter = CommandTypeListFilter;

            CreateActionTypes();
        }

        #region Filters

        private void Searchbar_SearchTextChanged(object sender, EventArgs e)
        {
            if (CommandTypeList.ItemsSource != null)
            {
                CollectionViewSource.GetDefaultView(CommandTypeList.ItemsSource).Refresh();
            }
        }

        public bool CommandTypeListFilter(object commandType)
        {
            if (string.IsNullOrEmpty(CommandTypeListSearch.Text))
            {
                return true;
            }
            else
            {
                return (
                    (commandType as CommandType).commandTypeDesc.ToString().IndexOf(CommandTypeListSearch.Text, StringComparison.OrdinalIgnoreCase) >= 0);
            }
        }

        #endregion Filters

        #endregion Constructors

        #region Functions

        public static bool IsAdministrator()
        {
            var identity = WindowsIdentity.GetCurrent();
            var principal = new WindowsPrincipal(identity);
            return principal.IsInRole(WindowsBuiltInRole.Administrator);
        }

        public bool OBSCommandExists()
        {
            var enviromentPath = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine);

            var paths = enviromentPath.Split(';');
            var exePath = paths.Select(x => Path.Combine(x, "OBSCommand.exe"))
                               .Where(x => File.Exists(x))
                               .FirstOrDefault();

            if (string.IsNullOrWhiteSpace(exePath))
            {
                return false;
            }

            string path = exePath.Replace(@"\OBSCommand.exe", "");

            return
                File.Exists($"{path}\\OBSCommand.exe")
                && File.Exists($"{path}\\Newtonsoft.Json.dll")
                && File.Exists($"{path}\\obs-websocket-dotnet.dll")
                && File.Exists($"{path}\\websocket-sharp.dll");
        }

        private void CreateActionTypes()
        {
            CommandTypes.Add(new CommandType("Stream", CommandType.Type.Stream));
            CommandTypes.Add(new CommandType("Record", CommandType.Type.Record));
            CommandTypes.Add(new CommandType("Profile", CommandType.Type.Profile));
            CommandTypes.Add(new CommandType("Scene", CommandType.Type.Scene));
            CommandTypes.Add(new CommandType("Source", CommandType.Type.Source));
            CommandTypes.Add(new CommandType("Filter", CommandType.Type.Filter));
            CommandTypes.Add(new CommandType("Audio", CommandType.Type.Audio));
            CommandTypes.Add(new CommandType("Media Control", CommandType.Type.Media));
            CommandTypes.Add(new CommandType("Transition", CommandType.Type.Transition));
            CommandTypes.Add(new CommandType("Studio Mode", CommandType.Type.StudioMode));
            CommandTypes.Add(new CommandType("Screenshot", CommandType.Type.Screenshot));
            CommandTypes.Add(new CommandType("Replay Buffer", CommandType.Type.ReplayBuffer));
            CommandTypes.Add(new CommandType("Projector", CommandType.Type.Projector));
            CommandTypes.Add(new CommandType("Delay", CommandType.Type.Delay));
            CommandTypes.Add(new CommandType("Custom", CommandType.Type.Custom));
        }

        #endregion Functions

        #region Page Actions

        private void CommandList_MouseDown(object sender, MouseButtonEventArgs e)
        {
            // Deselect when click outside of items
            HitTestResult r = VisualTreeHelper.HitTest(this, e.GetPosition(this));
            if (r.VisualHit.GetType() != typeof(ListBoxItem))
                CommandListBox.UnselectAll();
        }

        private void CommandTypeList_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var item = ItemsControl.ContainerFromElement(sender as ListBox, e.OriginalSource as DependencyObject) as ListBoxItem;

            if (item == null)
                return;

            if (item.Content.GetType() != typeof(CommandType))
                return;

            CommandType commandType = (CommandType)item.Content;

            switch (commandType.commandTypeID)
            {
                case CommandType.Type.Stream:
                    Commands.Add(new StreamCommand(obs));
                    break;
                case CommandType.Type.Record:
                    Commands.Add(new RecordingCommand(obs));
                    break;
                case CommandType.Type.Profile:
                    Commands.Add(new ProfileCommand(obs));
                    break;
                case CommandType.Type.Scene:
                    Commands.Add(new SceneCommand(obs));
                    break;
                case CommandType.Type.Source:
                    Commands.Add(new SourceCommand(obs));
                    break;
                case CommandType.Type.Filter:
                    Commands.Add(new FilterCommand(obs));
                    break;
                case CommandType.Type.Audio:
                    Commands.Add(new AudioCommand(obs));
                    break;
                case CommandType.Type.Media:
                    Commands.Add(new MediaCommand(obs));
                    break;
                case CommandType.Type.Transition:
                    Commands.Add(new TransitionCommand(obs));
                    break;
                case CommandType.Type.StudioMode:
                    Commands.Add(new StudioModeCommand(obs));
                    break;
                case CommandType.Type.Screenshot:
                    Commands.Add(new ScreenshotCommand(obs));
                    break;
                case CommandType.Type.ReplayBuffer:
                    Commands.Add(new ReplayBufferCommand(obs));
                    break;
                case CommandType.Type.Projector:
                    Commands.Add(new ProjectorCommand(obs));
                    break;
                case CommandType.Type.Delay:
                    Commands.Add(new DelayCommand(obs));
                    break;
                default:
                    Commands.Add(new CustomCommand(obs));
                    break;
            }

            // Scroll to end of list
            CommandListBox.ScrollIntoView(CommandListBox.Items[CommandListBox.Items.Count - 1]);
        }

        private void CommandListBox_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Delete)
            {
                DeleteCommands(CommandListBox.SelectedItems.OfType<Command>().ToList());
            }
        }

        #endregion Page Actions

        #region Connect

        private void Connect()
        {
            if (!obs.IsConnected)
            {
                string server = ServerText.Text;
                string port = PortText.Text;
                string password = PasswordText.Password;

                try
                {
                    obs.Connect(@"ws://" + server + ":" + port, password);
                }
                catch (AuthFailureException)
                {
                    MessageBox.Show("Authentication failed.", "Error", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                    obs.Disconnect();
                    return;
                }
                catch (ErrorResponseException ex)
                {
                    MessageBox.Show("Connect failed : " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                    return;
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Connect failed : " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                    return;
                }
            }
            else
            {
                obs.Disconnect();
            }
        }

        private void Obs_Connected(object sender, EventArgs e)
        {
            OnPropertyChanged("obs");

            Configuration configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            configuration.AppSettings.Settings["Server"].Value = ServerText.Text;
            configuration.AppSettings.Settings["Port"].Value = PortText.Text;
            configuration.AppSettings.Settings["Password"].Value = PasswordText.Password;
            configuration.Save();

            ConfigurationManager.RefreshSection("appSettings");
        }

        private void Obs_Disconnected(object sender, EventArgs e)
        {
            OnPropertyChanged("obs");
        }

        private void ConnectBtn_Click(object sender, RoutedEventArgs e)
        {
            Connect();
        }

        #endregion

        #region Test Command

        private void TestCommands(List<Command> commandList)
        {
            if (!OBSCommandExists())
            {
                MessageBox.Show(@"Please restart in admin mode to install OBSCommand.", "OBSCommand Not Installed", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            if (commandList.OfType<StreamCommand>().Count() > 0)
            {
                var result = MessageBox.Show("You are about to execute a command that starts or stops your stream. Are you sure you want to continue?", "Potentially Risky Command", MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (result == MessageBoxResult.No)
                    return;
            }

            string strCmdText;
            strCmdText = string.Format(@"/server={0}:{1} /password=""{2}""", ServerText.Text, PortText.Text, PasswordText.Password);

            foreach (Command command in commandList)
            {
                Console.WriteLine(command.ToString());
                strCmdText += " " + command.ToString().ReplaceTimestamp();
            }

            Console.WriteLine(strCmdText);

            var enviromentPath = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine);

            var paths = enviromentPath.Split(';');
            var exePath = paths.Select(x => Path.Combine(x, "OBSCommand.exe"))
                               .Where(x => File.Exists(x))
                               .FirstOrDefault();

            Process process = new Process
            {
                StartInfo =
                {
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    CreateNoWindow = true,
                    FileName = exePath,
                    Arguments = strCmdText
                }
            };

            try
            {
                process.Start();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Test failed : " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                return;
            }
        }

        private void TestCommandBtn_Click(object sender, RoutedEventArgs e)
        {
            TestCommands(Commands.ToList());
        }

        private void Test_MenuItem_Click(object sender, RoutedEventArgs e)
        {
            TestCommands(CommandListBox.SelectedItems.OfType<Command>().ToList());
        }

        #endregion Test Command

        #region Copy Commands

        private void CopyCommands(List<Command> commandList)
        {
            CommandsCopyStack.Clear();

            List<Command> reverseList = commandList;
            reverseList.Reverse();

            foreach (var command in reverseList)
                CommandsCopyStack.Add(command.Clone());
        }

        private void Copy_MenuItem_Click(object sender, RoutedEventArgs e)
        {
            CopyCommands(CommandListBox.SelectedItems.OfType<Command>().ToList());
        }

        #endregion Copy Commands

        #region Paste Commands

        private void PasteCommands(int row)
        {
            foreach (var command in CommandsCopyStack)
                Commands.Insert(row, command.Clone());
        }

        private void Paste_MenuItem_Click(object sender, RoutedEventArgs e)
        {
            int row = 0;

            if (CommandListBox.SelectedItems.Count <= 0)
            {
                row = CommandListBox.Items.Count;
            }
            else if (CommandListBox.SelectedItems.Count == 1)
            {
                row = CommandListBox.SelectedIndex + 1;
            }
            else if (CommandListBox.SelectedItems.Count > 1)
            {
                foreach (var item in CommandListBox.SelectedItems)
                {
                    row = CommandListBox.Items.IndexOf(item) > row ? CommandListBox.Items.IndexOf(item) : row;
                }

                row = row + 1;
            }

            PasteCommands(row);
        }

        #endregion Paste Commands

        #region Delete Commands

        private void DeleteCommands(List<Command> commandList)
        {
            foreach (var command in commandList)
                Commands.Remove(command);
        }

        private void Delete_MenuItem_Click(object sender, RoutedEventArgs e)
        {
            DeleteCommands(CommandListBox.SelectedItems.OfType<Command>().ToList());
        }

        #endregion Delete Commands

        #region Duplicate Commands

        private void DuplicateCommands(List<Command> commandList)
        {
            int row = 0;

            if (CommandListBox.SelectedItems.Count <= 0)
            {
                row = CommandListBox.Items.Count;
            }
            else if (CommandListBox.SelectedItems.Count == 1)
            {
                row = CommandListBox.SelectedIndex + 1;
            }
            else if (CommandListBox.SelectedItems.Count > 1)
            {
                foreach (var item in CommandListBox.SelectedItems)
                {
                    row = CommandListBox.Items.IndexOf(item) > row ? CommandListBox.Items.IndexOf(item) : row;
                }

                row = row + 1;
            }

            List<Command> reverseList = commandList;
            reverseList.Reverse();

            foreach (var command in reverseList)
                Commands.Insert(row, command.Clone());
        }

        private void Duplicate_MenuItem_Click(object sender, RoutedEventArgs e)
        {
            DuplicateCommands(CommandListBox.SelectedItems.OfType<Command>().ToList());
        }

        #endregion Duplicate Commands

        #region Export to Script

        private void ExportBtn_Click(object sender, RoutedEventArgs e)
        {
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.Filter = "Batch Script (*.bat)|*.bat|VBS Script (*.vbs)|*.vbs";
            if (dlg.ShowDialog() == true)
            {
                string path = dlg.FileName.Substring(0, dlg.FileName.LastIndexOf("\\") + 1);
                string filename = Path.GetFileNameWithoutExtension(dlg.FileName);
                File.WriteAllText(string.Format(@"{0}\\{1}.bat", path, filename), CommandsToBatch(Commands.ToList()));
                File.WriteAllText(string.Format(@"{0}\\{1}.vbs", path, filename), CommandsToVBS(Commands.ToList()), System.Text.Encoding.Unicode);
            }
        }

        private string CommandsToBatch(List<Command> commandList)
        {
            string strCmdText = string.Format(@"::::: GENERATED WITH NOOBS CMDR v{0} :::::", typeof(NOOBS_CMDR_Homepage).Assembly.GetName().Version);
            strCmdText += Environment.NewLine;
            strCmdText += @"chcp 65001";
            strCmdText += Environment.NewLine;
            strCmdText += Environment.NewLine;

            // Need to set up date variable for screenshots
            if (commandList.OfType<ScreenshotCommand>().Where(x => x.createNewFile).ToList().Count > 0)
            {
                strCmdText += @"FOR /f ""tokens=2 delims=="" %%G in ('wmic os get localdatetime /value') do set datetime=%%G";
                strCmdText += Environment.NewLine;
                strCmdText += @"SET hh=%time:~0,2%";
                strCmdText += Environment.NewLine;
                strCmdText += @"SET hh=%hh: =0%";
                strCmdText += Environment.NewLine;
                strCmdText += @"SET datetime=%datetime:~0,4%-%datetime:~4,2%-%datetime:~6,2% %hh%-%time:~3,2%-%time:~6,2%";
                strCmdText += Environment.NewLine;
                strCmdText += Environment.NewLine;
            }
            
            strCmdText += string.Format(@"OBSCommand.exe /server={0}:{1} /password=""{2}""", ServerText.Text, PortText.Text, PasswordText.Password);

            foreach (Command command in commandList)
            {
                strCmdText += " " + command.ToString().ReplaceTimestamp(StringExtensions.TimestampType.Batch);
            }

            return strCmdText;
        }

        private string CommandsToVBS(List<Command> commandList)
        {
            string strCmdText = string.Format(@"''''' GENERATED WITH NOOBS CMDR v{0} '''''", typeof(NOOBS_CMDR_Homepage).Assembly.GetName().Version);
            strCmdText += Environment.NewLine;
            strCmdText += Environment.NewLine;

            // Need to set up date variable for screenshots
            if (commandList.OfType<ScreenshotCommand>().Where(x => x.createNewFile).ToList().Count > 0)
            {
                strCmdText += @"Dim g_oSB : Set g_oSB = CreateObject(""System.Text.StringBuilder"")";
                strCmdText += Environment.NewLine;
                strCmdText += @"Function sprintf(sFmt, aData)";
                strCmdText += Environment.NewLine;
                strCmdText += @"   g_oSB.AppendFormat_4 sFmt, (aData)";
                strCmdText += Environment.NewLine;
                strCmdText += @"   sprintf = g_oSB.ToString()";
                strCmdText += Environment.NewLine;
                strCmdText += @"   g_oSB.Length = 0";
                strCmdText += Environment.NewLine;
                strCmdText += @"End Function";
                strCmdText += Environment.NewLine;
                strCmdText += @"Dim datetime : datetime = now()";
                strCmdText += Environment.NewLine;
                strCmdText += Environment.NewLine;
            }

            strCmdText += @"Set WshShell = CreateObject(""WScript.Shell"")";
            strCmdText += Environment.NewLine;
            strCmdText += string.Format(@"WshShell.Run ""OBSCommand.exe /server={0}:{1} /password=""""{2}""""", ServerText.Text, PortText.Text, PasswordText.Password);

            foreach (Command command in commandList)
            {
                strCmdText += " " + command.ToString().Replace(@"""", @"""""").ReplaceTimestamp(StringExtensions.TimestampType.VBS);
            }

            strCmdText += @""", 0";

            return strCmdText;
        }

        #endregion Export to Script

        #region Import Script

        private void ImportBtn_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.Filter = "Batch Script (*.bat)|*.bat|VBS Script (*.vbs)|*.vbs";
            if (dlg.ShowDialog() == true)
            {
                if (dlg.FileName.ToLower().EndsWith(".bat") || dlg.FileName.ToLower().EndsWith(".vbs"))
                {
                    string contents;

                    //Read the contents of the file into a stream
                    var fileStream = dlg.OpenFile();

                    using (StreamReader reader = new StreamReader(fileStream))
                    {
                        contents = reader.ReadToEnd();
                    }

                    if (dlg.FileName.ToLower().EndsWith(".bat"))
                    {
                        ImportFromBatch(contents);
                    }
                    else if (dlg.FileName.ToLower().EndsWith(".vbs"))
                    {
                        ImportFromVBS(contents);
                    }
                }
                else
                {
                    // Do nothing
                }
            }
        }

        private void ImportFromBatch(string contents)
        {
            Commands.Clear();

            string[] lines = contents.Split(
                new[] { "\r\n", "\r", "\n" },
                StringSplitOptions.None
            );

            foreach (string line in lines)
            {
                if (line.StartsWith("OBSCommand.exe"))
                {

                    string[] contentArray = Regex.Split(line, "[ ](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");
                    foreach (string cmdText in contentArray)
                    {
                        if (cmdText.StartsWith("OBSCommand.exe"))
                        {
                            // Do nothing
                        }
                        else if (cmdText.StartsWith("/server"))
                        {
                            // Do nothing
                        }
                        else if (cmdText.StartsWith("/password"))
                        {
                            // Do nothing
                        }
                        else if (cmdText == "/startstream")
                        {
                            Commands.Add(new StreamCommand(obs)
                            {
                                streamingStatus = StreamCommand.Status.Start
                            });
                        }
                        else if (cmdText == "/stopstream")
                        {
                            Commands.Add(new StreamCommand(obs)
                            {
                                streamingStatus = StreamCommand.Status.Stop
                            });
                        }
                        else if (cmdText == "/command=StartStopStreaming")
                        {
                            Commands.Add(new StreamCommand(obs)
                            {
                                streamingStatus = StreamCommand.Status.Toggle
                            });
                        }
                        else if (cmdText == "/startrecording")
                        {
                            Commands.Add(new RecordingCommand(obs)
                            {
                                recordingStatus = RecordingCommand.Status.Start
                            });
                        }
                        else if (cmdText == "/stoprecording")
                        {
                            Commands.Add(new RecordingCommand(obs)
                            {
                                recordingStatus = RecordingCommand.Status.Stop
                            });
                        }
                        else if (cmdText == "/command=StartStopRecording")
                        {
                            Commands.Add(new RecordingCommand(obs)
                            {
                                recordingStatus = RecordingCommand.Status.Toggle
                            });
                        }
                        else if (cmdText == "/command=PauseRecording")
                        {
                            Commands.Add(new RecordingCommand(obs)
                            {
                                recordingStatus = RecordingCommand.Status.Pause
                            });
                        }
                        else if (cmdText == "/command=ResumeRecording")
                        {
                            Commands.Add(new RecordingCommand(obs)
                            {
                                recordingStatus = RecordingCommand.Status.Resume
                            });
                        }
                        else if (cmdText.StartsWith("/profile="))
                        {
                            Commands.Add(new ProfileCommand(obs)
                            {
                                profileName = cmdText.RemoveBeforeChar('=').RemoveQuotes()
                            });
                        }
                        else if (cmdText.StartsWith("/scene="))
                        {
                            Commands.Add(new SceneCommand(obs)
                            {
                                sceneName = cmdText.RemoveBeforeChar('=').RemoveQuotes()
                            });
                        }
                        else if (cmdText.StartsWith("/showsource=") || cmdText.StartsWith("/hidesource=") || cmdText.StartsWith("/togglesource="))
                        {
                            string[] sourceArray = Regex.Split(cmdText.RemoveBeforeChar('='), "[/](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");
                            SourceCommand.State sourceState;

                            if (cmdText.StartsWith("/showsource="))
                            {
                                sourceState = SourceCommand.State.Show;
                            }
                            else if (cmdText.StartsWith("/hidesource="))
                            {
                                sourceState = SourceCommand.State.Hide;
                            }
                            else
                            {
                                sourceState = SourceCommand.State.Toggle;
                            }


                            if (sourceArray.Count() == 1)
                            {
                                Commands.Add(new SourceCommand(obs)
                                {
                                    sourceState = sourceState,
                                    sourceName = sourceArray[0].RemoveQuotes()
                                });
                            }
                            else if (sourceArray.Count() == 2)
                            {
                                Commands.Add(new SourceCommand(obs)
                                {
                                    sourceState = sourceState,
                                    sceneName = sourceArray[0].RemoveQuotes(),
                                    sourceName = sourceArray[1].RemoveQuotes()
                                });
                            }
                        }
                        else if (cmdText.StartsWith("/command=SetSourceFilterVisibility,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = "";
                            string filterName = "";
                            FilterCommand.State filterState = FilterCommand.State.Hide;

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sourceName"))
                                {
                                    sourceName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                                else if (par.StartsWith("filterName"))
                                {
                                    filterName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                                else if (par.StartsWith("filterEnabled"))
                                {
                                    filterState = par.RemoveBeforeChar('=').RemoveQuotes() == "True" ? FilterCommand.State.Show : FilterCommand.State.Hide;
                                }
                            }

                            Commands.Add(new FilterCommand(obs)
                            {
                                sourceName = sourceName,
                                filterName = filterName,
                                filterState = filterState
                            });
                        }
                        else if (cmdText.StartsWith("/mute="))
                        {
                            Commands.Add(new AudioCommand(obs)
                            {
                                audioState = AudioCommand.State.mute,
                                sourceName = cmdText.RemoveBeforeChar('=').RemoveQuotes()
                            });
                        }
                        else if (cmdText.StartsWith("/unmute="))
                        {
                            Commands.Add(new AudioCommand(obs)
                            {
                                audioState = AudioCommand.State.unmute,
                                sourceName = cmdText.RemoveBeforeChar('=').RemoveQuotes()
                            });
                        }
                        else if (cmdText.StartsWith("/toggleaudio="))
                        {
                            Commands.Add(new AudioCommand(obs)
                            {
                                audioState = AudioCommand.State.toggle,
                                sourceName = cmdText.RemoveBeforeChar('=').RemoveQuotes()
                            });
                        }
                        else if (cmdText.StartsWith("/setvolume="))
                        {
                            string parString = cmdText.RemoveBeforeChar('=');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = pars[0].RemoveQuotes();
                            int volume = int.Parse(pars[1]);
                            int delay = int.Parse(pars[2]);

                            Commands.Add(new AudioCommand(obs)
                            {
                                audioState = AudioCommand.State.setVolume,
                                sourceName = sourceName,
                                volume = volume,
                                delay = delay
                            });
                        }
                        else if (cmdText.StartsWith("/command=SetAudioMonitorType,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = "";
                            AudioCommand.MonitoringType monitorType = AudioCommand.MonitoringType.none;

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sourceName"))
                                {
                                    sourceName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                                else if (par.StartsWith("monitorType"))
                                {
                                    if (par.RemoveBeforeChar('=') == "none")
                                    {
                                        monitorType = AudioCommand.MonitoringType.none;
                                    }
                                    else if (par.RemoveBeforeChar('=') == "monitorOnly")
                                    {
                                        monitorType = AudioCommand.MonitoringType.monitorOnly;
                                    }
                                    else if (par.RemoveBeforeChar('=') == "monitorAndOutput")
                                    {
                                        monitorType = AudioCommand.MonitoringType.monitorAndOutput;
                                    }
                                }
                            }

                            Commands.Add(new AudioCommand(obs)
                            {
                                audioState = AudioCommand.State.setMonitoringType,
                                sourceName = sourceName,
                                monitoringType = monitorType
                            });
                        }
                        else if (cmdText.StartsWith("/command=PlayPauseMedia,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = "";
                            MediaCommand.ControlType controlType = MediaCommand.ControlType.play;

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sourceName"))
                                {
                                    sourceName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                                else if (par.StartsWith("playPause"))
                                {
                                    if (par.RemoveBeforeChar('=') == "False")
                                    {
                                        controlType = MediaCommand.ControlType.play;
                                    }
                                    else if (par.RemoveBeforeChar('=') == "True")
                                    {
                                        controlType = MediaCommand.ControlType.pause;
                                    }
                                }
                            }

                            Commands.Add(new MediaCommand(obs)
                            {
                                sourceName = sourceName,
                                controlType = controlType
                            });
                        }
                        else if (cmdText.StartsWith("/command=RestartMedia,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = "";
                            MediaCommand.ControlType state = MediaCommand.ControlType.restart;

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sourceName"))
                                {
                                    sourceName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                            }

                            Commands.Add(new MediaCommand(obs)
                            {
                                sourceName = sourceName,
                                controlType = state
                            });
                        }
                        else if (cmdText.StartsWith("/command=StopMedia,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = "";
                            MediaCommand.ControlType state = MediaCommand.ControlType.stop;

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sourceName"))
                                {
                                    sourceName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                            }

                            Commands.Add(new MediaCommand(obs)
                            {
                                sourceName = sourceName,
                                controlType = state
                            });
                        }
                        else if (cmdText.StartsWith("/command=NextMedia,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = "";
                            MediaCommand.ControlType state = MediaCommand.ControlType.next;

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sourceName"))
                                {
                                    sourceName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                            }

                            Commands.Add(new MediaCommand(obs)
                            {
                                sourceName = sourceName,
                                controlType = state
                            });
                        }
                        else if (cmdText.StartsWith("/command=PreviousMedia,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = "";
                            MediaCommand.ControlType state = MediaCommand.ControlType.previous;

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sourceName"))
                                {
                                    sourceName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                            }

                            Commands.Add(new MediaCommand(obs)
                            {
                                sourceName = sourceName,
                                controlType = state
                            });
                        }
                        else if (cmdText.StartsWith("/command=SetCurrentTransition,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string transitionName = pars[0].RemoveBeforeChar('=').RemoveQuotes();

                            Commands.Add(new TransitionCommand(obs)
                            {
                                transitionState = TransitionCommand.State.SetCurrentTransition,
                                transitionName = transitionName
                            });
                        }
                        else if (cmdText.StartsWith("/command=SetTransitionDuration,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            int duration = int.Parse(pars[0].RemoveBeforeChar('='));

                            Commands.Add(new TransitionCommand(obs)
                            {
                                transitionState = TransitionCommand.State.SetTransitionDuration,
                                duration = duration
                            });
                        }
                        else if (cmdText.StartsWith("/command=SetSceneTransitionOverride,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sceneName = "";
                            string transitionName = "";
                            int transitionDuration = 100;

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sceneName"))
                                {
                                    sceneName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                                else
                                if (par.StartsWith("transitionName"))
                                {
                                    transitionName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                                else if (par.StartsWith("transitionDuration"))
                                {
                                    transitionDuration = int.Parse(par.RemoveBeforeChar('='));
                                }
                            }

                            Commands.Add(new TransitionCommand(obs)
                            {
                                transitionState = TransitionCommand.State.SetSceneTransitionOverride,
                                sceneName = sceneName,
                                transitionName = transitionName,
                                duration = transitionDuration
                            });
                        }
                        else if (cmdText.StartsWith("/command=RemoveSceneTransitionOverride,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sceneName = pars[0].RemoveBeforeChar('=').RemoveQuotes();

                            Commands.Add(new TransitionCommand(obs)
                            {
                                transitionState = TransitionCommand.State.RemoveTransitionOverride,
                                sceneName = sceneName
                            });
                        }
                        else if (cmdText == "/command=EnableStudioMode")
                        {
                            Commands.Add(new StudioModeCommand(obs)
                            {
                                studioModeState = StudioModeCommand.State.Enable
                            });
                        }
                        else if (cmdText == "/command=DisableStudioMode")
                        {
                            Commands.Add(new StudioModeCommand(obs)
                            {
                                studioModeState = StudioModeCommand.State.Disable
                            });
                        }
                        else if (cmdText == "/command=ToggleStudioMode")
                        {
                            Commands.Add(new StudioModeCommand(obs)
                            {
                                studioModeState = StudioModeCommand.State.Toggle
                            });
                        }
                        else if (cmdText.StartsWith("/command=TakeSourceScreenshot,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            string sourceName = "";
                            string saveToFilePath = "";

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("sourceName"))
                                {
                                    sourceName = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                                else if (par.StartsWith("saveToFilePath"))
                                {
                                    saveToFilePath = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                            }

                            bool includesDate = saveToFilePath.IncludesDate();

                            saveToFilePath = saveToFilePath.RemoveDate();

                            if (obs.GetSceneList().Scenes.ConvertAll(x => x.Name).Contains(sourceName))
                            {
                                Commands.Add(new ScreenshotCommand(obs)
                                {
                                    screenshotType = ScreenshotCommand.Type.Scene,
                                    sceneName = sourceName,
                                    saveToFilePath = saveToFilePath,
                                    createNewFile = includesDate
                                });
                            }
                            else
                            {
                                Commands.Add(new ScreenshotCommand(obs)
                                {
                                    screenshotType = ScreenshotCommand.Type.Source,
                                    sourceName = sourceName,
                                    saveToFilePath = saveToFilePath,
                                    createNewFile = includesDate
                                });
                            }
                        }
                        else if (cmdText == "/command=StartReplayBuffer")
                        {
                            Commands.Add(new ReplayBufferCommand(obs)
                            {
                                replayBufferState = ReplayBufferCommand.State.Start
                            });
                        }
                        else if (cmdText == "/command=StopReplayBuffer")
                        {
                            Commands.Add(new ReplayBufferCommand(obs)
                            {
                                replayBufferState = ReplayBufferCommand.State.Stop
                            });
                        }
                        else if (cmdText == "/command=StartStopReplayBuffer")
                        {
                            Commands.Add(new ReplayBufferCommand(obs)
                            {
                                replayBufferState = ReplayBufferCommand.State.Toggle
                            });
                        }
                        else if (cmdText == "/command=SaveReplayBuffer")
                        {
                            Commands.Add(new ReplayBufferCommand(obs)
                            {
                                replayBufferState = ReplayBufferCommand.State.Save
                            });
                        }
                        else if (cmdText.StartsWith("/command=OpenProjector,"))
                        {
                            string parString = cmdText.RemoveBeforeChar(',');
                            string[] pars = Regex.Split(parString, "[,](?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");

                            ProjectorCommand.Type projectorType = ProjectorCommand.Type.Preview;
                            int? monitor = null;
                            string name = "";

                            foreach (string par in pars)
                            {
                                if (par.StartsWith("type"))
                                {
                                    if (par.RemoveBeforeChar('=') == "Preview")
                                    {
                                        projectorType = ProjectorCommand.Type.Preview;
                                    }
                                    else if (par.RemoveBeforeChar('=') == "StudioProgram")
                                    {
                                        projectorType = ProjectorCommand.Type.StudioProgram;
                                    }
                                    else if (par.RemoveBeforeChar('=') == "Scene")
                                    {
                                        projectorType = ProjectorCommand.Type.Scene;
                                    }
                                    else if (par.RemoveBeforeChar('=') == "Source")
                                    {
                                        projectorType = ProjectorCommand.Type.Source;
                                    }
                                    else if (par.RemoveBeforeChar('=') == "MultiView")
                                    {
                                        projectorType = ProjectorCommand.Type.MultiView;
                                    }
                                }
                                else if (par.StartsWith("monitor"))
                                {
                                    monitor = int.Parse(par.RemoveBeforeChar('='));
                                }
                                else if (par.StartsWith("name"))
                                {
                                    name = par.RemoveBeforeChar('=').RemoveQuotes();
                                }
                            }
                            if (obs.GetSceneList().Scenes.ConvertAll(x => x.Name).Contains(name))
                            {
                                Commands.Add(new ProjectorCommand(obs)
                                {
                                    projectorType = projectorType,
                                    monitor = monitor,
                                    isFullscreen = monitor != null ? true : false,
                                    sceneName = name
                                });
                            }
                            else
                            {
                                Commands.Add(new ProjectorCommand(obs)
                                {
                                    projectorType = projectorType,
                                    monitor = monitor,
                                    isFullscreen = monitor != null ? true : false,
                                    sourceName = name
                                });
                            }
                        }
                        else if (cmdText.StartsWith("/delay="))
                        {
                            Commands.Add(new DelayCommand(obs)
                            {
                                delay = (int)(decimal.Parse(cmdText.RemoveBeforeChar('=')) * 1000)
                            });
                        }
                        else
                        {
                            Commands.Add(new CustomCommand(obs)
                            {
                                command = cmdText
                            });
                        }
                    }
                }
            }
        }

        private void ImportFromVBS(string contents)
        {
            string[] lines = contents.Split(
                new[] { "\r\n", "\r", "\n" },
                StringSplitOptions.None
            );

            foreach (string line in lines)
            {
                if (line.StartsWith("WshShell.Run ") && line.EndsWith(", 0"))
                {
                    string cmd = line.RemoveDate();
                    cmd = cmd.Remove(cmd.Length - 4);
                    cmd = cmd.Substring(14);

                    cmd = cmd.Replace(@"""""", @"""");

                    ImportFromBatch(cmd);
                }
            }
        }

        #endregion Import Script

        #region IDropTarget

        void IDropTarget.DragOver(IDropInfo dropInfo)
        {
            if (((ObservableCollection<Command>)dropInfo.TargetCollection).Contains(dropInfo.Data))
            {
                dropInfo.DropTargetAdorner = DropTargetAdorners.Insert;
                dropInfo.Effects = DragDropEffects.Move;
            }
        }

        void IDropTarget.Drop(IDropInfo dropInfo)
        {
            int oldIndex = ((ObservableCollection<Command>)dropInfo.TargetCollection).IndexOf((Command)dropInfo.Data);
            int newIndex = dropInfo.InsertIndex <= oldIndex ? dropInfo.InsertIndex : dropInfo.InsertIndex - 1;

            ((ObservableCollection<Command>)dropInfo.TargetCollection).RemoveAt(oldIndex);
            ((ObservableCollection<Command>)dropInfo.TargetCollection).Insert(newIndex, (Command)dropInfo.Data);
        }

        #endregion IDropTarget

        #region Donate

        private void DonateBtn_Click(object sender, RoutedEventArgs e)
        {
            System.Diagnostics.Process.Start("https://streamelements.com/nutty-1152/tip");
        }

        #endregion Donate
    }
}