using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;


#pragma warning disable CS4014 // Da dieser Aufruf nicht abgewartet wird, wird die Ausführung der aktuellen Methode fortgesetzt, bevor der Aufruf abgeschlossen ist
#pragma warning disable CC0001 // Use var instead

namespace PEP_Tool
{
    /// <summary>
    /// Interaktionslogik für MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        public static MainWindow main;

        public event PropertyChangedEventHandler PropertyChanged;

        FileSystemWatcher fs = new FileSystemWatcher(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\JSON\", "*.json");

        //DispatcherTimer jsonTimer = new DispatcherTimer();
        DispatcherTimer bemerkungTimer = new DispatcherTimer();
        DispatcherTimer telefonTimer = new DispatcherTimer();
        DispatcherTimer newVersionTimer = new DispatcherTimer();
        DispatcherTimer lastChangeTimer = new DispatcherTimer();

        bool checkForChange = false;

        #region Properties

        public List<string> ZuweisungsMoeglichkeiten { get; set; }
        public Dictionary<string, Tuple<string, string>> AbteilungsNamen { get; set; }

        private List<TableInfo> userList;
        public List<TableInfo> UserList
        {
            get { return userList; }
            set
            {
                if (propertyChangeAllowed)
                {
                    userList = value;
                    OnPropertyChanged();
                }
            }
        }

        public List<TableInfo> DefaultUserList { get; set; }

        private List<TableInfo> bemerkungen = new List<TableInfo>();
        public List<TableInfo> Bemerkungen
        {
            get { return bemerkungen; }
            set
            {
                if (propertyChangeAllowed)
                {
                    bemerkungen = value;
                    OnPropertyChanged();
                }
            }
        }

        private bool bemerkungIsEnabled = true;
        public bool BemerkungIsEnabled
        {
            get { return bemerkungIsEnabled; }
            set
            {
                if (propertyChangeAllowed)
                {
                    bemerkungIsEnabled = value;
                    OnPropertyChanged();
                }
            }
        }

        private List<TableInfo> zuweisungen = new List<TableInfo>();
        public List<TableInfo> Zuweisungen
        {
            get
            {
                return zuweisungen;
            }
            set
            {
                zuweisungen = value;
                OnPropertyChanged();
            }
        }

        private List<TableInfo> telefon = new List<TableInfo>();
        public List<TableInfo> TelefonList
        {
            get
            {
                return telefon;
            }
            set
            {
                telefon = value;
                OnPropertyChanged();
            }
        }

        private bool telefonIsEnabled = true;
        public bool TelefonIsEnabled
        {
            get { return telefonIsEnabled; }
            set
            {
                if (propertyChangeAllowed)
                {
                    telefonIsEnabled = value;
                    OnPropertyChanged();
                }
            }
        }


        private string lastChangeTime;
        public string LastChangeTime
        {
            get
            {
                return lastChangeTime;
            }
            set
            {
                if (lastChangeTime != value)
                {
                    lastChangeTime = value;

                    Dispatcher.BeginInvoke(new Action(() =>
                    {
                        if (checkForChange)
                        {
                            lblLastChange.Text = lastChangeTime;
                            lblLastChange.Foreground = new SolidColorBrush(Colors.Red);
                        }
                    }));
                }
            }
        }


        #endregion

        public MainWindow()
        {
            if (Properties.Settings.Default.newVersionString != Properties.Settings.Default.Version)
            {
                Properties.Settings.Default.newVersionScreen = true;
                Properties.Settings.Default.newVersionString = Properties.Settings.Default.Version;
                Properties.Settings.Default.Save();
            }

            if (System.IO.File.Exists(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\Version.txt"))
            {
                main = this;
                PreStart(1);
            }
#if !DEBUG
            else if (System.IO.File.Exists(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\Maintenance.txt"))
            {
                main = this;
                PreStart(2);
            }
#endif
            else if(Environment.CurrentDirectory == @"\\bku\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung")
            {
                MessageBox.Show($"Achtung:{Environment.NewLine}Dieses Programm darf nicht mehr aus dem Gruppenlaufwerk gestartet werden!{Environment.NewLine}Bitte die PEP-Tool.exe auf den Desktop kopieren und von dort starten", "Fehler!", MessageBoxButton.OK, MessageBoxImage.Error);
                Application.Current.Shutdown();
            }
            else
            {
                if (Properties.Settings.Default.newVersionScreen)
                {
                    InitializeComponent();

                    NewVersionScreen nVs = new NewVersionScreen();
                    nVs.ShowDialog();

                    GetDesktopShortcuts();

                    main = this;

                    Start();
                }
                else
                {
                    InitializeComponent();

                    GetDesktopShortcuts();

                    main = this;

                    Start();
                }
            }


            this.Title += Properties.Settings.Default.Version;
        }

        public static bool MessageShown { get; set; } = false;
        public static bool propertyChangeAllowed { get; set; } = true;
        //public static bool PersonalNummerIsEnabled { get; set; } = true;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="VersionOrMaintenance">1: Neue Version, 2: Wartungsarbeiten</param>
        private async void PreStart(int VersionOrMaintenance)
        {

            onStartup = true;
            if (VersionOrMaintenance == 1)
            {
                Task.Run(() =>
                 {
                     Dispatcher.BeginInvoke(new Action(() =>
                     {
                         NewVersionMessageBox nVMB = new NewVersionMessageBox("Es ist eine neue Version verfügbar\nDie Anwendung kann bis zur Aktualisierung nicht gestartet werden.\n\nDie neue Version sollte in wenigen Minuten verfügbar sein.", 10, true);
                         nVMB.Show();
                     }));
                 });

                Task.Run(() =>
                {
                    while (!MessageShown) { }
                    Dispatcher.BeginInvoke(new Action(() =>
                    {
                        main.Close();
                    }));
                });
            }
            else if (VersionOrMaintenance == 2)
            {
                Task.Run(() =>
                {
                    Dispatcher.BeginInvoke(new Action(() =>
                    {
                        NewVersionMessageBox nVMB = new NewVersionMessageBox("Die Anwendung kann wegen Wartungsarbeiten nicht gestartet werden.\n\nDas System sollte in wenigen Minuten wieder verfügbar sein.", 10, true);
                        nVMB.Show();
                    }));
                });

                Task.Run(() =>
                {
                    while (!MessageShown) { }
                    Dispatcher.BeginInvoke(new Action(() =>
                    {
                        main.Close();
                    }));
                });
            }
        }

        private async void Start()
        {
            //jsonTimer.Interval = TimeSpan.FromSeconds(3);
            //jsonTimer.Tick += JsonTimer_Tick;

            bemerkungTimer.Interval = TimeSpan.FromSeconds(10);
            bemerkungTimer.Tick += BemerkungTimer_Tick;

            telefonTimer.Interval = TimeSpan.FromSeconds(10);
            telefonTimer.Tick += TelefonTimer_Tick;

            newVersionTimer.Interval = TimeSpan.FromSeconds(10);
            newVersionTimer.Tick += NewVersionTimer_Tick;

            Tracker.Init_Track();
            //bar.Visibility = Visibility.Visible;
            //li.IsActive = true;
            li.Visibility = Visibility.Visible;

            await Task.Run(() =>
            {
                ZuweisungsMoeglichkeiten = Reader.ReadZuweisungsMoeglichkeiten();
                AbteilungsNamen = Reader.ReadAbteilungsNamen();
                UserList = Reader.ReadUserList();
                DefaultUserList = UserList;
            });



            var abtFilterList = DefaultUserList.Select(p => p.Abteilung).Distinct().ToList();
            abtFilterList.Insert(0, "");
            abtFilterList.Sort();
            cBFilterAbteilung.ItemsSource = cBFilterAbteilung2.ItemsSource = cBFilterAbteilung3.ItemsSource = abtFilterList;

            //flowDocu.ItemsSource = UserList;

            btnFrueh.IsEnabled = true;
            btnSpaet.IsEnabled = true;
            btnNacht.IsEnabled = true;

            //bar.Visibility = Visibility.Collapsed;
            //li.Visibility = Visibility.Collapsed;
            //li.IsActive = false;

            //jsonTimer.Start();

            FileWatcher();
            newVersionTimer.Start();
        }


        bool versionMessage = false;
        private void NewVersionTimer_Tick(object sender, EventArgs e)
        {
            if (System.IO.File.Exists(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\Version.txt"))
            {
                if (!versionMessage)
                {
                    //Task.Run(() => MessageBox.Show("Es ist eine neue Version verfügbar\nDie Anwendung wird in 60 Sekunden automatisch beendet.", "Neue Version", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK, MessageBoxOptions.ServiceNotification));
                    NewVersionMessageBox nVMB = new NewVersionMessageBox("Es ist eine neue Version verfügbar\nDie Anwendung wird in 60 Sekunden automatisch beendet.\n\n" +
                        "Die neue Version sollte in wenigen Minuten verfügbar sein.\n\n" +
                        "Sie können während der nächsten 60 Sekunden weitere Eintragungen vornehmen, die Liste drucken oder exportieren.\n\n\n", 60, false);
                    nVMB.ShowDialog();
                    versionMessage = true;
                }
            }

            if (File.Exists(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\Maintenance.txt"))
            {
                if (!versionMessage)
                {
                    //Task.Run(() => MessageBox.Show("Es ist eine neue Version verfügbar\nDie Anwendung wird in 60 Sekunden automatisch beendet.", "Neue Version", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK, MessageBoxOptions.ServiceNotification));
                    NewVersionMessageBox nVMB = new NewVersionMessageBox("Die Anwendung muss aufgrund von Wartungsarbeiten geschlossen werden\nDie Anwendung wird in 30 Sekunden automatisch beendet.\n\n" +
                        "Das System wird in wenigen Minuten wieder verfügbar sein.\n\n" +
                        "Sie können während der nächsten 30 Sekunden die Liste drucken oder exportieren.\n\n\n", 30, false);
                    nVMB.ShowDialog();
                    versionMessage = true;
                }
            }
        }


        private async void FileWatcher()
        {
            FileSystemWatcher fs = new FileSystemWatcher(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\JSON\", "*.json");
            fs.EnableRaisingEvents = true;
            fs.IncludeSubdirectories = false;

            fs.Changed += Fs_Changed;

            li.Visibility = Visibility.Collapsed;
        }

        bool checkOldJsonData = true;
        private async void Fs_Changed(object sender, FileSystemEventArgs e)
        {
            if(e.Name == "Zuweisungen.json")
            {
                await Task.Run(async () =>
                {
                    try
                    {
                        var zuweisungenList = await Reader.CreateZuweisungenList();

                        if (zuweisungenList != null && Zuweisungen != null)
                        {
                            if (!Enumerable.SequenceEqual(zuweisungenList, Zuweisungen))
                            {
                                if (checkForChange)
                                {
                                    var items = Zuweisungen.Except(zuweisungenList);

                                    foreach (var item in items)
                                    {
                                        if (UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
                                        {
                                            //Debug.WriteLine(Zuweisungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung);
                                            string z = "";
                                            if (Zuweisungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
                                                z = string.IsNullOrEmpty(Zuweisungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung) ? " leer" : " " + Zuweisungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung;
                                            else
                                                z = " leer";

                                            string y = "";
                                            if (zuweisungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
                                                y = string.IsNullOrEmpty(zuweisungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung) ? " leer" : " " + zuweisungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung;
                                            else
                                                y = " leer";

                                            string x = "";
                                            x = UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().FilePath ?? "";

                                            if (x.CountSubstring("\n") > 6)
                                            {
                                                var i = x.CountSubstring("\n");
                                                x = x.Substring(0, x.IndexOf("\n")) + x.Substring(x.IndexOfNth("\n", i - 4));
                                            }

                                            var str = "";
                                            var sub = $"{x.Substring(x.IndexOf("\n") + 1).TrimStart("\n".ToCharArray())}";

                                            if (x.StartsWith("l, Bemerkung wurde geändert"))
                                                str = "l, Bemerkung und Zuweisung wurden geändert\n\n" + $"{sub}\nZuweisung:{z} -> {y}";

                                            else if (x.StartsWith("l, Zuweisung wurde geändert"))
                                                str = "l, Zuweisung wurde geändert\n\n" + $"{sub}\nZuweisung:{z} -> {y}";

                                            else if (x.StartsWith("l, Zuweisung und Bemerkung wurden geändert"))
                                                str = "l, Bemerkung und Zuweisung wurden geändert\n\n" + $"{sub}\nZuweisung:{z} -> {y}";

                                            else if (x.StartsWith("l, Bemerkung und Zuweisung wurden geändert"))
                                                str = "l, Bemerkung und Zuweisung wurden geändert\n\n" + $"{sub}\nZuweisung:{z} -> {y}";

                                            else
                                                str = $"l, Zuweisung wurde geändert\n\nZuweisung:{z} -> {y}";

                                            str = str.AddLineNumbers(2);
                                            UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().FilePath = str;
                                        }
                                    }
                                }

                                foreach (var user in UserList)
                                {
                                    if (zuweisungenList != null)
                                    {
                                        if (UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0 && zuweisungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0)
                                        {
                                            UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Zuweisung = zuweisungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Zuweisung;
                                            //UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum && p.FilePath == ".").First().FilePath = "●";
                                        }
                                    }
                                }
                                Zuweisungen = zuweisungenList;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogFile.WriteLine(ex.ToString());
                        LogFile.WriteLine("Message: " + ex.Message);
                        if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
                    }
                });
            }

            if(e.Name == "Bemerkungen.json")
            {
                await Task.Run(async () =>
                {
                    try
                    {
                        var bemerkungenList = await Reader.CreateBemerkungenList();


                        if (bemerkungenList != null && Bemerkungen != null)
                        {
                            if (!Enumerable.SequenceEqual(bemerkungenList, Bemerkungen))
                            {
                                if (checkForChange)
                                {
                                    var items = Bemerkungen.Except(bemerkungenList);

                                    foreach (var item in items)
                                    {
                                        if (UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
                                        {
                                            string z = "";
                                            if (Bemerkungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
                                                z = string.IsNullOrEmpty(Bemerkungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Bemerkung) ? " leer" : " " + Bemerkungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Bemerkung;
                                            else
                                                z = " leer";

                                            string y = "";
                                            if (bemerkungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
                                                y = string.IsNullOrEmpty(bemerkungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Bemerkung) ? " leer" : " " + bemerkungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Bemerkung;
                                            else
                                                y = " leer";

                                            string x = "";
                                            x = UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().FilePath ?? "";

                                            if (x.CountSubstring("\n") > 6)
                                            {
                                                var i = x.CountSubstring("\n");
                                                x = x.Substring(0, x.IndexOf("\n")) + x.Substring(x.IndexOfNth("\n", i - 4));
                                            }

                                            var str = "";
                                            var sub = $"{x.Substring(x.IndexOf("\n") + 1).TrimStart("\n".ToCharArray())}";

                                            if (x.StartsWith("l, Zuweisung wurde geändert"))
                                                str = "l, Zuweisung und Bemerkung wurden geändert\n\n" + $"{sub}\nBemerkung:{z} -> {y}";

                                            else if (x.StartsWith("l, Bemerkung wurde geändert"))
                                                str = "l, Bemerkung wurde geändert\n\n" + $"{sub}\nBemerkung:{z} -> {y}";

                                            else if (x.StartsWith("l, Bemerkung und Zuweisung wurden geändert"))
                                                str = "l, Zuweisung und Bemerkung wurden geändert\n\n" + $"{sub}\nBemerkung:{z} -> {y}";

                                            else if (x.StartsWith("l, Zuweisung und Bemerkung wurden geändert"))
                                                str = "l, Zuweisung und Bemerkung wurden geändert\n\n" + $"{sub}\nBemerkung:{z} -> {y}";

                                            else
                                                str = $"l, Bemerkung wurde geändert\n\nBemerkung Alter Wert:{z} -> {y}";

                                            str = str.AddLineNumbers(2);
                                            UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().FilePath = str;
                                        }
                                    }
                                }

                                foreach (var user in UserList)
                                {
                                    if (bemerkungenList != null)
                                    {
                                        if (UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0 && bemerkungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0)
                                            UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Bemerkung = bemerkungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Bemerkung;

                                    }
                                }
                                Bemerkungen = bemerkungenList;


                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogFile.WriteLine(ex.ToString());
                        LogFile.WriteLine("Message: " + ex.Message);
                        if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
                    }
                });
            }

            if(e.Name == "Telefon.json")
            {
                await Task.Run(async () =>
                {
                    try
                    {
                        var telefonList = await Reader.CreateTelefonList();


                        if (telefonList != null && TelefonList != null)
                        {
                            if (!Enumerable.SequenceEqual(telefonList, TelefonList))
                            {

                                foreach (var user in UserList)
                                {
                                    if (telefonList != null)
                                    {
                                        if (UserList.Where(p => p.PersNummer == user.PersNummer).Count() > 0 && telefonList.Where(p => p.PersNummer == user.PersNummer).Count() > 0)
                                        {
                                            UserList.Where(p => p.PersNummer == user.PersNummer).First().Telefon = telefonList.Where(p => p.PersNummer == user.PersNummer).First().Telefon;
                                            //UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum && p.FilePath == ".").First().FilePath = "●";
                                        }

                                    }
                                }
                                TelefonList = telefonList;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogFile.WriteLine(ex.ToString());
                        LogFile.WriteLine("Message: " + ex.Message);
                        if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
                    }
                });
            }

            checkForChange = true;

            if (checkOldJsonData)
            {
                Bemerkungen = Reader.CreateBemerkungenList().Result;
                Zuweisungen = Reader.CreateZuweisungenList().Result;

                var u = UserList.Min(p => p.Datum) - TimeSpan.FromDays(10);

                Bemerkungen = Bemerkungen.Except(Bemerkungen.Where(p => p.Datum < u)).ToList();
                Zuweisungen = Zuweisungen.Except(Zuweisungen.Where(p => p.Datum < u)).ToList();


                var json = Newtonsoft.Json.JsonConvert.SerializeObject(Zuweisungen);
                json = await Crypto.EncryptString(json);
                byte[] jsonB = new UTF8Encoding(true).GetBytes(json);

                using (var fs = Writer.WaitForFile(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\JSON\Zuweisungen.json", FileMode.Open, FileAccess.Write, FileShare.None)) //FileShare.Read geändert 18.02.19
                {
                    if (fs != null)
                    {
                        fs.SetLength(0);
                        await fs.WriteAsync(jsonB, 0, jsonB.Length);
                    }
                    else fs.Dispose();
                }

                var jsonBem = Newtonsoft.Json.JsonConvert.SerializeObject(Bemerkungen);
                jsonBem = await Crypto.EncryptString(jsonBem);
                byte[] jsonByte = new UTF8Encoding(true).GetBytes(jsonBem);


                using (var fs = Writer.WaitForFile(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\JSON\Bemerkungen.json", FileMode.Open, FileAccess.Write, FileShare.None)) //FileShare.Read geändert 18.02.19
                {
                    if (fs != null)
                    {
                        fs.SetLength(0);
                        await fs.WriteAsync(jsonByte, 0, jsonByte.Length);
                    }
                    else fs.Dispose();
                }

                checkOldJsonData = false;
            }
        }

        //private async void JsonTimer_Tick(object sender, EventArgs e)
        //{
        //    await Task.Run(async () =>
        //    {
        //        try
        //        {
        //            var zuweisungenList = await Reader.CreateZuweisungenList();


        //            if (zuweisungenList != null && Zuweisungen != null)
        //            {
        //                if (!Enumerable.SequenceEqual(zuweisungenList, Zuweisungen))
        //                {
        //                    if (checkForChange)
        //                    {
        //                        //zuweisungenList.OrderBy(p => p.PersNummer);
        //                        //Zuweisungen.OrderBy(p => p.PersNummer);
        //                        var items = zuweisungenList.Except(Zuweisungen);

        //                        foreach (var item in items)
        //                        {
        //                            if (UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
        //                            {
        //                                //Debug.WriteLine(Zuweisungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung);
        //                                string z = "";
        //                                if (Zuweisungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
        //                                    z = string.IsNullOrEmpty(Zuweisungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung) ? " leer" : " " + Zuweisungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung;
        //                                else
        //                                    z = " leer";

        //                                string y = "";
        //                                if (zuweisungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
        //                                    y = string.IsNullOrEmpty(zuweisungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung) ? " leer" : " " + zuweisungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Zuweisung;
        //                                else
        //                                    y = " leer";

        //                                string x = "";
        //                                x = UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().FilePath ?? "";

        //                                if (x.CountSubstring("\n") > 6)
        //                                {
        //                                    var i = x.CountSubstring("\n");
        //                                    x = x.Substring(0, x.IndexOf("\n")) + x.Substring(x.IndexOfNth("\n", i - 4));
        //                                }

        //                                var str = "";
        //                                var sub = $"{x.Substring(x.IndexOf("\n") + 1).TrimStart("\n".ToCharArray())}";

        //                                if (x.StartsWith("l, Bemerkung wurde geändert"))
        //                                    str = "l, Bemerkung und Zuweisung wurden geändert\n\n" + $"{sub}\nZuweisung:{z} -> {y}";

        //                                else if (x.StartsWith("l, Zuweisung wurde geändert"))
        //                                    str = "l, Zuweisung wurde geändert\n\n" + $"{sub}\nZuweisung:{z} -> {y}";

        //                                else if (x.StartsWith("l, Zuweisung und Bemerkung wurden geändert"))
        //                                    str = "l, Bemerkung und Zuweisung wurden geändert\n\n" + $"{sub}\nZuweisung:{z} -> {y}";

        //                                else if (x.StartsWith("l, Bemerkung und Zuweisung wurden geändert"))
        //                                    str = "l, Bemerkung und Zuweisung wurden geändert\n\n" + $"{sub}\nZuweisung:{z} -> {y}";

        //                                else
        //                                    str = $"l, Zuweisung wurde geändert\n\nZuweisung:{z} -> {y}";

        //                                str = str.AddLineNumbers(2);
        //                                UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().FilePath = str;
        //                            }
        //                        }
        //                    }

        //                    foreach (var user in UserList)
        //                    {
        //                        if (zuweisungenList != null)
        //                        {
        //                            if (PersonalNummerIsEnabled)
        //                            {
        //                                if (UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0 && zuweisungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0)
        //                                {
        //                                    UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Zuweisung = zuweisungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Zuweisung;
        //                                    //UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum && p.FilePath == ".").First().FilePath = "●";
        //                                }

        //                                //var a = UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count();
        //                                //var b = zuweisungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum && p.Zuweisung != user.Zuweisung).Count();
        //                                //var c = zuweisungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count();

        //                                //if (UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0 && zuweisungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0)
        //                                //{
        //                                //    if (zuweisungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Zuweisung != user.Zuweisung)
        //                                //        UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().FilePath = "●";
        //                                //    //UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum && p.FilePath == ".").First().FilePath = "●";
        //                                //}
        //                            }
        //                            else
        //                            {
        //                                if (UserList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).Count() > 0 && zuweisungenList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).Count() > 0)
        //                                    UserList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).First().Zuweisung = zuweisungenList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).First().Zuweisung;
        //                            }


        //                            //flowDocu.ItemsSource = UserList;
        //                        }
        //                    }
        //                    Zuweisungen = zuweisungenList;
        //                }
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            LogFile.WriteLine(ex.ToString());
        //            LogFile.WriteLine("Message: " + ex.Message);
        //            if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
        //        }

        //        try
        //        {
        //            var bemerkungenList = await Reader.CreateBemerkungenList();


        //            if (bemerkungenList != null && Bemerkungen != null)
        //            {
        //                if (!Enumerable.SequenceEqual(bemerkungenList, Bemerkungen))
        //                {
        //                    if (checkForChange)
        //                    {
        //                        //zuweisungenList.OrderBy(p => p.PersNummer);
        //                        //Zuweisungen.OrderBy(p => p.PersNummer);
        //                        var items = bemerkungenList.Except(Bemerkungen);

        //                        foreach (var item in items)
        //                        {
        //                            if (UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
        //                            {
        //                                string z = "";
        //                                if (Bemerkungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
        //                                    z = string.IsNullOrEmpty(Bemerkungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Bemerkung) ? " leer" : " " + Bemerkungen.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Bemerkung;
        //                                else
        //                                    z = " leer";

        //                                string y = "";
        //                                if (bemerkungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).Count() > 0)
        //                                    y = string.IsNullOrEmpty(bemerkungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Bemerkung) ? " leer" : " " + bemerkungenList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().Bemerkung;
        //                                else
        //                                    y = " leer";

        //                                string x = "";
        //                                x = UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().FilePath ?? "";

        //                                if (x.CountSubstring("\n") > 6)
        //                                {
        //                                    var i = x.CountSubstring("\n");
        //                                    x = x.Substring(0, x.IndexOf("\n")) + x.Substring(x.IndexOfNth("\n", i - 4));
        //                                }

        //                                var str = "";
        //                                var sub = $"{x.Substring(x.IndexOf("\n") + 1).TrimStart("\n".ToCharArray())}";

        //                                if (x.StartsWith("l, Zuweisung wurde geändert"))
        //                                    str = "l, Zuweisung und Bemerkung wurden geändert\n\n" + $"{sub}\nBemerkung:{z} -> {y}";

        //                                else if (x.StartsWith("l, Bemerkung wurde geändert"))
        //                                    str = "l, Bemerkung wurde geändert\n\n" + $"{sub}\nBemerkung:{z} -> {y}";

        //                                else if (x.StartsWith("l, Bemerkung und Zuweisung wurden geändert"))
        //                                    str = "l, Zuweisung und Bemerkung wurden geändert\n\n" + $"{sub}\nBemerkung:{z} -> {y}";

        //                                else if (x.StartsWith("l, Zuweisung und Bemerkung wurden geändert"))
        //                                    str = "l, Zuweisung und Bemerkung wurden geändert\n\n" + $"{sub}\nBemerkung:{z} -> {y}";

        //                                else
        //                                    str = $"l, Bemerkung wurde geändert\n\nBemerkung Alter Wert:{z} -> {y}";

        //                                str = str.AddLineNumbers(2);
        //                                UserList.Where(p => p.PersNummer == item.PersNummer && p.Datum == item.Datum).First().FilePath = str;
        //                            }
        //                        }
        //                    }

        //                    foreach (var user in UserList)
        //                    {
        //                        if (bemerkungenList != null)
        //                        {
        //                            if (PersonalNummerIsEnabled)
        //                            {
        //                                if (UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0 && bemerkungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0)
        //                                    UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Bemerkung = bemerkungenList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Bemerkung;
        //                            }
        //                            else
        //                            {
        //                                if (UserList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).Count() > 0 && bemerkungenList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).Count() > 0)
        //                                    UserList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).First().Bemerkung = bemerkungenList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).First().Bemerkung;
        //                            }


        //                            //flowDocu.ItemsSource = UserList;
        //                        }
        //                    }
        //                    Bemerkungen = bemerkungenList;


        //                }
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            LogFile.WriteLine(ex.ToString());
        //            LogFile.WriteLine("Message: " + ex.Message);
        //            if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
        //        }


        //        try
        //        {
        //            var telefonList = await Reader.CreateTelefonList();


        //            if (telefonList != null && TelefonList != null)
        //            {
        //                if (!Enumerable.SequenceEqual(telefonList, TelefonList))
        //                {

        //                    foreach (var user in UserList)
        //                    {
        //                        if (telefonList != null)
        //                        {
        //                            if (PersonalNummerIsEnabled)
        //                            {
        //                                //if (UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0 && telefonList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).Count() > 0)
        //                                //{
        //                                //    UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Telefon = telefonList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum).First().Telefon;
        //                                //    //UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum && p.FilePath == ".").First().FilePath = "●";
        //                                //}
        //                                if (UserList.Where(p => p.PersNummer == user.PersNummer).Count() > 0 && telefonList.Where(p => p.PersNummer == user.PersNummer).Count() > 0)
        //                                {
        //                                    UserList.Where(p => p.PersNummer == user.PersNummer).First().Telefon = telefonList.Where(p => p.PersNummer == user.PersNummer).First().Telefon;
        //                                    //UserList.Where(p => p.PersNummer == user.PersNummer && p.Datum == user.Datum && p.FilePath == ".").First().FilePath = "●";
        //                                }

        //                            }
        //                            else
        //                            {
        //                                if (UserList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).Count() > 0 && telefonList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).Count() > 0)
        //                                    UserList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).First().Telefon = telefonList.Where(p => p.Name == user.Name && p.Vorname == user.Vorname && p.Datum == user.Datum).First().Telefon;
        //                            }


        //                            //flowDocu.ItemsSource = UserList;
        //                        }
        //                    }
        //                    TelefonList = telefonList;
        //                }
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            LogFile.WriteLine(ex.ToString());
        //            LogFile.WriteLine("Message: " + ex.Message);
        //            if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
        //        }


        //    });


        //    //if (!checkForChange) this.Width = flowDocu.ActualWidth + 20;

        //    //jsonTimer.Stop();

        //}



        private async void btnOpenFile_Click(object sender, RoutedEventArgs e)
        {
            //bar.Visibility = Visibility.Visible;
            //li.IsActive = true;
            li.Visibility = Visibility.Visible;

            await Task.Run(() =>
            {
                ZuweisungsMoeglichkeiten = Reader.ReadZuweisungsMoeglichkeiten();
                AbteilungsNamen = Reader.ReadAbteilungsNamen();
                UserList = Reader.ReadUserList(true);
                DefaultUserList = UserList;
            });

            var abtFilterList = DefaultUserList.Select(p => p.Abteilung).Distinct().ToList();
            abtFilterList.Insert(0, "");
            abtFilterList.Sort();
            cBFilterAbteilung.ItemsSource = cBFilterAbteilung2.ItemsSource = cBFilterAbteilung3.ItemsSource = abtFilterList;

            //flowDocu.ItemsSource = UserList;

            btnFrueh.IsEnabled = true;
            btnSpaet.IsEnabled = true;
            btnNacht.IsEnabled = true;

            //bar.Visibility = Visibility.Collapsed;
            li.Visibility = Visibility.Collapsed;
            //li.IsActive = false;

            //jsonTimer.Start();

            FileWatcher();
            newVersionTimer.Start();
        }


        private async void ComboBox_DropDownClosed(object sender, EventArgs e)
        {
            li.Visibility = Visibility.Visible;
            await Task.Delay(30);

            try
            {
                var box = sender as ComboBox;
                DataGridRow dataGridRow = FindParent<DataGridRow>(box);
                int index = dataGridRow.GetIndex();

                TextBlock persnummer = null;

                var name = flowDocu.Columns[0].GetCellContent(flowDocu.Items[index]) as TextBlock;
                var vorname = flowDocu.Columns[1].GetCellContent(flowDocu.Items[index]) as TextBlock;
                var datum = flowDocu.Columns[2].GetCellContent(flowDocu.Items[index]) as TextBlock;
                persnummer = flowDocu.Columns[9].GetCellContent(flowDocu.Items[index]) as TextBlock;

                var Zuweisungen = await Reader.CreateZuweisungenList();
                if (Zuweisungen != null)
                {
                    if (!Zuweisungen.Select(p => p.PersNummer).Contains(persnummer.Text))
                    {
                        if (cBzuweisungFullDataset.IsChecked.Value)
                        {
                            foreach (var user in DefaultUserList)
                            {
                                if (user.PersNummer == persnummer.Text)
                                {
                                    Zuweisungen.Add(new TableInfo()
                                    {
                                        PersNummer = persnummer.Text ?? "",
                                        Name = name.Text,
                                        Vorname = vorname.Text,
                                        Datum = user.Datum,
                                        Zuweisung = box.SelectedItem == null ? "" : box.SelectedItem.ToString()
                                    });
                                }
                            }
                        }
                        else
                        {
                            Zuweisungen.Add(new TableInfo()
                            {
                                PersNummer = persnummer.Text ?? "",
                                Name = name.Text,
                                Vorname = vorname.Text,
                                Datum = DateTime.Parse(datum.Text),
                                Zuweisung = box.SelectedItem == null ? "" : box.SelectedItem.ToString()
                            });
                        }
                    }
                    else
                    {
                        if (Zuweisungen.Where(p => (p.PersNummer == persnummer.Text && p.Datum == DateTime.Parse(datum.Text))).Count() > 0 && box.SelectedItem != null)
                        {
                            if (cBzuweisungFullDataset.IsChecked.Value)
                            {
                                foreach (var user in Zuweisungen.Where(p => (p.PersNummer == persnummer.Text)))
                                {
                                    Zuweisungen.Where(p => (p == user)).First().Zuweisung = box.SelectedItem.ToString();
                                }
                            }
                            else
                                Zuweisungen.Where(p => (p.PersNummer == persnummer.Text && p.Datum == DateTime.Parse(datum.Text))).First().Zuweisung = box.SelectedItem.ToString();
                        }
                        else
                        {
                            if (cBzuweisungFullDataset.IsChecked.Value)
                            {
                                foreach (var user in DefaultUserList)
                                {
                                    if (user.PersNummer == persnummer.Text)
                                    {
                                        Zuweisungen.Add(new TableInfo()
                                        {
                                            PersNummer = persnummer.Text ?? "",
                                            Name = name.Text,
                                            Vorname = vorname.Text,
                                            Datum = user.Datum,
                                            Zuweisung = box.SelectedItem == null ? "" : box.SelectedItem.ToString()
                                        });
                                    }
                                }
                            }
                            else
                            {
                                Zuweisungen.Add(new TableInfo()
                                {
                                    PersNummer = persnummer.Text ?? "",
                                    Name = name.Text,
                                    Vorname = vorname.Text,
                                    Datum = DateTime.Parse(datum.Text),
                                    Zuweisung = box.SelectedItem == null ? "" : box.SelectedItem.ToString()
                                });
                            }
                        }
                    }
                }
                else Zuweisungen.Add(new TableInfo()
                {
                    PersNummer = persnummer.Text ?? "",
                    Name = name.Text,
                    Vorname = vorname.Text,
                    Datum = DateTime.Parse(datum.Text),
                    Zuweisung = box.SelectedItem == null ? "" : box.SelectedItem.ToString()
                });

                if (cBzuweisungFullDataset.IsChecked.Value)
                {
                    if (box.SelectedItem != null)
                    {
                        foreach (var user in DefaultUserList.Where(p => (p.PersNummer == persnummer.Text)))
                            DefaultUserList.Where(p => (p == user)).First().Zuweisung = box.SelectedItem.ToString();
                    }
                }
                else
                {
                    if (UserList.Where(p => (p.PersNummer == persnummer.Text && p.Datum == DateTime.Parse(datum.Text))).Count() > 0 && box.SelectedItem != null)
                        UserList.Where(p => (p.PersNummer == persnummer.Text && p.Datum == DateTime.Parse(datum.Text))).First().Zuweisung = box.SelectedItem.ToString();
                }

                var json = Newtonsoft.Json.JsonConvert.SerializeObject(Zuweisungen);
                json = await Crypto.EncryptString(json);
                byte[] jsonB = new UTF8Encoding(true).GetBytes(json);


                

                using (var fs = Writer.WaitForFile(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\JSON\Zuweisungen.json", FileMode.Open, FileAccess.Write, FileShare.None)) //FileShare.Read geändert 18.02.19
                {
                    if (fs != null)
                    {
                        fs.SetLength(0);
                        await fs.WriteAsync(jsonB, 0, jsonB.Length);
                    }
                    else fs.Dispose();
                }

                li.Visibility = Visibility.Collapsed;
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);

                //li.Visibility = Visibility.Collapsed;
            }
        }

#region Bemerkung

        List<ChangesQueue.BemerkungenChanges> BemerkungenChanges = new List<ChangesQueue.BemerkungenChanges>();
        TextBox bemerkungTextbox = null;
        //TextBox lastTextChangedTextbox = null;
        private void Bemerkung_KeyDown(object sender, KeyEventArgs e)
        {
            try
            {
                var box = sender as TextBox;

                if (!Helper.keyIsSpecialKey(e.Key))
                {
                    if (box.Text.ToLower().Contains("krank")) MessageBox.Show("Bitte nicht \"Krank\" eintragen (Datenschutz)\nWenn möglich stattdessen Zuweisung auf \"nicht Anwesend\" stellen", "Achtung!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
                    e.Handled = false;
                    //lastTextChangedTextbox = box;
                    //Debug.WriteLine("NonSpecialKey");
                    bemerkungTextbox = box;
                    bemerkungTimer.Stop();
                    bemerkungTimer.Start();

                    DisableFilterChange();
                }
                else e.Handled = true;

            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
        }

        private void Bemerkung_LostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
        {
            try
            {
                if (bemerkungTextbox != null)
                {
                    DataGridRow dataGridRow = FindParent<DataGridRow>(bemerkungTextbox);
                    if (dataGridRow != null)
                    {
                        int index = dataGridRow.GetIndex();

                        if (BemerkungenChanges.Where(p => p.sender == bemerkungTextbox).Count() == 0)
                            BemerkungenChanges.Add(new ChangesQueue.BemerkungenChanges() { sender = bemerkungTextbox, index = index });
                    }
                }

            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
        }

        private void BemerkungTimer_Tick(object sender, EventArgs e)
        {
            try
            {
            var bembox = bemerkungTextbox;
            if (bembox != null)
            {
                DataGridRow dataGridRow = FindParent<DataGridRow>(bembox);
                if (dataGridRow != null)
                {
                    int index = dataGridRow.GetIndex();

                    if (BemerkungenChanges.Where(p => p.sender == bembox).Count() == 0)
                        BemerkungenChanges.Add(new ChangesQueue.BemerkungenChanges() { sender = bembox, index = index });
                }
            }

            //BemerkungIsEnabled = false;
            SaveBemerkung(BemerkungenChanges);
            bemerkungTimer.Stop();
            EnableFilterChange();

            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
        }



        private async void SaveBemerkung(List<ChangesQueue.BemerkungenChanges> bemerkungenChanges)
        {
            var Bemerkungen = await Reader.CreateBemerkungenList();

            foreach (var change in bemerkungenChanges)
            {
                try
                {
                    var box = change.sender as TextBox;
                    int index = change.index;

                    TextBlock persnummer = null;

                    var name = flowDocu.Columns[0].GetCellContent(flowDocu.Items[index]) as TextBlock;
                    var vorname = flowDocu.Columns[1].GetCellContent(flowDocu.Items[index]) as TextBlock;
                    var datum = flowDocu.Columns[2].GetCellContent(flowDocu.Items[index]) as TextBlock;
                    persnummer = flowDocu.Columns[9].GetCellContent(flowDocu.Items[index]) as TextBlock;

                    
                    if (Bemerkungen != null && persnummer != null)
                    {
                        if (!Bemerkungen.Select(p => p.PersNummer).Contains(persnummer.Text))
                        {
                            Bemerkungen.Add(new TableInfo()
                            {
                                PersNummer = persnummer.Text ?? "",
                                Name = name.Text,
                                Vorname = vorname.Text,
                                Datum = DateTime.Parse(datum.Text),
                                Bemerkung = box.Text == null ? "" : box.Text.ToString()
                            });
                        }
                        else
                        {
                            if (Bemerkungen.Where(p => (p.PersNummer == persnummer.Text && p.Datum == DateTime.Parse(datum.Text))).Count() > 0 && box != null)
                                Bemerkungen.Where(p => (p.PersNummer == persnummer.Text && p.Datum == DateTime.Parse(datum.Text))).First().Bemerkung = box.Text.ToString();
                            else
                                Bemerkungen.Add(new TableInfo()
                                {
                                    PersNummer = persnummer.Text ?? "",
                                    Name = name.Text,
                                    Vorname = vorname.Text,
                                    Datum = DateTime.Parse(datum.Text),
                                    Bemerkung = box == null ? "" : box.Text.ToString()
                                });
                        }
                    }
                    else Bemerkungen.Add(new TableInfo()
                    {
                        PersNummer = persnummer.Text ?? "",
                        Name = name.Text,
                        Vorname = vorname.Text,
                        Datum = DateTime.Parse(datum.Text),
                        Bemerkung = box.Text == null ? "" : box.Text.ToString()
                    });

                    if (UserList.Where(p => (p.PersNummer == persnummer.Text && p.Datum == DateTime.Parse(datum.Text))).Count() > 0 && box != null)
                        UserList.Where(p => (p.PersNummer == persnummer.Text && p.Datum == DateTime.Parse(datum.Text))).First().Bemerkung = box.Text.ToString();

                }
                catch (Exception ex)
                {
                    LogFile.WriteLine(ex.ToString());
                    LogFile.WriteLine("Message: " + ex.Message);
                    if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
                    MessageBox.Show("Bemerkung konnte nicht gespeichert werden\nBitte die Bemerkung neu eingeben", "Fehler!", MessageBoxButton.OK, MessageBoxImage.Warning);
                    CreateList();
                    BemerkungIsEnabled = true;
                }


            }

            try
                {
                    var json = Newtonsoft.Json.JsonConvert.SerializeObject(Bemerkungen);
                    json = await Crypto.EncryptString(json);
                    byte[] jsonB = new UTF8Encoding(true).GetBytes(json);

                    using (var fs = Writer.WaitForFile(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\JSON\Bemerkungen.json", FileMode.Create, FileAccess.Write, FileShare.None)) //Test 25.07.19 FileShare.ReadWrite | FileShare.Delete
                    {
                        await fs.WriteAsync(jsonB, 0, jsonB.Length);
                    }

                    BemerkungenChanges.Clear();
                    //box.CaretIndex = box.Text.Length;
                    BemerkungIsEnabled = true;
                    //lastTextChangedTextbox = null;
                }
                catch (Exception ex)
                {
                    LogFile.WriteLine(ex.ToString());
                    LogFile.WriteLine("Message: " + ex.Message);
                    if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
                    MessageBox.Show("Bemerkung konnte nicht gespeichert werden\nBitte die Bemerkung neu eingeben", "Fehler!", MessageBoxButton.OK, MessageBoxImage.Warning);
                    CreateList();
                    BemerkungIsEnabled = true;
                }
        }


        private void Bemerkung_GotFocus(object sender, RoutedEventArgs e)
        {
            var row = sender as TextBox;
            //DataGridRow dataGridRow = FindParent<DataGridRow>(row);
            DataGridCell dataGridCell = FindParent<DataGridCell>(row);

            row.VerticalScrollBarVisibility = ScrollBarVisibility.Visible;
            //dataGridRow.Height = 55;
            dataGridCell.Height = 55;
            row.Height = 50;
        }

        private void Bemerkung_LostFocus(object sender, RoutedEventArgs e)
        {
            var row = sender as TextBox;
            //DataGridRow dataGridRow = FindParent<DataGridRow>(row);
            DataGridCell dataGridCell = FindParent<DataGridCell>(row);

            row.VerticalScrollBarVisibility = ScrollBarVisibility.Hidden;
            //dataGridRow.Height = 30;
            if(dataGridCell != null) dataGridCell.Height = 30;
            row.Height = 30;

            //bemerkungTimer.Interval = TimeSpan.FromSeconds(1.5);
        }


        //private void Bemerkung_MouseLeave(object sender, MouseEventArgs e)
        //{
        //    bemerkungTextbox = sender as TextBox;
        //    if (bemerkungTextbox.IsKeyboardFocused && lastTextChangedTextbox == bemerkungTextbox && bemerkungTimer.IsEnabled)
        //    {
        //        bemerkungTimer.Stop();
        //        SaveBemerkung(bemerkungTextbox);
        //        EnableFilterChange();
        //    }

        //    //if ((sender as TextBox).IsMouseOver == false && (sender as TextBox).IsKeyboardFocused)
        //    //    bemerkungTimer.Interval = TimeSpan.FromSeconds(0.5);
        //}

        //private void Bemerkung_MouseEnter(object sender, MouseEventArgs e)
        //{
        //    //if ((sender as TextBox).IsMouseOver == true && (sender as TextBox).IsKeyboardFocused)
        //    //    bemerkungTimer.Interval = TimeSpan.FromSeconds(1.5);
        //}




        private void DisableFilterChange()
        {
            btnFrueh.IsEnabled = false;
            btnSpaet.IsEnabled = false;
            btnNacht.IsEnabled = false;
            cBFrueh.IsEnabled = false;
            cBSpaet.IsEnabled = false;
            cBNacht.IsEnabled = false;

            btnAllDays.IsEnabled = false;
            btnDatePickerToday.IsEnabled = false;
            dPDatum.IsEnabled = false;
            btnSearch.IsEnabled = false;
            btnMinusDay.IsEnabled = false;
            btnPlusDay.IsEnabled = false;
        }

        private void EnableFilterChange()
        {
            btnFrueh.IsEnabled = true;
            btnSpaet.IsEnabled = true;
            btnNacht.IsEnabled = true;
            cBFrueh.IsEnabled = true;
            cBSpaet.IsEnabled = true;
            cBNacht.IsEnabled = true;

            btnAllDays.IsEnabled = true;
            btnDatePickerToday.IsEnabled = true;
            dPDatum.IsEnabled = true;
            btnSearch.IsEnabled = true;
            btnMinusDay.IsEnabled = true;
            btnPlusDay.IsEnabled = true;
        }
#endregion

#region Telefon

        List<ChangesQueue.TelefonChanges> TelefonChanges = new List<ChangesQueue.TelefonChanges>();
        TextBox telefonTextbox = null;
        //TextBox lastTextChangedTelbox = null;
        private void Telefon_KeyDown(object sender, KeyEventArgs e)
        {
            if (Helper.isTelNumber(e.Key))
            {
                //lastTextChangedTelbox = sender as TextBox;
                //Debug.WriteLine("NonSpecialKey");
                e.Handled = false;
                telefonTextbox = sender as TextBox;
                telefonTimer.Stop();
                telefonTimer.Start();

                DisableFilterChange();
            }
            else e.Handled = true;
        }

        private void TelefonTimer_Tick(object sender, EventArgs e)
        {
            if (telefonTextbox != null)
            {
                DataGridRow dataGridRow = FindParent<DataGridRow>(telefonTextbox);
                if (dataGridRow != null)
                {
                    int index = dataGridRow.GetIndex();

                    var persnummer = flowDocu.Columns[9].GetCellContent(flowDocu.Items[index]) as TextBlock;

                    foreach (var user in DefaultUserList.Where(p => (p.PersNummer == persnummer.Text)))
                        DefaultUserList.Where(p => (p.PersNummer == user.PersNummer && p.Datum == user.Datum)).First().Telefon = telefonTextbox.Text.ToString();

                    if (TelefonChanges.Where(p => p.sender == telefonTextbox).Count() == 0)
                        TelefonChanges.Add(new ChangesQueue.TelefonChanges() { sender = telefonTextbox, index = index });
                }
            }

            TelefonIsEnabled = false;
            SaveTelefon(TelefonChanges);
            //SaveTelefon(telefonTextbox);
            telefonTimer.Stop();
            EnableFilterChange();
        }

        private void Telefon_PreviewLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
        {
            Debug.WriteLine("jo");
            var telbox = sender as TextBox;
            
            if (telbox != null)
            {
                DataGridRow dataGridRow = FindParent<DataGridRow>(telbox);
                if (dataGridRow != null)
                {
                    int index = dataGridRow.GetIndex();

                    var persnummer = flowDocu.Columns[9].GetCellContent(flowDocu.Items[index]) as TextBlock;

                    foreach (var user in DefaultUserList.Where(p => (p.PersNummer == persnummer.Text)))
                        DefaultUserList.Where(p => (p.PersNummer == user.PersNummer && p.Datum == user.Datum)).First().Telefon = telbox.Text.ToString();

                    if (TelefonChanges.Where(p => p.sender == telbox).Count() == 0)
                        TelefonChanges.Add(new ChangesQueue.TelefonChanges() { sender = telbox, index = index });
                }
            }
        }

        private async void SaveTelefon(List<ChangesQueue.TelefonChanges> telefonChanges)
        {
            TelefonList = await Reader.CreateTelefonList();

            foreach (var change in telefonChanges)
            {
                try
                {
                    var telbox = change.sender as TextBox;
                    var index = change.index;

                    TextBlock persnummer = null;

                    var name = flowDocu.Columns[0].GetCellContent(flowDocu.Items[index]) as TextBlock;
                    var vorname = flowDocu.Columns[1].GetCellContent(flowDocu.Items[index]) as TextBlock;
                    var datum = flowDocu.Columns[2].GetCellContent(flowDocu.Items[index]) as TextBlock;
                    persnummer = flowDocu.Columns[9].GetCellContent(flowDocu.Items[index]) as TextBlock;

                    if (string.IsNullOrEmpty(telbox.Text) || string.IsNullOrWhiteSpace(telbox.Text))
                        TelefonList.RemoveAll(p => p.PersNummer == persnummer.Text);
                    else
                    {
                        if (TelefonList != null && persnummer.Text != null)
                        {
                            if (!TelefonList.Select(p => p.PersNummer).Contains(persnummer.Text))
                            {
                                foreach (var user in DefaultUserList.Where(p => p.PersNummer == persnummer.Text))
                                {
                                    TelefonList.Add(new TableInfo()
                                    {
                                        PersNummer = persnummer.Text ?? "",
                                        Name = name.Text,
                                        Vorname = vorname.Text,
                                        Datum = DateTime.Parse(datum.Text),
                                        Telefon = telbox.Text == null ? "" : telbox.Text.ToString()
                                    });
                                }
                            }
                            else
                            {
                                if (TelefonList.Where(p => (p.PersNummer == persnummer.Text)).Count() > 0 && telbox != null)
                                {
                                    foreach (var user in TelefonList.Where(p => (p.PersNummer == persnummer.Text)))
                                    {
                                        var t = TelefonList.Where(p => (p.PersNummer == persnummer.Text && p.Telefon != telbox.Text.ToString())).FirstOrDefault();
                                        if (t != null) t.Telefon = telbox.Text.ToString();
                                    }
                                }
                                else
                                {
                                    foreach (var user in DefaultUserList.Where(p => p.PersNummer == persnummer.Text))
                                    {
                                        TelefonList.Add(new TableInfo()
                                        {
                                            PersNummer = persnummer.Text ?? "",
                                            Name = name.Text,
                                            Vorname = vorname.Text,
                                            Datum = DateTime.Parse(datum.Text),
                                            Telefon = telbox == null ? "" : telbox.Text.ToString()
                                        });
                                    }
                                }
                            }
                        }
                        else TelefonList.Add(new TableInfo()
                        {
                            PersNummer = persnummer.Text ?? "",
                            Name = name.Text,
                            Vorname = vorname.Text,
                            Datum = DateTime.Parse(datum.Text),
                            Telefon = telbox.Text == null ? "" : telbox.Text.ToString()
                        });
                    }


                    //foreach (var user in DefaultUserList.Where(p => (p.PersNummer == persnummer.Text)))
                    //    DefaultUserList.Where(p => (p.PersNummer == user.PersNummer && p.Datum == user.Datum)).First().Telefon = telbox.Text.ToString();



                    //lastTextChangedTelbox = null;
                }
                catch (Exception ex)
                {
                    LogFile.WriteLine(ex.ToString());
                    LogFile.WriteLine("Message: " + ex.Message);
                    if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
                    MessageBox.Show("Telefon konnte nicht gespeichert werden\nBitte die Nummer neu eingeben", "Fehler!", MessageBoxButton.OK, MessageBoxImage.Warning);
                    CreateList();
                    //TelefonIsEnabled = true;
                }
            }

            try
            {
                var json = Newtonsoft.Json.JsonConvert.SerializeObject(TelefonList);
                json = await Crypto.EncryptString(json);
                byte[] jsonT = new UTF8Encoding(true).GetBytes(json);

                using (var fs = Writer.WaitForFile(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\JSON\Telefon.json", FileMode.Create, FileAccess.Write, FileShare.None))//ReadWrite | FileShare.Delete
                {
                    await fs.WriteAsync(jsonT, 0, jsonT.Length);
                }

                TelefonChanges.Clear();
                //telbox.CaretIndex = telbox.Text.Length;
                //TelefonIsEnabled = true;
            }
            catch (Exception)
            {

                throw;
            }
        }    
        

#endregion

#region Filter

        string abtFilter = "";
        string abtFilter2 = "";
        string abtFilter3 = "";
        private async void cBFilterAbteilung_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                abtFilter = cBFilterAbteilung.SelectedItem == null ? "" : cBFilterAbteilung.SelectedItem.ToString();

                CreateList();

                if (cBFilterAbteilung.SelectedItem != null && cBFilterAbteilung.SelectedItem.ToString() != "") cBFilterAbteilung2.IsEnabled = true;
                else if (cBFilterAbteilung.SelectedItem == null || cBFilterAbteilung.SelectedItem.ToString() == "")
                {
                    cBFilterAbteilung2.IsEnabled = cBFilterAbteilung3.IsEnabled = false;
                    cBFilterAbteilung2.SelectedIndex = cBFilterAbteilung3.SelectedIndex = 0;
                }
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private async void cBFilterAbteilung2_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                abtFilter = cBFilterAbteilung.SelectedItem == null ? "" : cBFilterAbteilung.SelectedItem.ToString();
                abtFilter2 = cBFilterAbteilung2.SelectedItem == null ? "" : cBFilterAbteilung2.SelectedItem.ToString();

                CreateList();

                if (cBFilterAbteilung2.SelectedItem != null && cBFilterAbteilung2.SelectedItem.ToString() != "") cBFilterAbteilung3.IsEnabled = true;
                else if (cBFilterAbteilung2.SelectedItem == null || cBFilterAbteilung2.SelectedItem.ToString() == "")
                {
                    cBFilterAbteilung3.IsEnabled = false;
                    cBFilterAbteilung3.SelectedIndex = 0;
                }
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private async void cBFilterAbteilung3_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                abtFilter = cBFilterAbteilung.SelectedItem == null ? "" : cBFilterAbteilung.SelectedItem.ToString();
                abtFilter2 = cBFilterAbteilung2.SelectedItem == null ? "" : cBFilterAbteilung2.SelectedItem.ToString();
                abtFilter3 = cBFilterAbteilung3.SelectedItem == null ? "" : cBFilterAbteilung3.SelectedItem.ToString();

                CreateList();
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        string lastButton = "";
        private async void btnFrueh_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                lastButton = "MT;MF";

                uncheck_Boxes();

                btnFrueh.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989"));
                btnSpaet.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnNacht.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));

                CreateList();
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private async void btnSpaet_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                lastButton = "MS";

                uncheck_Boxes();

                btnFrueh.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnSpaet.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989"));
                btnNacht.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));

                CreateList();
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private async void btnNacht_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                lastButton = "MN";

                uncheck_Boxes();

                btnFrueh.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnSpaet.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnNacht.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989"));

                CreateList();
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private void cBFrueh_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                if (((lastButton == "MS" || lastButton == "MN") && !cBSpaet.IsChecked.Value && !cBNacht.IsChecked.Value)) lastButton = "";
                if (!lastButton.Contains("MT;MF")) lastButton = lastButton + ";MT;MF";
                lastButton = lastButton.Replace(";;", ";").TrimStart(';').TrimEnd(';');

                btnFrueh.Background = cBFrueh.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnSpaet.Background = cBSpaet.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnNacht.Background = cBNacht.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));

                CreateList();
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private void cBSpaet_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                if (((lastButton == "MT;MF" || lastButton == "MN") && !cBFrueh.IsChecked.Value && !cBNacht.IsChecked.Value)) lastButton = "";
                if (!lastButton.Contains("MS")) lastButton = lastButton + ";MS";
                lastButton = lastButton.Replace(";;", ";").TrimStart(';').TrimEnd(';');

                btnFrueh.Background = cBFrueh.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnSpaet.Background = cBSpaet.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnNacht.Background = cBNacht.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));

                CreateList();
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private void cBNacht_Checked(object sender, RoutedEventArgs e)
        {
            try
            {
                if (((lastButton == "MT;MF" || lastButton == "MS") && !cBSpaet.IsChecked.Value && !cBFrueh.IsChecked.Value)) lastButton = "";
                if (!lastButton.Contains("MN")) lastButton = lastButton + ";MN";
                lastButton = lastButton.Replace(";;", ";").TrimStart(';').TrimEnd(';');

                btnFrueh.Background = cBFrueh.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnSpaet.Background = cBSpaet.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));
                btnNacht.Background = cBNacht.IsChecked.Value ? (SolidColorBrush)(new BrushConverter().ConvertFrom("#4C898989")) : (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));

                CreateList();
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private void cBFrueh_Unchecked(object sender, RoutedEventArgs e)
        {
            lastButton = lastButton.Replace("MT;MF", "");
            lastButton = lastButton.Replace(";;", ";").TrimStart(';').TrimEnd(';');
            btnFrueh.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));

            CreateList();
        }

        private void cBSpaet_Unchecked(object sender, RoutedEventArgs e)
        {
            lastButton = lastButton.Replace("MS", "");
            lastButton = lastButton.Replace(";;", ";").TrimStart(';').TrimEnd(';');
            btnSpaet.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));

            CreateList();
        }

        private void cBNacht_Unchecked(object sender, RoutedEventArgs e)
        {
            lastButton = lastButton.Replace("MN", "");
            lastButton = lastButton.Replace(";;", ";").TrimStart(';').TrimEnd(';');
            btnNacht.Background = (SolidColorBrush)(new BrushConverter().ConvertFrom("#4CDDDDDD"));

            CreateList();
        }

        private void uncheck_Boxes()
        {
            cBFrueh.Unchecked -= cBFrueh_Unchecked;
            cBSpaet.Unchecked -= cBSpaet_Unchecked;
            cBNacht.Unchecked -= cBNacht_Unchecked;
            cBFrueh.IsChecked = false;
            cBSpaet.IsChecked = false;
            cBNacht.IsChecked = false;
            cBFrueh.Unchecked += cBFrueh_Unchecked;
            cBSpaet.Unchecked += cBSpaet_Unchecked;
            cBNacht.Unchecked += cBNacht_Unchecked;
        }





        private async void tbSearch_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Return)
            {
                btnSearch.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
            }
        }

        private void btnSearch_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                CreateList(tbSearch.Text, true, cBSearchWithFilters.IsChecked.Value);
                tbSearch.Text = "";
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private void dPDatum_SelectedDateChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                CreateList();
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }

        private void btnDatePickerToday_Click(object sender, RoutedEventArgs e)
        {
            dPDatum.SelectedDate = DateTime.Now.Date;
        }

        private void btnAllDays_Click(object sender, RoutedEventArgs e)
        {
            dPDatum.SelectedDate = null;
        }


        private void BtnMinusDay_Click(object sender, RoutedEventArgs e)
        {
            if (dPDatum.SelectedDate != null)
                dPDatum.SelectedDate = dPDatum.SelectedDate - TimeSpan.FromDays(1);
            else
                dPDatum.SelectedDate = DateTime.Now.Date;
        }

        private void BtnPlusDay_Click(object sender, RoutedEventArgs e)
        {
            if (dPDatum.SelectedDate != null)
                dPDatum.SelectedDate = dPDatum.SelectedDate + TimeSpan.FromDays(1);
            else
                dPDatum.SelectedDate = DateTime.Now.Date + TimeSpan.FromDays(1);
        }

#endregion

#region Print and Export

        private async void btnPrint_Click(object sender, RoutedEventArgs e)
        {
            propertyChangeAllowed = false;

            Print print = new Print();

            bar.IsIndeterminate = true;
            bar.Visibility = Visibility.Visible;

            List<TableInfo> printList = new List<TableInfo>();
            printList = userList;

            DataGrid grid = new DataGrid();

            grid = print.CreatePrintGrid(printList);

            if (printList.Count > 100) lblBar.Visibility = Visibility.Visible;

            string listTitle = "";
            switch (lastButton)
            {
                case "MT;MF":
                    listTitle = " für Früh- / Tagschicht";
                    break;
                case "MS":
                    listTitle = " für Spätschicht";
                    break;
                case "MN":
                    listTitle = " für Nachtschicht";
                    break;
                default:
                    listTitle = "";
                    break;
            }

            print.printDG(grid, "Personaleinsatzplanung" + listTitle);

            bar.Visibility = Visibility.Collapsed;
            lblBar.Visibility = Visibility.Collapsed;
            //PrintDialog pd = new PrintDialog();
            //print.PrintDataGrid(null, grid, null, pd);
            propertyChangeAllowed = true;
        }

        private void btnExport_Click(object sender, RoutedEventArgs e)
        {
            Export.ExportCSV(UserList);
        }

        private Visibility barVisibility;
        public Visibility BarVisibility
        {
            get { return barVisibility; }
            set
            {
                barVisibility = value;
                bar.Visibility = value;
            }
        }

        private bool barIsIndeterminate;
        public bool BarIsIndeterminate
        {
            get { return barIsIndeterminate; }
            set
            {
                barIsIndeterminate = value;
                bar.IsIndeterminate = value;
            }
        }

        private double barMax;
        public double BarMax
        {
            get { return barMax; }
            set
            {
                barMax = value;
                bar.Maximum = value;
            }
        }

        private double barValue;
        public double BarValue
        {
            get { return barValue; }
            set
            {
                barValue = value;
                bar.Value = value;
            }
        }


#endregion

#region LastChange Funktionen


        private void flowDocu_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (this.IsMouseOver && this.IsKeyboardFocusWithin)
            {
                int selectedRow = flowDocu.SelectedIndex;

                if (selectedRow >= 0)
                {
                    DispatcherTimer ChangeTimer = new DispatcherTimer();
                    ChangeTimer.Interval = TimeSpan.FromSeconds(3);
                    ChangeTimer.Tick += (s, ev) => { ChangeTimer_Tick(sender, e, selectedRow, selectedRow, ChangeTimer); };
                    ChangeTimer.Start();
                }
            }
        }


        int lastVisibleFirstRow;

        void DataGrid_ScrollChanged(object sender, RoutedEventArgs e)
        {
            var scroll = Helper.FindVisualChild<ScrollViewer>((DependencyObject)sender);

            int firstRow = (int)scroll.VerticalOffset;
            int lastRow = (int)scroll.VerticalOffset + (int)scroll.ViewportHeight - 1;

            if (firstRow != lastVisibleFirstRow)
            {
                lastVisibleFirstRow = firstRow;
                DispatcherTimer ChangeTimer = new DispatcherTimer();
                ChangeTimer.Interval = TimeSpan.FromSeconds(10);
                ChangeTimer.Tick += (s, ev) => { ChangeTimer_Tick(sender, e, firstRow, lastRow, ChangeTimer); };
                ChangeTimer.Start();
            }
        }

        private void ChangeTimer_Tick(object sender, EventArgs e, int firstRow, int lastRow, DispatcherTimer timer)
        {
            try
            {
                for (var i = firstRow; i <= lastRow; i++)
                {
                    DataGridRow dataGridRow = flowDocu.ItemContainerGenerator.ContainerFromIndex(i) as DataGridRow;
                    if (dataGridRow != null)
                    {
                        int index = dataGridRow.GetIndex();
                        var change = flowDocu.Columns[11].GetCellContent(flowDocu.Items[index]) as TextBlock;

                        if (!string.IsNullOrEmpty(change.Text))
                        {
                            var datum = flowDocu.Columns[2].GetCellContent(flowDocu.Items[index]) as TextBlock;
                            var pers = flowDocu.Columns[9].GetCellContent(flowDocu.Items[index]) as TextBlock;

                            if (UserList.Where(p => (p.PersNummer == pers.Text && p.Datum == DateTime.Parse(datum.Text) && p.FilePath != "")).Count() > 0)
                                UserList.Where(p => (p.PersNummer == pers.Text && p.Datum == DateTime.Parse(datum.Text))).First().FilePath = "";
                        }
                    }
                }

                if (UserList != null)
                {
                    //Debug.WriteLine(UserList.Where(p => !string.IsNullOrEmpty(p.FilePath)).Count());
                    if (UserList.Where(p => !string.IsNullOrEmpty(p.FilePath)).Count() <= 0) lblLastChange.Foreground = new SolidColorBrush(Colors.Black);
                }

            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }

            timer.Stop();
        }

#endregion


        private async void CreateList(string search = "", bool isSearch = false, bool searchWithFilter = false)
        {
            try
            {
                var date = dPDatum.SelectedDate.HasValue ? dPDatum.SelectedDate.ToString() : "";

                var newList = await Task.Run(() => TableCreator.CreateList(DefaultUserList, abtFilter, abtFilter2, abtFilter3, lastButton, date, search, searchWithFilter, isSearch));

                if (newList != null) UserList = newList;

                //flowDocu.ItemsSource = UserList;
            }
            catch (Exception ex)
            {
                LogFile.WriteLine(ex.ToString());
                LogFile.WriteLine("Message: " + ex.Message);
                LogFile.WriteLine("UserList: " + UserList.Count + " Items");
                if (ex.InnerException != null) LogFile.WriteLine("InnerException: " + ex.InnerException);
            }
        }



#region Extensions

        public static Parent FindParent<Parent>(DependencyObject child)
            where Parent : DependencyObject
        {
            DependencyObject parentObject = child;

            //We are not dealing with Visual, so either we need to fnd parent or
            //get Visual to get parent from Parent Heirarchy.
            while (!((parentObject is System.Windows.Media.Visual)
                    || (parentObject is System.Windows.Media.Media3D.Visual3D)))
            {
                if (parentObject is Parent || parentObject == null)
                {
                    return parentObject as Parent;
                }
                else
                {
                    parentObject = (parentObject as FrameworkContentElement).Parent;
                }
            }

            //We have not found parent yet , and we have now visual to work with.
            parentObject = VisualTreeHelper.GetParent(parentObject);

            //check if the parent matches the type we're looking for
            if (parentObject is Parent || parentObject == null)
            {
                return parentObject as Parent;
            }
            else
            {
                //use recursion to proceed with next level
                return FindParent<Parent>(parentObject);
            }
        }

        public ScrollViewer GetScrollViewer(UIElement element)
        {
            //Dispatcher.BeginInvoke(new Action(() => { 
            if (element == null) return null;

            ScrollViewer retour = null;
            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(element) && retour == null; i++)
            {
                if (VisualTreeHelper.GetChild(element, i) is ScrollViewer)
                {
                    retour = (ScrollViewer)(VisualTreeHelper.GetChild(element, i));
                }
                else
                {
                    retour = GetScrollViewer(VisualTreeHelper.GetChild(element, i) as UIElement);
                }
            }
            return retour;
            //}));
        }


#endregion

#region Settings

        private void btnSettings_Click(object sender, RoutedEventArgs e)
        {
            tBAbtTranslatePath.Text = Properties.Settings.Default.AbteilungsnamenPath;
            tBLicenseFilePath.Text = Properties.Settings.Default.LizenzenPath;
            tBZuweisungenPath.Text = Properties.Settings.Default.ZuweisungenPath;


            gridSettings.Visibility = Visibility.Visible;
            canvasSettings.Visibility = Visibility.Visible;

            gridToolbar.Visibility = Visibility.Collapsed;
            gridTable.Visibility = Visibility.Collapsed;
        }

        private void btnCloseSettings_Click(object sender, RoutedEventArgs e)
        {
            canvasSettings.Visibility = Visibility.Collapsed;
            gridSettings.Visibility = Visibility.Collapsed;
            gridToolbar.Visibility = Visibility.Visible;
            gridTable.Visibility = Visibility.Visible;
            Properties.Settings.Default.AbteilungsnamenPath = tBAbtTranslatePath.Text;
            Properties.Settings.Default.LizenzenPath = tBLicenseFilePath.Text;
            Properties.Settings.Default.ZuweisungenPath = tBZuweisungenPath.Text;
            Properties.Settings.Default.Save();
        }

        private void btnCancelSettings_Click(object sender, RoutedEventArgs e)
        {
            canvasSettings.Visibility = Visibility.Collapsed;
            gridSettings.Visibility = Visibility.Collapsed;
            gridToolbar.Visibility = Visibility.Visible;
            gridTable.Visibility = Visibility.Visible;
        }

        private void btnSelectLicenseFile_Click(object sender, RoutedEventArgs e)
        {
            var p = Reader.OpenFile("Lizenzen");
            var lines = System.IO.File.ReadAllLines(p);

            if (lines[0].StartsWith("Name;") || lines[0].StartsWith("Personalnummer;0001")) tBLicenseFilePath.Text = p;
            else
            {
                var x = MessageBox.Show("Keine gültige Lizenzdatei ausgewählt!", "Fehler!", MessageBoxButton.OK, MessageBoxImage.Exclamation, MessageBoxResult.OK, MessageBoxOptions.ServiceNotification);
                btnSelectLicenseFile.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
            }
        }

        private void btnSelectAbtTranslateFile_Click(object sender, RoutedEventArgs e)
        {
            var p = Reader.OpenFile("Abteilungsnamen");
            var lines = System.IO.File.ReadAllLines(p);

            if (lines[0].StartsWith("Abteilung;")) tBAbtTranslatePath.Text = p;
            else
            {
                var x = MessageBox.Show("Keine gültige Abteilungsliste ausgewählt!", "Fehler!", MessageBoxButton.OK, MessageBoxImage.Exclamation, MessageBoxResult.OK, MessageBoxOptions.ServiceNotification);
                btnSelectAbtTranslateFile.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
            }
        }

        private void btnSelectZuweisungenFile_Click(object sender, RoutedEventArgs e)
        {
            var p = Reader.OpenFile("Zuweisungen");
            var lines = System.IO.File.ReadAllLines(p);

            if (!lines.Contains(";")) tBZuweisungenPath.Text = p;
            else
            {
                var x = MessageBox.Show("Keine gültige Zuweisungen-Liste ausgewählt!", "Fehler!", MessageBoxButton.OK, MessageBoxImage.Exclamation, MessageBoxResult.OK, MessageBoxOptions.ServiceNotification);
                btnSelectZuweisungenFile.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
            }
        }

        private void btnImpressum_Click(object sender, RoutedEventArgs e)
        {
            canvasImpressum.Visibility = Visibility.Visible;
        }

        private void btnCloseImpressum_Click(object sender, RoutedEventArgs e)
        {
            canvasImpressum.Visibility = Visibility.Collapsed;
        }


        private void btnVersionInfo_Click(object sender, RoutedEventArgs e)
        {
            canvasVersionInfo.Visibility = Visibility.Visible;
        }

        private void btnCloseVersionInfo_Click(object sender, RoutedEventArgs e)
        {
            canvasVersionInfo.Visibility = Visibility.Collapsed;
        }


#endregion



        private void Window_Deactivated(object sender, EventArgs e)
        {
            Debug.WriteLine("jo2");
            var telbox = telefonTextbox;

            if (telbox != null)
            {
                DataGridRow dataGridRow = FindParent<DataGridRow>(telbox);
                if (dataGridRow != null)
                {
                    int index = dataGridRow.GetIndex();

                    var persnummer = flowDocu.Columns[9].GetCellContent(flowDocu.Items[index]) as TextBlock;

                    foreach (var user in DefaultUserList.Where(p => (p.PersNummer == persnummer.Text)))
                        DefaultUserList.Where(p => (p.PersNummer == user.PersNummer && p.Datum == user.Datum)).First().Telefon = telbox.Text.ToString();

                    if (TelefonChanges.Where(p => p.sender == telbox).Count() == 0)
                        TelefonChanges.Add(new ChangesQueue.TelefonChanges() { sender = telbox, index = index });
                }
            }

            var bembox = bemerkungTextbox;

            try
            {
                if (bembox != null)
                {
                    DataGridRow dataGridRow = FindParent<DataGridRow>(bembox);
                    if (dataGridRow != null)
                    {
                        int index = dataGridRow.GetIndex();

                        if (BemerkungenChanges.Where(p => p.sender == bembox).Count() == 0)
                            BemerkungenChanges.Add(new ChangesQueue.BemerkungenChanges() { sender = bembox, index = index });
                    }
                }

            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
        }


        private void btnHideToolbar_Click(object sender, RoutedEventArgs e)
        {
            if (gridToolbar.Height == 184)
            {
                gridToolbar.Height = 14;
                btnHideToolbar.Content = "˅˅";
                flowDocu.Height = ActualHeight + 170;
                btnHideToolbar.ToolTip = "Toolbar öffnen";
            }
            else
            {
                gridToolbar.Height = 184;
                btnHideToolbar.Content = "^^";
                flowDocu.Height = ActualHeight - 170;
                btnHideToolbar.ToolTip = "Toolbar schließen";
            }

            gridTable.Height = main.ActualHeight - gridToolbar.Height - 40;
            flowDocu.Height = gridTable.Height;
        }

        bool onStartup = false;
        private async void Window_Closing(object sender, CancelEventArgs e)
        {
            await Tracker.SaveTrack(false);
            await Task.Delay(1000);


            var telbox = telefonTextbox;

            if (telbox != null)
            {
                DataGridRow dataGridRow = FindParent<DataGridRow>(telbox);
                if (dataGridRow != null)
                {
                    int index = dataGridRow.GetIndex();

                    var persnummer = flowDocu.Columns[9].GetCellContent(flowDocu.Items[index]) as TextBlock;

                    foreach (var user in DefaultUserList.Where(p => (p.PersNummer == persnummer.Text)))
                        DefaultUserList.Where(p => (p.PersNummer == user.PersNummer && p.Datum == user.Datum)).First().Telefon = telbox.Text.ToString();

                    if (TelefonChanges.Where(p => p.sender == telbox).Count() == 0)
                        TelefonChanges.Add(new ChangesQueue.TelefonChanges() { sender = telbox, index = index });
                }
            }

            var bembox = bemerkungTextbox;

            if (bembox != null)
            {
                DataGridRow dataGridRow = FindParent<DataGridRow>(bembox);
                if (dataGridRow != null)
                {
                    int index = dataGridRow.GetIndex();

                    if (BemerkungenChanges.Where(p => p.sender == bembox).Count() == 0)
                        BemerkungenChanges.Add(new ChangesQueue.BemerkungenChanges() { sender = bembox, index = index });
                }
            }

            if (TelefonChanges.Count > 0)
                SaveTelefon(TelefonChanges);

            if (BemerkungenChanges.Count > 0)
                SaveBemerkung(BemerkungenChanges);

            if (!onStartup) Application.Current.Shutdown();


        }

        private void Window_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            gridTable.Height = main.ActualHeight - gridToolbar.Height - 40;
            flowDocu.Height = gridTable.Height;

        }

        private void Window_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            var scroll = Helper.FindVisualChild<ScrollViewer>((DependencyObject)sender);

            int firstRow = (int)scroll.VerticalOffset;
            int lastRow = (int)scroll.VerticalOffset + (int)scroll.ViewportHeight - 1;

            if (firstRow != lastVisibleFirstRow)
            {
                lastVisibleFirstRow = firstRow;
                DispatcherTimer ChangeTimer = new DispatcherTimer();
                ChangeTimer.Interval = TimeSpan.FromSeconds(10);
                ChangeTimer.Tick += (s, ev) => { ChangeTimer_Tick(sender, e, firstRow, lastRow, ChangeTimer); };
                ChangeTimer.Start();
            }
        }


        private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            var combo = sender as ComboBox;
            combo.SelectedIndex = 0;
        }




        private static void GetDesktopShortcuts()
        {
            if (!File.Exists(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\UpdatePEP.bat") || File.GetLastWriteTime(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\UpdatePEP.bat") != File.GetLastWriteTime(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\UpdatePEP.bat"))
            {
                File.Copy(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\UpdatePEP.bat", Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\UpdatePEP.bat", true);
                GetDesktopShortcuts();
            }
            else
            {
                if (File.GetLastWriteTime(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\PEP-Tool.exe") < File.GetLastWriteTime(@"\\bku.db.de\db\DB_006\GLW_11\ICE-Fertigung\M2\Personaleinsatzplanung\PEP-Tool.exe"))
                {
                    Process.Start(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\UpdatePEP.bat");
                    Application.Current.Shutdown();
                }
            }

            foreach (var link in Directory.GetFiles(Environment.GetFolderPath(Environment.SpecialFolder.Desktop)))
            {
                if (System.IO.Path.GetExtension(link) == ".lnk")
                {
                    var target = ResolveShortcut(link);

                    if (target.EndsWith("AV-Tool.exe"))
                    {
                        ChangeShortcutTarget(link);
                    }
                }
            }
        }

        static string ResolveShortcut(string filePath)
        {
            // IWshRuntimeLibrary is in the COM library "Windows Script Host Object Model"
            IWshRuntimeLibrary.WshShell shell = new IWshRuntimeLibrary.WshShell();

            try
            {
                IWshRuntimeLibrary.IWshShortcut shortcut = (IWshRuntimeLibrary.IWshShortcut)shell.CreateShortcut(filePath);
                return shortcut.TargetPath;
            }
            catch (System.Runtime.InteropServices.COMException)
            {
                // A COMException is thrown if the file is not a valid shortcut (.lnk) file 
                return null;
            }
        }

        [System.Runtime.InteropServices.DllImport("Shell32.dll")]
        private static extern int SHChangeNotify(int eventId, int flags, IntPtr item1, IntPtr item2);

        static void ChangeShortcutTarget(string filePath)
        {
            File.Delete(filePath);
            //// IWshRuntimeLibrary is in the COM library "Windows Script Host Object Model"
            //IWshRuntimeLibrary.WshShell shell = new IWshRuntimeLibrary.WshShell();

            //try
            //{
            //    IWshRuntimeLibrary.IWshShortcut shortcut = (IWshRuntimeLibrary.IWshShortcut)shell.CreateShortcut(filePath);
            //    shortcut.TargetPath = shortcut.TargetPath.Replace("AV-Tool.exe", "PEP-Tool.exe");
            //    shortcut.Save();

            //    File.Move(filePath, filePath.Substring(0, filePath.LastIndexOf("\\")) + "\\PEP-Tool.lnk");

            //    SHChangeNotify(0x8000000, 0x1000, IntPtr.Zero, IntPtr.Zero);
            //}
            //catch (System.Runtime.InteropServices.COMException ex)
            //{
            //    // A COMException is thrown if the file is not a valid shortcut (.lnk) file 
            //    LogFile.WriteLine(ex);
            //}
        }

        private void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            Debug.WriteLine("PropertyChanged   " + propertyName);
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

    }
}