source: 2014/tet/FileWatcher/FileWatcher/Program.cs @ 5795

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Permissions;
using System.IO;
using System.Diagnostics;
using System.Threading;
using System.ComponentModel;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Windows.Threading;


namespace FileWatcher
{
    public static class Program
    {
        /// <summary>
        /// Kansio, jota tarkkaillaan.
        /// </summary>
        public static String SelectedFolder { get; set; }

        /// <summary>
        /// Tiedostotyypit, joita tarkkaillaan.
        /// </summary>
        public static String[] SelectedFileExtensions { get; set; }

        /// <summary>
        /// Ohjelmat, jotka ajetaan tiedoston löytyessä.
        /// </summary>
        public static List<Executable> ExecutablePrograms;

        private static List<String> jobs = new List<String>();
        private static List<FileSystemWatcher> watchers;

        public static bool WatchCreation { get; set; }
        public static bool WatchDeletion { get; set; }
        public static bool WatchChanges { get; set; }
        public static bool WatchRenaming { get; set; }

        /// <summary>
        /// Tarkkaillaanko alikansioita.
        /// </summary>
        public static bool WatchSubdirectories { get; set; }

        public static readonly String WorkingDirectory = AppDomain.CurrentDomain.BaseDirectory;
        public static readonly String OptionsFilePath = WorkingDirectory + "\\options.dat";
        public static readonly String LogFilePath = WorkingDirectory + "\\log.txt";
        public static StreamWriter LogWriter;

        /// <summary>
        /// Ladataanko edelliset asetukset automaattisesti ohjelman käynnistyessä.
        /// </summary>
        public static bool LoadSettingsAutomatically { get; set; }

        /// <summary>
        /// Tallenetaanko asetukset ohjelman sulkeutuessa.
        /// </summary>
        public static bool SaveSettingsAutomatically { get; set; }

        /// <summary>
        /// Aloitetaanko tarkkailu automaattisesti edellisillä asetuksilla.
        /// </summary>
        public static bool StartWatchingAutomatically { get; set; }

        /// <summary>
        /// Pidetäänkö lokia ohjelman tekemisistä.
        /// </summary>
        public static bool KeepLog { get; set; }

        /// <summary>
        /// Oletusasetukset.
        /// </summary>
        public static readonly OptionsFile DefaultSettings = new OptionsFile("", null, null, true, false, false, false, false, false, false, true);

        public static void Initialize()
        {
            AddMessage("Initializing...");
            LogWriter = new StreamWriter(LogFilePath, true);
            OptionsFile ops = LoadSettings();
            if (ops.LoadSettingsAutomatically)
            {
                UseSettings(ops);
                AddMessage("Loaded previous settings.");
            }
            else UseSettings(ops, true);
            if (ops.KeepLog)
            {
                AddMessage("Logging ON, keeping log in file: log.txt.");
            }
            else AddMessage("Logging OFF.");
            if (StartWatchingAutomatically)
            {
                AddMessage("Starting to watch automatically...");
                Start();
                MainWindow.StartButton.IsEnabled = false;
                MainWindow.StopButton.IsEnabled = true;
                MainWindow.ResetButton.IsEnabled = false;
                MainWindow.Directory.IsEnabled = false;
                MainWindow.Extensions.IsEnabled = false;
                MainWindow.SubfolderBox.IsEnabled = false;
                MainWindow.CreationBox.IsEnabled = false;
                MainWindow.DeletionBox.IsEnabled = false;
                MainWindow.ChangeBox.IsEnabled = false;
                MainWindow.RenameBox.IsEnabled = false;
                MainWindow.LoadButton.IsEnabled = false;
                MainWindow.DirectoryBrowseButton.IsEnabled = false;
            }
        }

        /// <summary>
        /// Aloitetaan tarkkailuprosessi.
        /// </summary>
        public static bool Start()
        {
            AddMessage("Verifying inputs...");

            if (SelectedFolder == "" || SelectedFolder == MainWindow.DIRECTORY_DEFAULT_TEXT)
            {
                AddMessage("The folder path is empty!");
                return false;
            }

            try
            {
                FileInfo f = new FileInfo(SelectedFolder); // tarkistetaan kansion polun oikeellisuus
            }
            catch (ArgumentException)
            {
                AddMessage("The folder path is invalid!");
                return false;
            }

            if (SelectedFileExtensions == null)
            {
                AddMessage("No file extensions specified!");
                return false;
            }

            if (SelectedFileExtensions.Length == 0)
            {
                AddMessage("No file extensions specified!");
                return false;
            }

            if (ExecutablePrograms == null)
            {
                AddMessage("No executable programs selected!");
                return false;
            }

            WatchCreation = (bool)MainWindow.CreationBox.IsChecked;
            WatchDeletion = (bool)MainWindow.DeletionBox.IsChecked;
            WatchChanges = (bool)MainWindow.ChangeBox.IsChecked;
            WatchRenaming = (bool)MainWindow.RenameBox.IsChecked;

            if (WatchChanges == false && WatchCreation == false && WatchDeletion == false && WatchRenaming == false)
            {
                AddMessage("No events selected!");
                return false;
            }

            AddMessage("Inputs valid. Starting to watch.");

            StartWatching();
            return true;
        }

        /// <summary>
        /// Aloitetaan tiedosten muutosten tarkkailu valitussa kansiossa.
        /// </summary>
        [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
        public static void StartWatching()
        {
            watchers = new List<FileSystemWatcher>();

            foreach (String extension in SelectedFileExtensions)
            {
                FileSystemWatcher watcher = new FileSystemWatcher();
                var searchPath = SelectedFolder;
                watcher.Path = searchPath;
                watcher.IncludeSubdirectories = WatchSubdirectories;
                watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
                   | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.Attributes | NotifyFilters.Size | NotifyFilters.Security | NotifyFilters.CreationTime;
                watcher.Filter = extension;

                if (WatchCreation) watcher.Created += delegate(object source, FileSystemEventArgs e) { OnChanged(source, e); };
                if (WatchDeletion) watcher.Deleted += delegate(object source, FileSystemEventArgs e) { OnChanged(source, e); };
                if (WatchChanges) watcher.Changed += delegate(object source, FileSystemEventArgs e) { OnChanged(source, e); };
                if (WatchRenaming) watcher.Renamed += delegate(object source, RenamedEventArgs e) { OnChanged(source, e); };

                watcher.EnableRaisingEvents = true;
                watchers.Add(watcher);
            }
            if (WatchSubdirectories) AddMessage("Watching folder " + SelectedFolder + " and its subfolders for changes.");
            else AddMessage("Watching folder " + SelectedFolder + " for changes.");

            AddMessage("Watched file types: ", false);
            foreach (String ext in SelectedFileExtensions)
            {
                AddMessage(ext, false);
            }

            AddMessage("\nWatched events: ");
            if (WatchCreation) AddMessage("File creation");
            if (WatchDeletion) AddMessage("File deletion");
            if (WatchChanges) AddMessage("Changes in files");
            if (WatchRenaming) AddMessage("Renaming files");
        }

        /// <summary>
        /// Lopetetaan muutosten tarkkailu.
        /// </summary>
        public static void StopWatching()
        {
            if (watchers != null)
            {
                for (int i = 0; i < watchers.Count; i++)
                {
                    watchers[i].EnableRaisingEvents = false;
                    watchers[i].Dispose();
                }
                watchers.Clear();
                jobs.Clear();
                AddMessage("Stopped watching.");
            }
            AddMessage("-----------------------------------");
            AddMessage();
        }

        /// <summary>
        /// Näytetään tekstiä viesti-ikkunassa.
        /// </summary>
        /// <param name="message">Näytettävä viesti.</param>
        public static void AddMessage(String message, bool addNewLine = true)
        {
            if (addNewLine) MainWindow.MessageWindow.Content += message + "\n";
            else MainWindow.MessageWindow.Content += message;
            MainWindow.MessageWindow.ScrollToBottom();
            if (KeepLog) WriteToLog(message);
        }

        /// <summary>
        /// Lisätään rivinvaihto viesti-ikkunaan.
        /// </summary>
        public static void AddMessage()
        {
            MainWindow.MessageWindow.Content += "\n";
            MainWindow.MessageWindow.ScrollToBottom();
            if (KeepLog) WriteToLog();
        }

        /// <summary>
        /// Lisätään viesti-ikkunaan viesti toisesta säikeestä.
        /// </summary>
        /// <param name="message">Viesti</param>
        public static void AddMessageFromAnotherThread(String message, bool addNewLine = true)
        {
            MainWindow.UIDispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
            {
                if (addNewLine) MainWindow.MessageWindow.Content += message + "\n";
                else MainWindow.MessageWindow.Content += message;
                MainWindow.MessageWindow.ScrollToBottom();
                if (KeepLog) WriteToLog(message);
            }));
        }

        /// <summary>
        /// Tyhjennetään viesti-ikkuna.
        /// </summary>
        public static void ClearMessages()
        {
            MainWindow.MessageWindow.Content = "";
        }

        /// <summary>
        /// Ajetaan ohjelmat tiedoston muututtua.
        /// </summary>
        /// <param name="source">Jaa?</param>
        /// <param name="e">Tiedoston polku.</param>
        private static void OnChanged(object source, FileSystemEventArgs e)
        {
            String changedFile = e.FullPath;
            FileInfo file = new FileInfo(changedFile);

            if (jobs.Contains(changedFile))
                return;

            AddMessageFromAnotherThread("File \"" + GetName(changedFile) + "\" changed (" + e.ChangeType.ToString() + ")");
            jobs.Add(changedFile);

            /*// wait until file is not locked anymore
            while (IsFileLocked(file))
            {
                AddMessageFromAnotherThread("File locked, waiting for it to be released before continuing.");
                Thread.Sleep(5000);
            }*/

            int waitedTime = 0;
            const int MAXIMUM_WAIT_TIME = 60000; // minuutti
            // wait until file is not locked anymore
            while (true)
            {
                bool? fileState = IsFileLocked(file);
                if (fileState == false) break;
                if (fileState == null)
                {
                    AddMessageFromAnotherThread("Aborting execution, file is missing."); // ehkä ajo ilman tiedostoa?
                    return;
                }
                // jäljellä true, joten odotellaan tiedoston vapautumista

                if (waitedTime > MAXIMUM_WAIT_TIME)
                {
                    AddMessageFromAnotherThread("Aborting execution, file has been locked for too long or something else has gone wrong.");
                    return;
                }

                AddMessageFromAnotherThread("File locked, waiting for it to be released before continuing.");
                Thread.Sleep(5000);
                waitedTime += 5000;
            }


            for (int i = 0; i < ExecutablePrograms.Count; i++)
            {
                ProcessStartInfo psi = new ProcessStartInfo();
                psi.FileName = Environment.ExpandEnvironmentVariables(ExecutablePrograms[i].Path);
                psi.Arguments = Environment.ExpandEnvironmentVariables(GenerateArguments(ExecutablePrograms[i], changedFile));

                try
                {
                    AddMessageFromAnotherThread("Executing program \"" + ExecutablePrograms[i].GetName() + "\".");
                    Process process = Process.Start(psi);
                    process.EnableRaisingEvents = true; // muuten ei tule Exitediä
                    process.Exited += delegate {
                        jobs.Remove(changedFile);
                        /*if (ExecutablePrograms[i].SubPrograms != null && ExecutablePrograms[i].SubPrograms.Count != 0)
                        {
                            RunSubProgram(ExecutablePrograms[i], changedFile);
                        }*/
                    };
                }
                catch (Win32Exception ex)
                {
                    AddMessageFromAnotherThread("Execution failed, Win32 error code: " + (ex.ErrorCode + Math.Pow(2, 31)));
                    jobs.Remove(changedFile);
                }
            }
        }

        /// <summary>
        /// Ajetaan kaikki ohjelman aliohjelmat siten, että edellisen päätyttyä seuraava käynnistyy.
        /// </summary>
        /// <param name="parent">Ohjelma, jonka aliohjelmat ajetaan.</param>
        /// <param name="file">Päivittynyt tiedosto.</param>
        /*private static void RunSubProgram(Executable parent, string file)
        {
            if (parent.CurrentSubProgram >= parent.SubPrograms.Count) return;

            ProcessStartInfo psi = new ProcessStartInfo();
            psi.FileName = Environment.ExpandEnvironmentVariables(parent.SubPrograms[parent.CurrentSubProgram].Path);
            psi.Arguments = Environment.ExpandEnvironmentVariables(GenerateArguments(parent.SubPrograms[parent.CurrentSubProgram], file));

            try
            {
                AddMessageFromAnotherThread("Executing subprogram \"" + parent.SubPrograms[parent.CurrentSubProgram].GetName() + "\".");
                Process process = Process.Start(psi);
                process.EnableRaisingEvents = true; // muuten ei tule Exitediä
                process.Exited += delegate
                {
                    parent.CurrentSubProgram++;
                    RunSubProgram(parent, file);
                };
            }
            catch (Win32Exception ex)
            {
                AddMessageFromAnotherThread("Execution failed, Win32 error code: " + ex.ErrorCode);
            }
        }*/

        /// <summary>
        /// Muutetaan parametrit sopivaan muotoon asetusten mukaan.
        /// </summary>
        /// <param name="ex">Parametrit ja niiden asetukset.</param>
        /// <param name="file">Tiedosto.</param>
        /// <returns>Parametrit.</returns>
        public static String GenerateArguments(Executable ex, string file)
        {
            String args = "";

            if (ex.HasFileAsFirstParameter)
            {
                args = file + " " + ex.Arguments;
            }
            else
            {
                int filePos = ex.Arguments.IndexOf("%1");
                args = ex.Arguments.Substring(0, filePos); // ennen %1
                args += file; // tiedostopolku
                args += ex.Arguments.Substring(filePos + 2); // %1 jälkeen
            }

            return args;
        }

        /// <summary>
        /// Palauttaa ohjelman nimen ilman hakemistopolkua.
        /// </summary>
        /// <param name="path">Koko hakemistopolku.</param>
        /// <returns>Ohjelman nimi.</returns>
        public static String GetName(string path)
        {
            int kauttaviivanPaikka = 0;
            bool loytyiko = false;
            String nimi = "";
            for (int i = path.Length - 1; i >= 0; i--)
            {
                if (path[i] == '\\')
                {
                    kauttaviivanPaikka = i;
                    loytyiko = true;
                    break;
                }
            }
            if (loytyiko)
                nimi = path.Substring(kauttaviivanPaikka + 1);
            else
                nimi = path;
            return nimi;
        }


        /// <summary>
        /// Checks if the file is locked because of
        /// still being written to
        /// or being processed by another thread
        /// or does not exist (has already been processed)
        /// </summary>
        /// <param name="file">File</param>
        /// <returns>Is the file locked</returns>
        private static bool? IsFileLocked(FileInfo file)
        {
            FileStream stream = null;

            try
            {
                stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
                //stream = file.Open(FileMode.Open, FileAccess.Read);
            }
            catch (FileNotFoundException e)
            {
                return null;
            }
            catch (IOException e)
            {
                //the file is unavailable because it is:
                // * still being written to or
                // * being processed by another thread or
                // * does not exist (has already been processed)
                return true;
            }
            finally
            {
                if (stream != null)
                    stream.Close();
            }

            //file is not locked
            return false;
        }

        public static void UpdateExecutableList()
        {
            MainWindow.ProgramWindow.Items.Clear();
            for (int i = 0; i < ExecutablePrograms.Count; i++)
            {
                if (ExecutablePrograms[i].HasFileAsFirstParameter)
                    MainWindow.ProgramWindow.Items.Add(ExecutablePrograms[i].GetName() + " [file] " + ExecutablePrograms[i].Arguments);
                else
                    MainWindow.ProgramWindow.Items.Add(ExecutablePrograms[i].GetName() + " " + ExecutablePrograms[i].Arguments.Replace("%1", "[file]"));

                if (ExecutablePrograms[i].SubPrograms == null) continue;
                for (int j = 0; j < ExecutablePrograms[i].SubPrograms.Count; j++)
                {
                    if (ExecutablePrograms[i].SubPrograms[j].HasFileAsFirstParameter)
                        MainWindow.ProgramWindow.Items.Add("  " + (j + 1) + ". " + ExecutablePrograms[i].SubPrograms[j].GetName() + " [file] " + ExecutablePrograms[i].SubPrograms[j].Arguments);
                    else
                        MainWindow.ProgramWindow.Items.Add("  " + (j + 1) + ". " + ExecutablePrograms[i].SubPrograms[j].GetName() + " " + ExecutablePrograms[i].SubPrograms[j].Arguments.Replace("%1", "[file]"));
                }
            }
        }

        public static void UpdateEvents()
        {
            WatchCreation = (bool)MainWindow.CreationBox.IsChecked;
            WatchDeletion = (bool)MainWindow.DeletionBox.IsChecked;
            WatchChanges = (bool)MainWindow.ChangeBox.IsChecked;
            WatchRenaming = (bool)MainWindow.RenameBox.IsChecked;
        }

        /// <summary>
        /// Tallennetaan käyttäjän tämänhetkiset asetukset.
        /// </summary>
        public static void SaveSettings()
        {
            UpdateEvents();
            OptionsFile ops = new OptionsFile(SelectedFolder, SelectedFileExtensions, ExecutablePrograms, WatchCreation, WatchDeletion, WatchChanges, WatchRenaming, LoadSettingsAutomatically, SaveSettingsAutomatically, StartWatchingAutomatically, KeepLog);

            FileStream stream = new FileStream(OptionsFilePath, FileMode.Create);

            BinaryFormatter formatter = new BinaryFormatter();
            try
            {
                formatter.Serialize(stream, ops);
            }
            catch (SerializationException se)
            {
                AddMessage("Saving settings failed: " + se.Message);
            }
            finally
            {
                stream.Close();
            }
        }

        /// <summary>
        /// Tallennetaan käyttäjän tämänhetkiset asetukset.
        /// </summary>
        public static void SaveSettings(OptionsFile options)
        {
            if (options == null) return;

            UpdateEvents();
            FileStream stream = new FileStream(OptionsFilePath, FileMode.Create);

            BinaryFormatter formatter = new BinaryFormatter();
            try
            {
                formatter.Serialize(stream, options);
            }
            catch (SerializationException se)
            {
                AddMessage("Saving settings failed: " + se.Message);
            }
            finally
            {
                stream.Close();
            }
        }


        /// <summary>
        /// Ladataan asetukset tiedostosta.
        /// </summary>
        public static OptionsFile LoadSettings()
        {
            OptionsFile ops = new OptionsFile();
            FileStream stream;
            BinaryFormatter formatter = new BinaryFormatter();
            try
            {
                using (stream = new FileStream(OptionsFilePath, FileMode.Open))
                {
                    ops = (OptionsFile)formatter.Deserialize(stream);
                }
            }
            catch (SerializationException se)
            {
                AddMessage("Loading settings failed: " + se.Message);
            }
            catch (FileNotFoundException)
            {
                AddMessage("Options file missing, reverting to defaults.");
                SaveSettings(DefaultSettings);
                return DefaultSettings;
            }
            return ops;
        }

        public static void UseSettings(OptionsFile settings, bool useOnlyOptionsScreenSettings = false)
        {
            if (!useOnlyOptionsScreenSettings)
            {
                SelectedFolder = settings.SelectedFolder;
                SelectedFileExtensions = settings.SelectedFileExtensions;
                ExecutablePrograms = settings.ExecutablePrograms;
                WatchSubdirectories = settings.WatchSubdirectories;

                WatchCreation = settings.WatchCreation;
                WatchDeletion = settings.WatchDeletion;
                WatchChanges = settings.WatchChanges;
                WatchRenaming = settings.WatchRenaming;
            }

            LoadSettingsAutomatically = settings.LoadSettingsAutomatically;
            SaveSettingsAutomatically = settings.SaveSettingsAutomatically;
            StartWatchingAutomatically = settings.StartWatchingAutomatically;

            KeepLog = settings.KeepLog;

            if (!useOnlyOptionsScreenSettings)
                MainWindow.UpdateVisuals();
        }

        /// <summary>
        /// Kirjoitetaan tekstiä lokitiedostoon.
        /// </summary>
        /// <param name="message">Kirjoitettava teksti.</param>
        public static void WriteToLog(string message)
        {
            LogWriter.WriteLine(DateTime.Now + " " + message);
            LogWriter.Flush();
        }

        /// <summary>
        /// Lisätään rivinvaihto lokiin.
        /// </summary>
        public static void WriteToLog()
        {
            LogWriter.WriteLine();
            LogWriter.Flush();
        }
    }
}