random-file-runner/MainForm.cs

using RyzStudio.IO;
using RyzStudio.Windows.Forms;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace RandomFileRunner
{
    public partial class MainForm : Form
    {
        [DllImport("user32.dll")]
        protected static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);

        [DllImport("user32.dll")]
        protected static extern bool UnregisterHotKey(IntPtr hWnd, int id);

        //protected const int MOD_NONE = 0x0000;
        //protected const int MOD_ALT = 0x1;
        //protected const int MOD_CONTROL = 0x2;
        //protected const int MOD_SHIFT = 0x4;
        //protected const int MOD_WIN = 0x8;
        protected const int WM_HOTKEY = 0x312;
        protected const int WM_QUERYENDSESSION = 0x0011;


        protected readonly Random randy = new Random();
        protected CancellationTokenSource cancellationToken = new CancellationTokenSource();

        protected OptionsForm optionsForm = null;
        protected bool isBusy = false;
        protected bool requestCancel = false;

        protected List<string> foundFiles = null;
        protected Process currentProcess = null;


        public MainForm()
        {
            InitializeComponent();

            textBox1.Text = "*.*";
            memoBox1.TextBox.WordWrap = false;
        }

        protected async override void OnShown(EventArgs e)
        {
            base.OnShown(e);

            string[] commandLineArgs = Environment.GetCommandLineArgs();

            string jsonfigFilename = null;
            if (string.IsNullOrWhiteSpace(jsonfigFilename)) jsonfigFilename = ParseOpenFile_FromCMD(commandLineArgs);
            if (string.IsNullOrWhiteSpace(jsonfigFilename)) jsonfigFilename = Path.ChangeExtension(Application.ExecutablePath, "jsonfig");

            if (!string.IsNullOrWhiteSpace(jsonfigFilename) && File.Exists(jsonfigFilename))
            {
                await LoadSessionFile(jsonfigFilename);
            }
        }

        protected override void OnClosing(CancelEventArgs e)
        {
            base.OnClosing(e);

            if (this.IsBusy)
            {
                e.Cancel = true;
                return;
            }

            if (this.CurrentSession.ClosePrevOnNext) CloseCurrentProcess(currentProcess);

            if (this.CurrentSession.NextHotKey != null)
            {
                if (this.CurrentSession.NextHotKey.KeyCode != Keys.None)
                {
//#if !DEBUG
                    UnregisterHotKey((IntPtr)Handle, 1);
//#endif
                }
            }
        }

        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
                case WM_HOTKEY:
                    if (m.WParam.ToInt32() == 1) button5_MouseClick(null, null);

                    break;
                //case WM_QUERYENDSESSION:
                //    requestExit = true;
                //    //this.Close();
                //    Application.Exit();

                //    break;
                default: break;
            }

            base.WndProc(ref m);
        }


        public bool IsBusy
        {
            get => isBusy;
            set
            {
                isBusy = value;

                ThreadControl.SetValue(pictureBox1, (isBusy ? UIcon.GetImage("loading_block") : null));
                ThreadControl.SetEnable(textBox1, !isBusy);
                //ThreadControl.SetEnable(button2, !isBusy);
                button2.LabelText = (isBusy? "&Cancel" : "&Search");
                ThreadControl.SetEnable(button3, !isBusy);
                ThreadControl.SetEnable(button4, !isBusy);
                ThreadControl.SetEnable(memoBox1, !isBusy);
                ThreadControl.SetEnable(button5, !isBusy);
                //ThreadControl.SetEnable(button1, !isBusy);
            }
        }

        public AppSession CurrentSession { get; set; } = new AppSession();


        protected bool SearchDirecory_OnFound(string file, ulong searchCount, int searchQueue)
        {
            if (!string.IsNullOrWhiteSpace(file))
            {
                foundFiles.Add(file);
            }

            //ThreadControl.SetText(label2, foundFiles.Count.ToString());
            ThreadControl.SetText(label2, foundFiles.Count.ToString("#,#", System.Globalization.CultureInfo.CurrentCulture) + Environment.NewLine + searchQueue.ToString("#,#", System.Globalization.CultureInfo.CurrentCulture));

            return true;
        }



        /// <summary>
        /// New
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void newToolStripMenuItem_Click(object sender, EventArgs e)
        {
            await Task.Run(() =>
            {
                if (this.IsBusy) return;

                if (this.CurrentSession.ClosePrevOnNext) CloseCurrentProcess(currentProcess);

                ClearSession();
            });
        }

        /// <summary>
        /// Open
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void openToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (this.IsBusy) return;

            if (openFileDialog2.ShowDialog() == DialogResult.OK)
            {
                await LoadSessionFile(openFileDialog2.FileName);
            }
        }

        /// <summary>
        /// Save as
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (this.IsBusy) return;

            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                await SaveSessionFile(saveFileDialog1.FileName);
            }
        }

        /// <summary>
        /// Close
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void exitToolStripMenuItem2_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        /// <summary>
        /// Options
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void optionsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (this.IsBusy) return;

            if (optionsForm == null) optionsForm = new OptionsForm(this.CurrentSession);
            if (optionsForm.ShowDialog() == DialogResult.OK)
            {
                this.CurrentSession = optionsForm.Session;

                InvalidateHotKey();
            }
        }

        /// <summary>
        /// Help
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void viewHelpToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            try
            {
                System.Diagnostics.Process.Start(new ProcessStartInfo()
                {
                    FileName = AppResource.AppHelpURL,
                    UseShellExecute = true
                });
            }
            catch
            {
                // do nothing
            }
        }

        /// <summary>
        /// About
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void aboutToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            MessageBox.Show(Application.ProductName + " v" + Application.ProductVersion, "About", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }


        /// <summary>
        /// Search
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void button2_MouseClick(object sender, MouseEventArgs e)
        {
            await Task.Run(async () =>
            {
                if (this.IsBusy)
                {
                    requestCancel = true;
                    button2.LabelText = "&Cancelling...";
                    cancellationToken.Cancel();

                    return;
                }

                this.IsBusy = true;
                requestCancel = false;

                foundFiles = new List<string>();
                cancellationToken = new CancellationTokenSource();
                currentProcess = null;

                if (!string.IsNullOrWhiteSpace(memoBox1.Text))
                {
                    string[] itemList = memoBox1.Text?.Trim().Split('\n');
                    for (int i = 0; i < itemList.Length; i++)
                    {
                        if (string.IsNullOrWhiteSpace(itemList[i])) continue;
                        if (requestCancel) break;

                        string item = itemList[i]?.Trim();

                        if (File.Exists(item))
                        {
                            if (AccessibleDirectory.IsFileAccessible(item))
                            {
                                foundFiles.Add(item);
                                ThreadControl.SetText(label2, foundFiles.Count.ToString());

                                continue;
                            }
                        }

                        if (Directory.Exists(item))
                        {
                            await AccessibleDirectory.GetFilesAsync(item, textBox1.Text, this.CurrentSession.SearchTopDirectoryOnly, SearchDirecory_OnFound, cancellationToken.Token);

                            ThreadControl.SetText(label2, foundFiles.Count.ToString());

                            continue;
                        }
                    }
                }

                ThreadControl.SetText(label2, ((foundFiles.Count <= 0) ? "0" :foundFiles.Count.ToString("#,#", System.Globalization.CultureInfo.CurrentCulture)) + " File" + ((foundFiles.Count == 1) ? "" : "s") + " Found");

                this.IsBusy = false;
                requestCancel = false;
            });
        }

        /// <summary>
        /// Add directory
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void addDirectoryToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (this.IsBusy) return;

            if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
            {
                AddSearchItem(folderBrowserDialog1.SelectedPath);
            }
        }

        /// <summary>
        /// Add file
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void addFileToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (this.IsBusy) return;

            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                AddSearchItem(openFileDialog1.FileName);
            }
        }

        /// <summary>
        ///  Clear
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button4_MouseClick(object sender, MouseEventArgs e)
        {
            if (this.IsBusy) return;

            memoBox1.Text = string.Empty;
        }

        private void memoBox1_DragOver(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                if (this.IsBusy)
                {
                    e.Effect = DragDropEffects.None;
                }
                else
                {
                    e.Effect = DragDropEffects.Copy;
                }
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }

        private void memoBox1_DragDrop(object sender, DragEventArgs e)
        {
            if (this.IsBusy) return;

            string[] fileList = e.Data.GetData(DataFormats.FileDrop) as string[];
            if (fileList == null)
            {
                return;
            }

            foreach (string item in fileList)
            {
                AddSearchItem(item);
            }
        }

        /// <summary>
        /// Run next
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void button5_MouseClick(object sender, MouseEventArgs e)
        {
            await Task.Run(() =>
            {
                if (this.IsBusy) return;
                if (foundFiles.Count <= 0) return;

                //this.IsBusy = true;

                if (this.CurrentSession == null) this.CurrentSession = new AppSession();

                if (this.CurrentSession.ClosePrevOnNext) CloseCurrentProcess(currentProcess);

                string filename = null;

                // retry 8 times
                for (int i = 0; i < this.CurrentSession.RetryOnError; i++)
                {
                    filename = foundFiles[randy.Next(0, (foundFiles.Count - 1))];
                    if (File.Exists(filename))
                    {
                        continue;
                    }

                    filename = null;
                }

                if (!string.IsNullOrWhiteSpace(filename))
                {
                    ProcessStartInfo psi = new ProcessStartInfo(filename);
                    psi.UseShellExecute = true;

                    try
                    {
                        currentProcess = Process.Start(psi);
                    }
                    catch (Exception)
                    {
                        // do nothing
                    }
                }

                //this.IsBusy = false;
            });
        }

        /// <summary>
        /// Close
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_MouseClick(object sender, MouseEventArgs e)
        {
            this.Close();
        }


        protected void AddSearchItem(string line)
        {
            memoBox1.Text = memoBox1.Text.Trim();

            // above line-break
            if (!string.IsNullOrWhiteSpace(memoBox1.Text)) memoBox1.Text += Environment.NewLine;

            memoBox1.Text += line + Environment.NewLine;
        }

        private void CloseCurrentProcess(Process p)
        {
            if (p == null) return;

            try
            {
                p.CloseMainWindow();
                //p.Close();
            }
            catch (Exception)
            {
                // do nothing
            }
        }

        private void InvalidateHotKey()
        {
//#if !DEBUG
            if (this.InvokeRequired)
            {
                this.Invoke(new MethodInvoker(() =>
                {
                    UnregisterHotKey((IntPtr)Handle, 1);
                }));
            }
            else
            {
                UnregisterHotKey((IntPtr)Handle, 1);
            }
//#endif

            if (this.CurrentSession.NextHotKey != null)
            {
                if (this.CurrentSession.NextHotKey.KeyCode != Keys.None)
                {
//#if !DEBUG
                    if (this.InvokeRequired)
                    {
                        this.Invoke(new MethodInvoker(() =>
                        {
                            RegisterHotKey((IntPtr)Handle, 1, this.CurrentSession.NextHotKey.ModifierCode, this.CurrentSession.NextHotKey.Key);
                        }));
                    }
                    else
                    {
                        RegisterHotKey((IntPtr)Handle, 1, this.CurrentSession.NextHotKey.ModifierCode, this.CurrentSession.NextHotKey.Key);
                    }
//#endif
                }
            }
        }

        private void ClearSession()
        {
            foundFiles = new List<string>();
            currentProcess = null;
            textBox1.Text = "*.*";
            ThreadControl.SetText(label2, "0");
            memoBox1.Text = string.Empty;
        }

        protected async Task LoadSessionFile(string filename)
        {
            await Task.Run(() =>
            {
                if (string.IsNullOrWhiteSpace(filename)) return;
                if (!File.Exists(filename)) return;

                string sourceCode = null;

                try
                {
                    sourceCode = File.ReadAllText(filename);
                }
                catch (Exception exc)
                {
                    MessageBox.Show(exc.Message, "Load session");
                    return;
                }

                if (string.IsNullOrWhiteSpace(sourceCode))
                {
                    return;
                }

                // load options
                var options = new JsonSerializerOptions();
                //options.Converters.Add(new JsonPointConverter());
                //options.Converters.Add(new JsonSizeConverter());

                try
                {
                    this.CurrentSession = JsonSerializer.Deserialize<AppSession>(sourceCode, options);
                }
                catch (Exception exc)
                {
                    MessageBox.Show("Unable to read session", "Load session");
                    return;
                }

                if (this.CurrentSession == null) this.CurrentSession = new AppSession();

                ClearSession();

                textBox1.Text = (string.IsNullOrWhiteSpace(this.CurrentSession.SearchFilePattern) ? "*" : this.CurrentSession.SearchFilePattern?.Trim());

                if (this.CurrentSession.SearchItems != null)
                {
                    foreach (string item in this.CurrentSession.SearchItems)
                    {
                        AddSearchItem(item);
                    }
                }

                // hotkey
                InvalidateHotKey();
            });
        }

        protected string ParseOpenFile_FromCMD(string[] args)
        {
            if (args.Length <= 1)
            {
                return null;
            }

            int i = 1;
            while (true)
            {
                if (i > (args.Length - 1))
                {
                    break;
                }

                switch (args[i].Trim().ToLower())
                {
                    case "-o":
                    case "-open":
                        if ((i + 1) > (args.Length - 1)) break;

                        string openFilename = args[(i + 1)];
                        if (string.IsNullOrWhiteSpace(openFilename)) break;
                        if (!File.Exists(openFilename)) break;

                        return openFilename;

                        i++;
                        break;
                }

                i++;
            }

            return null;
        }

        protected async Task SaveSessionFile(string filename)
        {
            await Task.Run(() =>
            {
                if (string.IsNullOrWhiteSpace(filename)) return;

                if (this.CurrentSession == null) this.CurrentSession = new AppSession();
                this.CurrentSession.SearchFilePattern = textBox1.Text;
                this.CurrentSession.SearchItems = new List<string>();

                if (!string.IsNullOrWhiteSpace(memoBox1.Text))
                {
                    foreach (string item in memoBox1.Text?.Trim().Split('\n'))
                    {
                        if (string.IsNullOrWhiteSpace(item))
                        {
                            continue;
                        }

                        this.CurrentSession.SearchItems.Add(item?.Trim());
                    }
                }

                string sourceCode = null;

                try
                {
                    sourceCode = JsonSerializer.Serialize(this.CurrentSession);
                }
                catch (Exception)
                {
                    MessageBox.Show("Unable to write session", "Save session");
                    return;
                }

                try
                {
                    File.WriteAllText(filename, sourceCode);
                }
                catch (Exception exc)
                {
                    MessageBox.Show(exc.Message, "Save session");
                    return;
                }
            });
        }

    }
}