using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Threading;
using AvalonDock.Layout;
using Comal.Classes;
using Comal.Stores;
using Comal.TaskScheduler.Shared;
using H.Pipes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.Database;
using InABox.Database.SQLite;
using InABox.DynamicGrid;
using InABox.Mail;
using InABox.Rpc;
using InABox.Scripting;
using InABox.Wpf;
using InABox.WPF;
using NAudio.Wave;
using PRS.Shared;
using InABox.WPF.Themes;
using PRSDesktop.Configuration;
using PRSDesktop.Forms;
using PRSServer;
using SharpAvi.Codecs;
using SharpAvi.Output;
using Syncfusion.Windows.Shared;
using Syncfusion.Windows.Tools.Controls;
using Application = System.Windows.Application;
using ButtonBase = System.Windows.Controls.Primitives.ButtonBase;
using Color = System.Windows.Media.Color;
using ColorConverter = System.Windows.Media.ColorConverter;
using Control = System.Windows.Controls.Control;
using Image = System.Drawing.Image;
using KeyEventArgs = System.Windows.Input.KeyEventArgs;
using MessageBox = System.Windows.MessageBox;
using Pen = System.Drawing.Pen;
using PixelFormat = System.Drawing.Imaging.PixelFormat;
using SortDirection = InABox.Core.SortDirection;
using InABox.Wpf.Reports;
using Comal.Classes.SecurityDescriptors;
using System.Threading;
using H.Formatters;
using PRSDesktop.Forms.Issues;
using Brushes = System.Windows.Media.Brushes;
using System.Windows.Media.Imaging;

namespace PRSDesktop;

public enum PanelType
{
    InPlace,
    NewWindow
}

public class SimpleCommand : ICommand
{
    
    public Action OnExecute { get; private set; }
    
    public bool CanExecute(object? parameter) => true; 

    public event EventHandler? CanExecuteChanged
    {
        add => CommandManager.RequerySuggested += value;
        remove => CommandManager.RequerySuggested -= value;
    }

    public void Execute(object? parameter)
    {
        OnExecute?.Invoke();
    }

    public SimpleCommand(Action onExecute)
    {
        OnExecute = onExecute;
    }
    
}

/// <summary>
///     Interaction logic for Main.xaml
/// </summary>
public partial class MainWindow : IPanelHostControl
{
    //private const int WM_LBUTTONDOWN = 0x201;

    private static PipeServer<string>? _client;

    private IRpcClientTransport? _transport;

    private WaveIn? _audio;
    private bool _audioMuted;
    private MemoryStream? _audioStream;
    private readonly Dictionary<DateTime, Stream> _bitmaps = new();

    private DesktopConsole? _console;
    private Dictionary<DateTime, Tuple<Rectangle, string>> _notes = new();


    private DispatcherTimer? _recorder;


    private Process? _recordingnotes;
    private int _screenheight = 720;

    private int _screenleft;
    private int _screentop;
    private int _screenwidth = 1280;

    private readonly Dictionary<Guid, SecondaryWindow> SecondaryWindows = new();

    private CoreTable? _timesheets;

    private DailyActivityHistory? ActivityHistory;
    private readonly List<Control> CurrentModules = new();

    private Fluent.RibbonTabItem? CurrentTab;
    private Fluent.Button? CurrentButton;

    private readonly int FRAMES_PER_SECOND = 10;

    private DatabaseType DatabaseType;

    private readonly Dictionary<int, int> messages = new();

    private readonly DispatcherTimer NotificationsWatchDog;

    private DateTime pausestarted = DateTime.MinValue;

    private readonly Scheduler scheduler = new() { Interval = new TimeSpan(0, 5, 0) };

    // We use a Guid for the StationID rather than an IP or Mac address
    // because we want true single-instance restriction.  Using either of
    // the above allows for two instances on the once machine, and thus
    // double-counting in the Heartbeat() function
    private Login station = new() { StationID = Guid.NewGuid().ToString() };
    private TimeSpan totalpauses = new(0);
    private readonly int VIDEO_HEIGHT = 1080;
    private readonly int VIDEO_WIDTH = 1920;

    private PanelHost PanelHost;

    public MainWindow()
    {
        PanelHost = new PanelHost(this);

        NotificationsWatchDog = new DispatcherTimer { IsEnabled = false };
        NotificationsWatchDog.Tick += Notifications_Tick;
        NotificationsWatchDog.Interval = new TimeSpan(0, 2, 0);

        ClientFactory.PushHandlers.AddHandler<Notification>(ReceiveNotification);
        ClientFactory.RegisterMailer(EmailType.IMAP, typeof(IMAPMailer));
        ClientFactory.RegisterMailer(EmailType.Exchange, typeof(ExchangeMailer));
        ClientFactory.OnLog += (type, userid, message, parameters) => Logger.Send(LogType.Information, ClientFactory.UserID, message, parameters);
        ClientFactory.OnRequestError += ClientFactory_OnRequestError;

        HotKeyManager.Initialize();
        HotKeyManager.RegisterHotKey(Key.F1, ShowHelp);
        //HotKeyManager.RegisterHotKey(Key.F5, ToggleRecording);
        //HotKeyManager.RegisterHotKey(Key.F6, ShowRecordingNotes);
        //HotKeyManager.RegisterHotKey(Key.F4, ToggleRecordingAudio);

        Logger.Send(LogType.Information, "", "Connecting to server");
        var settings = App.DatabaseSettings;
        bool dbConnected;
        DatabaseType = settings.DatabaseType;
        switch (DatabaseType)
        {
            case DatabaseType.Standalone:
                ClientFactory.SetClientType(typeof(LocalClient<>), Platform.Wpf, CoreUtils.GetVersion());
                DbFactory.ColorScheme = App.DatabaseSettings.ColorScheme;
                DbFactory.Logo = App.DatabaseSettings.Logo;
                dbConnected = true;
                break;

            case DatabaseType.Networked:
                if (App.DatabaseSettings.Protocol == SerializerProtocol.RPC)
                {
                    _transport = new RpcClientSocketTransport(App.DatabaseSettings.URLs);
                    _transport.OnClose += TransportConnectionLost;
                    _transport.OnException += Transport_OnException;
                    _transport.OnOpen += Transport_OnOpen; ;
                    dbConnected = _transport.Connect();
                    ClientFactory.SetClientType(typeof(RpcClient<>), Platform.Wpf, CoreUtils.GetVersion(),
                        _transport);
                }
                else
                {
                    var url = RestClient<User>.Ping(App.DatabaseSettings.URLs, out DatabaseInfo info);
                    ClientFactory.SetClientType(typeof(RestClient<>), Platform.Wpf, CoreUtils.GetVersion(), url, true);
                    dbConnected = true;
                }

                break;

            case DatabaseType.Local:
                //new RPC stuff (temporary disabled - for enabling when RPC is ready)
                var pipename = DatabaseServerProperties.GetPipeName(App.DatabaseSettings.LocalServerName, true);
                _transport = new RpcClientPipeTransport(pipename);
                _transport.OnClose += TransportConnectionLost;
                dbConnected = _transport.Connect();
                ClientFactory.SetClientType(typeof(RpcClient<>), Platform.Wpf, CoreUtils.GetVersion(), _transport );
                
                //ClientFactory.SetClientType(typeof(IPCClient<>), Platform.Wpf, CoreUtils.GetVersion(),
                //    DatabaseServerProperties.GetPipeName(App.DatabaseSettings.LocalServerName, false));
                //dbConnected = true;
                
                break;
            default:
                throw new Exception($"Invalid database type {DatabaseType}");
        }

        InitializeComponent();

        if (!dbConnected)
        {
            switch (DoConnectionFailed())
            {
                case ConnectionFailedResult.Quit:
                    Close();
                    return;
                case ConnectionFailedResult.Restart:
                    App.ShouldRestart = true;
                    Close();
                    return;
                case ConnectionFailedResult.Ok:
                    // Do nothing
                    break;
            }
        }

        ThemeManager.BaseColor = Colors.CornflowerBlue;
        Progress.DisplayImage = PRSDesktop.Resources.splash_small.AsBitmapImage();
        try
        {
            var dbInfo = new Client<User>().Info();
            ClientFactory.DatabaseID = dbInfo.DatabaseID;
            ThemeManager.BaseColor = (Color)ColorConverter.ConvertFromString(dbInfo.ColorScheme);
            if (dbInfo.Logo?.Any() == true)
                using (var ms = new MemoryStream(dbInfo.Logo))
                {
                    Progress.DisplayImage = new Bitmap(ms).AsBitmapImage();
                }
        }
        catch
        {
        }

        //VideoRecordingStatus.Source = PRSDesktop.Resources.videorecording.AsGrayScale().AsBitmapImage();
        //AudioRecordingStatus.Source = PRSDesktop.Resources.audiorecording.AsGrayScale().AsBitmapImage();
        //SecondaryWindowStatus.Source = PRSDesktop.Resources.target.AsGrayScale().AsBitmapImage();
        
        ConsoleStatus.Source = PRSDesktop.Resources.view.AsGrayScale().AsBitmapImage();
        SelectTask.Source = PRSDesktop.Resources.uparrow.Invert().AsBitmapImage();
        Title = $"{(String.Equals(App.Profile?.ToUpper(), "DEFAULT") ? "PRS Desktop" : App.Profile)} (Release {CoreUtils.GetVersion()})";
        
        Logger.Send(LogType.Information, "", "Checking for updates");
        if (SupportUtils.CheckForUpdates())
        {
            Logger.Send(LogType.Information, "", "Update found, closing application.");
            Close();
            return;
        }

        Exception? startupException = null;
        ValidationStatus? loginStatus = null;

        Progress.ShowModal("Loading PRS", progress =>
        {
            DynamicGridUtils.PreviewReport = (t, m) => { ReportUtils.PreviewReport(t, m, false, Security.IsAllowed<CanDesignReports>()); };
            DynamicGridUtils.PrintMenu = (e, s, m, p) => { ReportUtils.PrintMenu(e, s, m, Security.IsAllowed<CanDesignReports>(), p); };
            ImportFactory.Register(typeof(ExcelImporter<>), "Excel File", "Excel Files (*.xls;*.xlsx;*.xlsm)|*.xls;*.xlsx;*.xlsm");
            ImportFactory.Register(typeof(CustomImporter<>), "Custom", "All Files (*.*)|*.*");

            FormUtils.Register();
            
            DigitalFormDocumentFactory.Init(
                new WpfDigitalFormDocumentHandler(
                    b => Dispatcher.BeginInvoke(() =>
                        {
                            BackgroundUploadStatus.Visibility = b
                                ? Visibility.Visible
                                : Visibility.Hidden;
                        }
                    ),
                    () => _transport?.IsConnected() ?? false
                )
            );
            DigitalFormDocumentFactory.Run();
            
            Logger.Send(LogType.Information, "", "Registering Classes");

            progress.Report("Registering Classes");

            var tasks = new List<Task>
            {
                Task.Run(() =>
                {
                    CoreUtils.RegisterClasses(typeof(TaskGrid).Assembly);
                    CoreUtils.RegisterClasses();
                    ComalUtils.RegisterClasses();
                    StoreUtils.RegisterClasses();
                    PRSSharedUtils.RegisterClasses();
                    WPFUtils.RegisterClasses();
                    ReportUtils.RegisterClasses();
                    ConfigurationUtils.RegisterClasses();
                }),
                Task.Run(() =>
                {
                    ScriptDocument.DefaultAssemblies.AddRange(
                        Assembly.Load("RoslynPad.Roslyn.Windows"),
                        Assembly.Load("RoslynPad.Editor.Windows"),
                        typeof(Control).Assembly,
                        typeof(MessageBox).Assembly,
                        typeof(SolidColorBrush).Assembly
                    );
                    ScriptDocument.Initialize();
                }),
                Task.Run(() => DatabaseUpdateScripts.RegisterScripts())
            };
            Task.WaitAll(tasks.ToArray());

            Logger.Send(LogType.Information, "", "Configuring Application");

            progress.Report("Configuring Application");
            RegisterModules(progress);

            if (DatabaseType == DatabaseType.Standalone)
            {
                progress.Report("Starting local database...");
                try
                {
                    StartLocalDatabase(progress);
                }
                catch (Exception err)
                {
                    startupException = new Exception(
                        string.Format(
                            "Unable to open database ({0})\n\n{1}\n\n{2}",
                            App.DatabaseSettings.FileName,
                            err.Message,
                            err.StackTrace
                        )
                    );
                }
            }
        });

        if (startupException is null && App.DatabaseSettings.Autologin)
        {
            try
            {
                Logger.Send(LogType.Information, "", "Logging in");
                Dispatcher.Invoke(() =>
                {
                    loginStatus = TryAutoLogin();
                });
                if(loginStatus == ValidationStatus.VALID)
                {
                    // Do the AfterLogin() here so that we aren't opening and closing progress windows again and again.
                    Progress.ShowModal("Loading PRS", progress =>
                    {
                        AfterLogin(progress);
                    });
                }
            }
            catch(Exception e)
            {
                startupException = e;
            }
        }

        if (startupException != null)
        {
            MessageWindow.ShowError("Error during startup.", startupException);
        }
        
        // If the login status is valid, then we've already loaded everything, so we don't here.
        if(loginStatus != ValidationStatus.VALID)
        {
            Logger.Send(LogType.Information, "", "Logging in");
            if (DoLogin() == ValidationStatus.VALID)
            {
                AfterLogin(null);
            }
            else
            {
                ConfigureMainScreen(null);
            }
        }

        ProfileName.Content = App.Profile;
        URL.Content = GetDatabaseConnectionDescription();

        if (loginStatus == ValidationStatus.VALID && DatabaseType == DatabaseType.Standalone)
        {
            Progress.ShowModal("Starting Scheduler", progress =>
            {
                scheduler.Start();
            });
        }
    }

    #region Connection Management

    private string GetDatabaseConnectionDescription()
    {
        return DatabaseType switch
        {
#if RPC
            DatabaseType.Networked => (ClientFactory.Parameters?.FirstOrDefault() as RpcClientSocketTransport)?.Host,
#else
            DatabaseType.Networked => ClientFactory.Parameters?.FirstOrDefault() as string,
#endif
            DatabaseType.Standalone => App.DatabaseSettings?.FileName,
            DatabaseType.Local => App.DatabaseSettings?.LocalServerName,
            _ => ""
        } ?? "";
    }

    /// <summary>
    /// Reconnect to the server.
    /// </summary>
    /// <returns><see langword="true"/> if connection was successful.</returns>
    private bool Reconnect()
    {
        if (_transport != null)
        {
            return _transport.Connect();
        }
        Logger.Send(LogType.Error, ClientFactory.UserID, "Trying to reconnect without a transport set.");
        return true; // Returning true so we don't get stuck in infinite loops in exceptional circumstances.
    }

    private enum ConnectionFailedResult
    {
        Quit,
        Restart,
        Ok
    }

    /// <summary>
    /// To be called when initial connection to the server has failed; asks the user if they want to retry,
    /// change the database settings, or simply quit PRS.
    /// </summary>
    /// <returns>The action to take next.</returns>
    /// <exception cref="Exception"></exception>
    private ConnectionFailedResult DoConnectionFailed()
    {
        bool connected = false;
        while (!connected)
        {
            var connectionFailedWindow = new ConnectionFailed();
            connectionFailedWindow.ShowDialog();

            var reconnect = false;
            switch (connectionFailedWindow.Result)
            {
                case ConnectionFailedWindowResult.OpenDatabaseConfiguration:
                    var result = ShowDatabaseConfiguration();
                    switch (result)
                    {
                        case DatabaseConfigurationResult.RestartRequired:
                            var shouldRestart = MessageBox.Show(
                                "A restart is required to apply these changes. Do you wish to restart now?",
                                "Restart?",
                                MessageBoxButton.YesNo);
                            if (shouldRestart == MessageBoxResult.Yes)
                            {
                                return ConnectionFailedResult.Restart;
                            }
                            else
                            {
                                reconnect = true;
                            }
                            break;
                        case DatabaseConfigurationResult.RestartNotRequired:
                            reconnect = true;
                            break;
                        case DatabaseConfigurationResult.Cancel:
                            reconnect = true;
                            break;
                        default:
                            throw new Exception($"Invalid enum result {result}");
                    }
                    break;
                case ConnectionFailedWindowResult.RetryConnection:
                    reconnect = true;
                    break;
                case ConnectionFailedWindowResult.Quit:
                    return ConnectionFailedResult.Quit;
                default:
                    throw new Exception($"Invalid enum result {connectionFailedWindow.Result}");
            }
            if (!reconnect)
            {
                return ConnectionFailedResult.Quit;
            }
            connected = Reconnect();
        }
        return ConnectionFailedResult.Ok;
    }

    private void Transport_OnOpen(IRpcTransport transport, RpcTransportOpenArgs e)
    {
        Logger.Send(LogType.Information, ClientFactory.UserID, "Connection opened");
    }

    private void Transport_OnException(IRpcTransport transport, RpcTransportExceptionArgs e)
    {
        Logger.Send(LogType.Error, ClientFactory.UserID, $"Error in connection: {CoreUtils.FormatException(e.Exception)}");
    }

    private void TransportConnectionLost(IRpcTransport transport, RpcTransportCloseArgs e)
    {
        Logger.Send(LogType.Information, ClientFactory.UserID, "Connection lost");
        if (transport is IRpcClientTransport client)
        {
            Dispatcher.Invoke(() =>
            {
                var reconnection = new ReconnectionWindow();
                var cancellationTokenSource = new CancellationTokenSource();

                reconnection.OnCancelled = () => cancellationTokenSource.Cancel();

                var ct = cancellationTokenSource.Token;
                var work = () =>
                {
                    try
                    {
                        DateTime lost = DateTime.Now;
                        while (!client.IsConnected() && !ct.IsCancellationRequested)
                        {
                            try
                            {
                                Logger.Send(LogType.Error, ClientFactory.UserID, $"Reconnecting - ({DateTime.Now - lost:hh\\:mm})");
                                if (client.Connect(ct))
                                {
                                    break;
                                }
                            }
                            catch (System.Exception e1)
                            {
                                Logger.Send(LogType.Error, ClientFactory.UserID, $"Reconnect Failed: {e1.Message}");

                                // TODO: Remove this suppression
                                if (e1.Message.StartsWith("The socket is connected, you needn't connect again!"))
                                {
                                    break;
                                }
                            }
                        }
                        if (client.IsConnected())
                        {
                            Logger.Send(LogType.Information, ClientFactory.UserID, "Reconnected");
                            ClientFactory.Validate(ClientFactory.SessionID);
                            Logger.Send(LogType.Information, ClientFactory.UserID, "Validated");
                            return true;
                        }
                    }
                    catch (Exception e)
                    {
                        Logger.Send(LogType.Error, ClientFactory.UserID, $"Reconnect Failed: {e.Message}");
                    }
                    return false;
                };
                var task = Task.Run(() =>
                {
                    var result = work();
                    Dispatcher.Invoke(() =>
                    {
                        reconnection.Close();
                    });
                    return result;
                }, ct);
                reconnection.ShowDialog();
                if (!task.Result)
                {
                    Close();
                }
            });
        }
    }

    #endregion

    private bool _loggingOut = false;

    private void ClientFactory_OnRequestError(RequestException e)
    {
        if (e.Status == StatusCode.Unauthenticated)
        {
            switch (e.Method)
            {
                case RequestMethod.Query:
                case RequestMethod.Save:
                case RequestMethod.Delete:
                case RequestMethod.MultiQuery:
                case RequestMethod.MultiSave:
                case RequestMethod.MultiDelete:
                    if (!_loggingOut)
                    {
                        Dispatcher.InvokeAsync(() =>
                        {
                            _loggingOut = true;
                            try
                            {
                                Logout(null, true);
                            }
                            finally
                            {
                                _loggingOut = false;
                            }
                        });
                    }
                    break;
                default:
                    break;
            }
        }
    }

    private void ApplyColorScheme()
    {

        Color baseColor;
        try
        {
            baseColor = (Color)ColorConverter.ConvertFromString(App.DatabaseSettings.ColorScheme);
        }
        catch
        {
            baseColor = Colors.CornflowerBlue;
        }

        ThemeManager.BaseColor = baseColor;
        DynamicGridUtils.SelectionBackground = ThemeManager.SelectionBackgroundBrush;
        DynamicGridUtils.SelectionForeground = ThemeManager.SelectionForegroundBrush;
        DynamicGridUtils.FilterBackground = ThemeManager.FilterBackgroundBrush;
        DynamicGridUtils.FilterForeground = ThemeManager.FilterForegroundBrush;
        
        //_ribbon.Background =  new SolidColorBrush(Colors.White);
        //_ribbon.BackStageColor = ThemeConverter.GetBrush(ElementType.Ribbon, BrushType.Background);
        ////_ribbon.BackStage.Background = ThemeConverter.GetBrush(ElementType.Ribbon, BrushType.Background);
        ////_ribbon.BackStage.Foreground = ThemeConverter.GetBrush(ElementType.Ribbon, BrushType.Foreground);

        UpdateRibbonColors();
        PanelHost.Refresh();

    }

    #region Configuration
    /*
    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);
        var source = PresentationSource.FromVisual(this) as HwndSource;
        source?.AddHook(WndProc);
    }

    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        var message = (App.Message)msg;
        switch (message)
        {
            case App.Message.Maximise:
                WindowState = WindowState.Maximized;
                break;
        }

        return IntPtr.Zero;
    }*/


    private void ConfigureMainScreen(IProgress<string>? progress)
    {
        var bMaps = Security.CanView<Equipment>()
                    || Security.CanView<Job>()
                    || Security.CanView<TimeSheet>()
                    || Security.CanView<GPSTracker>();

        var sections = new[]
        {
            new ProgressSection("Configuring Main Screen", SetupMainScreen),
            new ProgressSection("Configuring Projects", () => SetupProjectsTab(bMaps)),
            new ProgressSection("Configuring Manufacturing", () => SetupManufacturingTab(bMaps)),
            new ProgressSection("Configuring Logistics", () => SetupLogisticsTab(bMaps)),
            new ProgressSection("Configuring Products", () => SetupProductsTab(bMaps)),
            new ProgressSection("Configuring Human Resources", () => SetupHumanResourcesTab(bMaps)),
            new ProgressSection("Configuring Accounts", () => SetupAccountsTab(bMaps)),
            new ProgressSection("Configuring Equipment", () => SetupEquipmentTab(bMaps)),
            new ProgressSection("Configuring DigitalForms", () => SetupDigitalFormsTab(bMaps)),
            new ProgressSection("Configuring Dashboards", () => SetupDashboardsTab(bMaps)),
            new ProgressSection("Configuring System Modules", SetupSystemModules)
        };

        if(progress is not null)
        {
            Dispatcher.Invoke(SetupScreen);
            foreach(var section in sections)
            {
                progress.Report(section.Message);
                Dispatcher.Invoke(section.Action);
            }
        }
        else
        {
            SetupScreen();
            Progress.ShowModal(sections);
        }
    }

    private void SetupScreen()
    {
        var button = _ribbon.FindVisualChildren<Fluent.DropDownButton>().FirstOrDefault();
        if (button != null)
            button.Visibility = Visibility.Collapsed;

        if (ClientFactory.UserGuid == Guid.Empty)
            _ribbonRow.Height = new GridLength(30, GridUnitType.Pixel);
        else
            _ribbonRow.Height = new GridLength(1, GridUnitType.Auto);
    }

    private void SetupMainScreen()
    {
        //DockManager.SidePanelSize = OutstandingDailyReports(false) ? 0.00F : 30.00F;

        // Notifications Area
        SetFrameworkItemVisibility(SendNotification, Security.CanView<Notification>());
        SetFrameworkItemVisibility(Notifications, Security.CanView<Notification>());
        SetFrameworkItemVisibility(TaskTracking, Security.IsAllowed<CanTrackTasksInDailyReport>());

        UserID.Content = ClientFactory.UserID;
        if (ClientFactory.PasswordExpiration != DateTime.MinValue)
        {
            var timeUntilExpiration = ClientFactory.PasswordExpiration - DateTime.Now;
            if (timeUntilExpiration.Days < 14)
            {
                PasswordExpiryNotice.Content = $"Password will expire in {timeUntilExpiration.Days} days!";
                PasswordExpiryNotice.Visibility = Visibility.Visible;
            }
            else
            {
                PasswordExpiryNotice.Visibility = Visibility.Collapsed;
            }
        }
    }

    private void SetupSystemModules()
    {
        SetFrameworkItemVisibility(CompanyInformation, Security.CanView<CompanyInformation>());

        SetVisibleIfAny(BackstageSeparator0, CompanyInformation);
        SetFrameworkItemVisibility(SecurityDefaultsButton,
            ClientFactory.IsSupported<GlobalSecurityToken>() && Security.IsAllowed<CanCustomiseSecurityDefaults>());
        SetVisibleIfAny(BackstageSeparator1, SecurityDefaultsButton);

        BackstageSeparator1a.Visibility = Visibility.Visible;
        SystemLogsButton.Visibility = Visibility.Visible;

        SetFrameworkItemVisibility(DocumentTypeList, ClientFactory.IsSupported<DocumentType>() && Security.IsAllowed<CanViewDocumentTypes>());
        SetFrameworkItemVisibility(EventList, Security.IsAllowed<CanManageEvents>());
        SetVisibleIfAny(BackstageSeparator2, DocumentTypeList, EventList);

        //SetModuleVisibility<>(VideoRecordingButton, Security.IsAllowed<CanRecordScreen>());

        LogoutButton.Visibility = ClientFactory.UserGuid == Guid.Empty ? Visibility.Collapsed : Visibility.Visible;
        LoginButton.Visibility = ClientFactory.UserGuid != Guid.Empty ? Visibility.Collapsed : Visibility.Visible;

        EditDetailsButton.Visibility = ClientFactory.UserGuid == Guid.Empty ? Visibility.Collapsed : Visibility.Visible;

        SetupDock<CanViewContactsDock>(ContactDock, Contacts);
        SetupDock<CanViewJobDock>(JobDock, Jobs);
        SetupDock<CanViewConsignmentDock>(ConsignmentDock, Consignments);
        SetupDock<CanViewDeliveryDock>(DeliveryDock, Deliveries);
        SetupDock<CanViewProductDock>(ProductLookupDock, ProductLookup);
        SetupDock<CanViewDigitalFormsDock>(DigitalFormsDock, DigitalForms);
        SetupDock<CanViewProblemsDock>(ProblemsDock, Problems);
        SetupDock<CanViewRequisitionsDock>(RequisitionsDock, Requisitions);

        _ribbon.InvalidateArrange();
    }

    private void SetupDashboardsTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopDashboardsTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(DashboardsDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(DashboardMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(DashboardsTaskButton, ClientFactory.IsSupported<Kanban>() && Security.IsAllowed<CanViewTasks>());
        SetModuleVisibility<AttendancePanel>(DashboardsAttendanceButton, ClientFactory.IsSupported<TimeSheet>() && Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(DashboardsMapButton, bMaps);
        SetModuleVisibility<DailyReport>(DashboardsDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());

        SetModuleVisibility<FactoryProductivityDashboard>(FactoryProductivityButton,
            ClientFactory.IsSupported<ManufacturingHistory>() 
            && Security.IsAllowed<CanViewFactoryKPIs>()
            && Security.IsAllowed<ViewDesktopFactoryKPIsDashboard>());

        SetModuleVisibility<ManufacturingTemplateAnalysis>(TemplateAnalysisButton,
            ClientFactory.IsSupported<ManufacturingTemplate, ManufacturingHistory>() 
            && Security.IsAllowed<CanViewTemplateAnalysis>()
            && Security.IsAllowed<ViewDesktopTemplateAnalysisDashboard>());

        SetModuleVisibility<FactoryFloorAnalysis>(FactoryAnalysisButton,
            ClientFactory.IsSupported<ManufacturingTemplate, ManufacturingHistory>() 
            && Security.IsAllowed<CanViewFactoryAnalysis>()
            && Security.IsAllowed<ViewDesktopFactoryAnalysisDashboard>());

        SetModuleVisibility<DatabaseActivityDashboard>(DatabaseActivityButton,
            ClientFactory.IsSupported<UserTracking>() 
            && Security.IsAllowed<CanViewDatabaseActivity>()
            && Security.IsAllowed<ViewDesktopDatabaseActivityDashboard>());

        SetModuleVisibility<UserActivity>(UserActivityButton, ClientFactory.IsSupported<ModuleTracking>() 
                                                        && Security.IsAllowed<CanViewUserActivity>()
                                                        && Security.IsAllowed<ViewDesktopUserActivityDashboard>());

        SetModuleVisibility<WidgetDashboard>(QuickStatusButton, Security.IsAllowed<CanViewQuickStatus>() && Security.IsAllowed<ViewDesktopQuickStatusDashboard>());

        SetVisibleIfEither(DashboardsTaskSeparator,
            new FrameworkElement[]
            {
                            DashboardsDashboardButton, DashboardMessagesButton, DashboardsTaskButton, DashboardsAttendanceButton,
                            DashboardsMapButton,
                            DashboardsDailyReportButton
            },
            new FrameworkElement[]
            {
                            FactoryProductivityButton, TemplateAnalysisButton, FactoryAnalysisButton, DatabaseActivityButton, UserActivityButton, QuickStatusButton
            });
        SetVisibleIfAny(DashboardsActions, DashboardsDashboardButton, DashboardMessagesButton, DashboardsTaskButton,
            DashboardsAttendanceButton, DashboardsDailyReportButton, FactoryProductivityButton, TemplateAnalysisButton,
            FactoryAnalysisButton, DatabaseActivityButton, UserActivityButton, QuickStatusButton);

        //DashboardsActions.IsLauncherButtonVisible = Security.IsAllowed<CanCustomiseModules>();
        //DashboardsReports.IsLauncherButtonVisible = Security.IsAllowed<CanDesignReports>();

        SetVisibleIfAny(DashboardsTab, FactoryProductivityButton, TemplateAnalysisButton, FactoryAnalysisButton,
            DatabaseActivityButton,
            UserActivityButton, QuickStatusButton);
    }
    
    private void SetupDigitalFormsTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopDigitalFormsTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(DigitalFormsDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(DigitalFormsMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(DigitalFormsTaskButton, ClientFactory.IsSupported<Kanban>() && Security.IsAllowed<CanViewTasks>());
        SetModuleVisibility<AttendancePanel>(DigitalFormsAttendanceButton, ClientFactory.IsSupported<TimeSheet>() && Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(DigitalFormsMapButton, bMaps);
        SetModuleVisibility<DailyReport>(DigitalFormsDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());

        SetModuleVisibility<DigitalFormsLibrary>(DigitalFormsFormsLibraryButton, ClientFactory.IsSupported<DigitalForm>()
                                                                           && Security.CanView<DigitalForm>()
                                                                           && Security.IsAllowed<CanAdministerDigitalFormsLibrary>());

        SetModuleVisibility<CompletedFormsPanel>(DigitalFormsCompletedFormsButton, Security.IsAllowed<CanViewDigitalFormsDashbaord>() && Security.IsAllowed<ViewDesktopDigitalFormsDashboard>());

        SetVisibleIfEither(DigitalFormsTaskSeparator,
            new FrameworkElement[]
            {
                DigitalFormsDashboardButton, DigitalFormsMessagesButton, DigitalFormsTaskButton, DigitalFormsAttendanceButton, DigitalFormsMapButton,
                DigitalFormsDailyReportButton
            }, new FrameworkElement[] { DigitalFormsFormsLibraryButton, DigitalFormsCompletedFormsButton });

        SetVisibleIfAny(DigitalFormsActions, DigitalFormsDashboardButton, DigitalFormsMessagesButton, DigitalFormsTaskButton,
            DigitalFormsAttendanceButton, DigitalFormsDailyReportButton, DigitalFormsFormsLibraryButton, DigitalFormsCompletedFormsButton);

        SetTabVisibleIfAny(DigitalFormsTab, DigitalFormsFormsLibraryButton, DigitalFormsCompletedFormsButton);

    }
    
    private void SetupEquipmentTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopEquipmentTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(EquipmentDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(EquipmentMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(EquipmentTaskButton, ClientFactory.IsSupported<Kanban>() && Security.IsAllowed<CanViewTasks>());
        SetModuleVisibility<AttendancePanel>(EquipmentAttendanceButton, ClientFactory.IsSupported<TimeSheet>() && Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(EquipmentMapButton, bMaps);
        SetModuleVisibility<DailyReport>(EquipmentDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());

        SetModuleVisibility<EquipmentPanel>(EquipmentButton, ClientFactory.IsSupported<Equipment>() 
                                                       && Security.CanView<Equipment>()
                                                       && Security.IsAllowed<ViewDesktopEquipmentListScreen>());
        
        SetModuleVisibility<EquipmentMaintenancePanel>(EquipmentMaintenanceButton,
            ClientFactory.IsSupported<Equipment>() 
            && Security.CanView<Equipment>()
            && Security.IsAllowed<ViewDesktopEquipmentMaintenanceScreen>() );

        SetModuleVisibility<EquipmentPlannerPanel>(EquipmentPlannerButton, 
            ClientFactory.IsSupported<Equipment>() 
            && Security.CanView<Equipment>()
            && ClientFactory.IsSupported<Assignment>() 
            && Security.CanView<Assignment>()
            && Security.IsAllowed<ViewDesktopEquipmentPlannerScreen>());


        SetVisibleIfEither(EquipmentTaskSeparator,
            new FrameworkElement[]
            {
                            EquipmentDashboardButton, EquipmentMessagesButton, EquipmentTaskButton, EquipmentAttendanceButton, EquipmentMapButton,
                            EquipmentDailyReportButton
            }, new FrameworkElement[] { EquipmentButton, EquipmentPlannerButton });
        
        SetVisibleIfAny(EquipmentActions, EquipmentDashboardButton, EquipmentMessagesButton, EquipmentTaskButton,
            EquipmentAttendanceButton, EquipmentDailyReportButton, EquipmentButton, EquipmentPlannerButton);

        SetModuleVisibility<GPSTrackers>(TrackersMasterList, Security.CanView<GPSTracker>() && Security.IsAllowed<ViewDesktopGPSTrackersScreen>());

        SetTabVisibleIfAny(EquipmentTab, EquipmentButton, TrackersMasterList);
    }

    private void SetupAccountsTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopAccountsTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(AccountsDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(AccountsMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(AccountsTaskButton, ClientFactory.IsSupported<Kanban>() && Security.IsAllowed<CanViewTasks>());
        SetModuleVisibility<AttendancePanel>(AccountsAttendanceButton, ClientFactory.IsSupported<TimeSheet>() && Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(AccountsMapButton, bMaps);
        SetModuleVisibility<DailyReport>(AccountsDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());

        SetModuleVisibility<CustomerPanel>(CustomerList, ClientFactory.IsSupported<Customer>() 
                                                   && Security.CanView<Customer>()
                                                   && Security.IsAllowed<ViewDesktopCustomersScreen>());

        SetModuleVisibility<InvoicePanel>(InvoiceList, ClientFactory.IsSupported<Invoice>() 
                                                 && Security.CanView<Invoice>()
                                                 && Security.IsAllowed<ViewDesktopInvoicesScreen>());

        SetModuleVisibility<CustomerReceipts>(ReceiptList, ClientFactory.IsSupported<Receipt>() 
                                                     && Security.CanView<Receipt>()
                                                     && Security.IsAllowed<ViewDesktopReceiptsScreen>());

        SetModuleVisibility<SupplierPanel>(SupplierList, ClientFactory.IsSupported<Supplier>() 
                                                   && Security.CanView<Supplier>()
                                                   && Security.IsAllowed<ViewDesktopSuppliersScreen>());

        SetModuleVisibility<DataEntryPanel>(AccountsDataButton, Security.IsAllowed<CanViewDataEntryPanel>());

        SetModuleVisibility<SupplierPurchaseOrderPanel>(PurchasesList, ClientFactory.IsSupported<PurchaseOrder>() 
                                                                 && Security.CanView<PurchaseOrder>()
                                                                 && Security.IsAllowed<ViewDesktopPurchaseOrdersScreen>());

        SetModuleVisibility<SupplierBillPanel>(BillsList, ClientFactory.IsSupported<Bill>() 
                                                    && Security.CanView<Bill>()
                                                    && Security.IsAllowed<ViewDesktopBillsScreen>());

        SetModuleVisibility<SupplierPayments>(PaymentsList, ClientFactory.IsSupported<Payment>() 
                                                      && Security.CanView<Payment>()
                                                      && Security.IsAllowed<ViewDesktopPaymentsScreen>());

        SetVisibleIfEither(AccountsTaskSeparator1,
            new FrameworkElement[]
            {
                            AccountsDashboardButton, AccountsMessagesButton, AccountsTaskButton, AccountsAttendanceButton, AccountsMapButton,
                            AccountsDailyReportButton
            }, new FrameworkElement[] { CustomerList, InvoiceList, ReceiptList });
        SetVisibleIfEither(AccountsTaskSeparator2, new FrameworkElement[] { CustomerList, InvoiceList, ReceiptList },
            new FrameworkElement[] { SupplierList, AccountsDataButton, PurchasesList, BillsList, PaymentsList });
        SetVisibleIfAny(AccountsActions, AccountsDashboardButton, AccountsMessagesButton, AccountsTaskButton,
            AccountsAttendanceButton,
            AccountsDailyReportButton, CustomerList, InvoiceList, ReceiptList, SupplierList, PurchasesList, BillsList, PaymentsList);

        SetTabVisibleIfAny(AccountsTab, CustomerList, InvoiceList, ReceiptList, SupplierList, AccountsDataButton, PurchasesList, BillsList, PaymentsList);
    }

    private void SetupHumanResourcesTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopHumanResourcesTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(HumanResourcesDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(HumanResourcesMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(HumanResourcesTaskButton, ClientFactory.IsSupported<Kanban>() && Security.IsAllowed<CanViewTasks>());
        SetModuleVisibility<AttendancePanel>(HumanResourcesAttendanceButton,
            ClientFactory.IsSupported<TimeSheet>() && Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(HumanResourcesMapButton, bMaps);
        SetModuleVisibility<DailyReport>(HumanResourcesDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());

        SetModuleVisibility<CalendarPanel>(CalendarButton, Security.CanView<Assignment>() && Security.IsAllowed<ViewDesktopCalendarScreen>());
        SetModuleVisibility<EmployeeResourcePlannerPanel>(EmployeePlannerButton, Security.CanView<Assignment>() && Security.IsAllowed<ViewDesktopEmployeePlannerScreen>());
        SetModuleVisibility<TimesheetPanel>(TimesheetsButton, Security.CanView<TimeSheet>() && Security.IsAllowed<ViewDesktopStaffTimeSheetsScreen>());
        SetModuleVisibility<LeaveRequestPanel>(LeaveRequestsButton, Security.CanView<LeaveRequest>() && Security.IsAllowed<ViewDesktopLeaveRequestsScreen>());
        SetModuleVisibility<OrgChartPanel>(OrgChartButton,
            ClientFactory.IsSupported<Employee>()
            && 
            Security.IsAllowed<ViewDesktopOrgChartScreen>()
        );
        SetModuleVisibility<MeetingPanel>(MeetingsButton, Security.IsAllowed<ViewDesktopMeetingsScreen>());

        SetVisibleIfEither(HumanResourcesTaskSeparator,
            new FrameworkElement[]
            {
                            HumanResourcesDashboardButton, HumanResourcesMessagesButton, HumanResourcesTaskButton, HumanResourcesAttendanceButton,
                            HumanResourcesMapButton, HumanResourcesDailyReportButton
            }, new FrameworkElement[] { CalendarButton, EmployeePlannerButton, TimesheetsButton, LeaveRequestsButton, OrgChartButton });
        SetVisibleIfAny(HumanResourcesActions, HumanResourcesDashboardButton, HumanResourcesTaskButton,
            HumanResourcesAttendanceButton,
            HumanResourcesDailyReportButton, CalendarButton, EmployeePlannerButton, TimesheetsButton, LeaveRequestsButton, OrgChartButton);

        SetModuleVisibility<UserPanel>(UsersButton, Security.CanView<User>() && Security.IsAllowed<ViewDesktopUserAccountsScreen>());
        SetModuleVisibility<EmployeePanel>(EmployeesButton, Security.CanView<Employee>() && Security.IsAllowed<ViewDesktopEmployeeListScreen>());

        SetVisibleIfEither(HumanResourcesSetupSeparator1,
            new FrameworkElement[] { CalendarButton, TimesheetsButton, LeaveRequestsButton, OrgChartButton },
            new FrameworkElement[] { UsersButton, EmployeesButton });

        SetTabVisibleIfAny(HumanResourcesTab, CalendarButton, TimesheetsButton, LeaveRequestsButton, OrgChartButton, UsersButton, EmployeesButton);
    }

    private void SetupProductsTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopProductManagementTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(ProductsDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(ProductsMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(ProductsTaskButton, Security.CanView<Kanban>());
        SetModuleVisibility<AttendancePanel>(ProductsAttendanceButton, Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(ProductsMapButton, bMaps);
        SetModuleVisibility<DailyReport>(ProductsDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());

        SetModuleVisibility<ProductsPanel>(ProductsMasterList, Security.CanView<Product>() && Security.IsAllowed<ViewDesktopProductListScreen>());
        SetModuleVisibility<StockLocationPanel>(StockLocationList, Security.CanView<StockLocation>() && Security.IsAllowed<ViewDesktopStockLocationsScreen>());
        SetModuleVisibility<StockMovementPanel>(StockMovementList, Security.CanView<StockMovement>() && Security.IsAllowed<ViewDesktopStockMovementsScreen>());
        SetModuleVisibility<StockForecastPanel>(StockForecastButton, Security.CanView<Product>()
                                                                     && Security.CanView<JobMaterial>()
                                                                     && Security.IsAllowed<ViewDesktopStockForecastScreen>());
        SetModuleVisibility<ReservationManagementPanel>(ReservationManagementButton, Security.IsAllowed<ViewDesktopReservationManagementScreen>());

        SetVisibleIfEither(ProductsTaskSeparator,
            new FrameworkElement[]
            {
                            ProductsDashboardButton, ProductsMessagesButton, ProductsTaskButton, ProductsAttendanceButton, ProductsMapButton,
                            ProductsDailyReportButton
            }, new FrameworkElement[] { ProductsMasterList, StockLocationList, StockMovementList, StockForecastButton });

        SetVisibleIfAny(ProductActions, ProductsMasterList, StockLocationList, StockMovementList, StockForecastButton);

        SetTabVisibleIfAny(ProductTab, ProductActions);
    }

    private void SetupLogisticsTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopLogisticsTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(LogisticsDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(LogisticsMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(LogisticsTaskButton, ClientFactory.IsSupported<Kanban>() && Security.IsAllowed<CanViewTasks>());
        SetModuleVisibility<AttendancePanel>(LogisticsAttendanceButton, ClientFactory.IsSupported<TimeSheet>() && Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(LogisticsMapButton, bMaps);
        SetModuleVisibility<DailyReport>(LogisticsDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());

        SetModuleVisibility<ReadyToGoPanel>(ReadyToGoItemsButton,
            ClientFactory.IsSupported<DeliveryItem>()
            && Security.IsAllowed<CanViewLogisticsReadyToGo>()
            && Security.IsAllowed<ViewDesktopReadyToGoScreen>());

        SetModuleVisibility<DispatchPanel>(DispatchButton, Security.CanView<Shipment>()
                                                           && Security.CanView<DeliveryItem>()
                                                           && Security.IsAllowed<ViewDesktopRackListScreen>());

        SetModuleVisibility<RequisitionPanel>(RequisitionsButton, Security.CanView<Requisition>() && Security.IsAllowed<ViewDesktopSiteRequisitionsScreen>());

        SetModuleVisibility<DeliveryPanel>(DeliveriesButton, Security.IsAllowed<CanViewDeliveriesModule>() && Security.IsAllowed<ViewDesktopDeliveriesScren>());

        SetModuleVisibility<DeliveredOnSitePanel>(DeliveredItemsButton,
            ClientFactory.IsSupported<DeliveryItem>()
            && Security.IsAllowed<CanViewDeliveredOnSite>()
            && Security.IsAllowed<ViewDesktopDeliveredOnSiteScreen>());

        SetModuleVisibility<ConsignmentsPanel>(ConsignmentButton, Security.CanView<Consignment>() && Security.IsAllowed<ViewDesktopIncomingConsignmentsScreen>());

        SetVisibleIfEither(LogisticsTaskSeparator1,
            new FrameworkElement[]
            {
                            LogisticsDashboardButton, LogisticsMessagesButton, LogisticsTaskButton, LogisticsAttendanceButton, LogisticsMapButton,
                            LogisticsDailyReportButton
            },
            new FrameworkElement[]
                { ReadyToGoItemsButton, DispatchButton, RequisitionsButton, DeliveriesButton, DeliveredItemsButton });
        SetVisibleIfEither(LogisticsTaskSeparator2,
            new FrameworkElement[]
                { ReadyToGoItemsButton, DispatchButton, RequisitionsButton, DeliveriesButton, DeliveredItemsButton },
            new FrameworkElement[] { ConsignmentButton });

        SetTabVisibleIfAny(LogisticsTab, DispatchButton, RequisitionsButton, DeliveriesButton, ReadyToGoItemsButton,
            DeliveredItemsButton,
            ConsignmentButton);
    }

    private void SetupManufacturingTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopManufacturingTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(ManufacturingDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(ManufacturingMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(ManufacturingTaskButton, ClientFactory.IsSupported<Kanban>() && Security.IsAllowed<CanViewTasks>());
        SetModuleVisibility<AttendancePanel>(ManufacturingAttendanceButton,
            ClientFactory.IsSupported<TimeSheet>() && Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(ManufacturingMapButton, bMaps);
        SetModuleVisibility<DailyReport>(ManufacturingDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());
        
        SetVisibleIfAny(ManufacturingTaskSeparator,
            new FrameworkElement[]
            {
                ManufacturingDashboardButton, ManufacturingMessagesButton, ManufacturingTaskButton, ManufacturingAttendanceButton,
                ManufacturingMapButton, ManufacturingDailyReportButton
            });
        
        SetModuleVisibility<StagingPanel>(DesignManagementButton, Security.CanView<Job>() && Security.IsAllowed<ViewDesktopDesignManagementScreen>());
        SetFrameworkItemVisibility(ManufacturingDesignSeparator, Security.CanView<Job>() && Security.IsAllowed<ViewDesktopDesignManagementScreen>());
        
        SetModuleVisibility<ManufacturingPanel>(FactoryStatusButton,
            ClientFactory.IsSupported<ManufacturingFactory, ManufacturingPacket>()
            && Security.IsAllowed<CanViewFactoryStatus>()
            && Security.IsAllowed<ViewDesktopManufacturingStatusScreen>());

        SetModuleVisibility<ManufacturingAllocationPanel>(FactoryAllocationButton,
            ClientFactory.IsSupported<ManufacturingFactory, ManufacturingPacket, ManufacturingPacketStage>()
            && Security.IsAllowed<CanViewFactoryAllocation>()
            && Security.IsAllowed<ViewDesktopFactoryAllocationScreen>());

        //SetModuleVisibility<>(FactoryScheduleButton, ClientFactory.IsSupported<Booking>() && ClientFactory.IsEnabled<>());
        SetModuleVisibility<FactoryPanel>(FactoryFloorButton,
            ClientFactory.IsSupported<ManufacturingPacket>()
            && Security.IsAllowed<CanViewFactoryFloor>()
            && Security.IsAllowed<ViewDesktopFactoryFloorScreen>());
        //SetModuleVisibility<>(FactoryReadyButton, ClientFactory.IsSupported<ManufacturingPacket>() && Security.IsAllowed<CanViewFactoryReadyToGo>());
        
        SetVisibleIfAny(ManufacturingActionSeparator,
            new FrameworkElement[]
            {
                FactoryStatusButton, FactoryAllocationButton, FactoryFloorButton
            });
        
        
        SetVisibleIfAny(ManufacturingActions, ManufacturingDashboardButton, ManufacturingMessagesButton, ManufacturingTaskButton,
            ManufacturingAttendanceButton, ManufacturingDailyReportButton, FactoryStatusButton, FactoryAllocationButton,
            FactoryFloorButton);

        SetTabVisibleIfAny(ManufacturingTab, FactoryStatusButton, FactoryAllocationButton, FactoryFloorButton);
    }

    private void SetupProjectsTab(bool bMaps)
    {
        if (!Security.IsAllowed<ViewDesktopProjectsTab>())
            return;

        SetModuleVisibility<UtilityDashboard>(ProjectsDashboardButton, Security.IsAllowed<CanViewUserDefinedDashboards>());

        SetModuleVisibility<NotificationPanel>(ProjectMessagesButton, Security.CanView<Notification>());
        SetModuleVisibility<TaskPanel>(ProjectTaskButton, ClientFactory.IsSupported<Kanban>() && Security.IsAllowed<CanViewTasks>());
        SetModuleVisibility<AttendancePanel>(ProjectAttendanceButton, ClientFactory.IsSupported<TimeSheet>() && Security.IsAllowed<CanViewInOutBoard>());
        SetModuleVisibility<MapsPanel>(ProjectsMapButton, bMaps);
        SetModuleVisibility<DailyReport>(ProjectDailyReportButton,
            ClientFactory.IsSupported<TimeSheet, Assignment>() && Security.IsAllowed<CanViewDailyReports>());

        SetModuleVisibility<ProjectsPanel>(ProjectsButton, Security.CanView<Job>() && Security.IsAllowed<ViewDesktopProjectsScreen>());
        //SetModuleVisibility<>(ServiceButton, Security.CanView<Job>() && Security.IsAllowed<ViewDesktopServiceScreen>());
        SetModuleVisibility<JobResourcePlannerPanel>(ProjectPlannerButton, Security.CanView<Job>() && Security.IsAllowed<ViewDesktopProjectPlannerScreen>());
        
        SetVisibleIfEither(ProjectTaskSeparator,
            new FrameworkElement[]
            {
                            ProjectsDashboardButton, ProjectMessagesButton, ProjectTaskButton, ProjectAttendanceButton, ProjectsMapButton,
                            ProjectDailyReportButton
            }, new FrameworkElement[] { QuotesButton, ProjectsButton, ProjectPlannerButton });
        
        SetModuleVisibility<QuotePanel>(QuotesButton, Security.CanView<Quote>() && Security.IsAllowed<ViewDesktopQuotesScreen>());
        SetModuleVisibility<KitPanel>(KitsMasterList, Security.CanView<Kit>() && Security.IsAllowed<ViewDesktopProductKitsScreen>());
        SetModuleVisibility<CostSheetPanel>(CostSheetsMasterList, Security.CanView<CostSheet>() && Security.IsAllowed<ViewDesktopCostSheetsScreen>());
        SetVisibleIfAny(ProjectsSetup, KitsMasterList, CostSheetsMasterList);


        //ProjectsActions.IsLauncherButtonVisible = Security.IsAllowed<CanCustomiseModules>();
        //ProjectReports.IsLauncherButtonVisible = Security.IsAllowed<CanDesignReports>();

        SetTabVisibleIfAny(ProjectsTab, QuotesButton, ProjectsButton, ProjectPlannerButton, CostSheetsMasterList, KitsMasterList);
    }
    
    private void SetupDock<TSecurityDescriptor>(LayoutAnchorable layout, IDockPanel dock)
        where TSecurityDescriptor : ISecurityDescriptor, new()
    {
        if (Security.IsAllowed<TSecurityDescriptor>())
        {
            if (!DockGroup.Children.Any(x => x == layout))
            {
                DockGroup.Children.Add(layout);
            }
            if (layout.IsVisible && (ClientFactory.UserGuid != Guid.Empty))
                dock.Setup();
        }
        else
        {
            DockGroup.RemoveChild(layout);
        }
    }



    private void LoadApplicationState()
    {
        if (ClientFactory.UserGuid != Guid.Empty)
        {
            _ribbon.IsCollapsed = false;

            if (OutstandingDailyReports(false))
            {
                MessageWindow.ShowMessage("There are outstanding Daily Reports that must be filled out before continuing!"
                    + "\n\nAccess to PRS is restricted until this is corrected.",
                    "Outstanding Reports");

                var dailyReportPanel = LoadWindow<DailyReport>(ProjectDailyReportButton);
                if(dailyReportPanel is not null)
                {
                    dailyReportPanel.OnTimeSheetConfirmed += e =>
                    {
                        if (!OutstandingDailyReports(true))
                        {
                            ConfigureMainScreen(null);
                            LoadApplicationState();
                        }
                    };
                }
                return;
            }

            using (new WaitCursor())
            {
                _ribbon.IsCollapsed = false;

                LoadInitialWindow();
            }
        }
    }

    private void LoadInitialWindow()
    {
        var app = new LocalConfiguration<AppSettings>().Load();
        var module = app.Settings.ContainsKey("CurrentPanel")
            ? !string.IsNullOrWhiteSpace(app.Settings["CurrentPanel"])
                ? app.Settings["CurrentPanel"].Split([" / "], StringSplitOptions.None)
                : [ "Human Resources", "Task List"]
            : [ "Human Resources", "Task List"];
        

        try
        {
            var bFound = false;
            if (module.Length == 2)
                foreach (Fluent.RibbonTabItem tab in _ribbon.Tabs)
                {
                    if (String.Equals(tab.Header, module.First()))
                    {
                        _ribbon.SelectedTabItem = tab;
                        foreach (Fluent.RibbonGroupBox bar in tab.Groups)
                        {
                            foreach (var item in bar.Items)
                            {
                                var button = item as Fluent.Button;
                                if (button != null && String.Equals(button.Header, module.Last()))
                                {
                                    bFound = true;
                                    if (button.Command is SimpleCommand command)
                                        command.Execute(null);
                                    //button.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
                                    break;
                                }
                            }

                            if (bFound)
                                break;
                        }
                    }

                    if (bFound)
                        break;
                }
        }
        catch (Exception e)
        {
            MessageWindow.ShowError($"Unable to load {app.Settings["CurrentPanel"]}", e);
        }

    }

    private void _ribbon_OnLoaded(object sender, RoutedEventArgs e)
    {
        _ribbon.SelectedTabItem = CurrentTab;
    }

    private void LoadSecondaryWindows()
    {
        if (ClientFactory.UserGuid != Guid.Empty)
        {
            var windows = App.DatabaseSettings.SecondaryWindows;
            foreach (var key in windows.Keys.ToArray())
            {
                SecondaryWindows[key] = new SecondaryWindow(
                    key,
                    windows[key].Item1,
                    windows[key].Item2,
                    windows[key].Item3,
                    windows[key].Item4,
                    windows[key].Item5,
                    windows[key].Item6
                );
                SecondaryWindows[key].Closed += (o, e) => { SecondaryWindows.Remove(key); };
                SecondaryWindows[key].Show();
            }
        }
        else
        {
            foreach (var key in SecondaryWindows.Keys.ToArray())
            {
                App.IsClosing = true;
                SecondaryWindows[key].Close();
                App.IsClosing = false;
            }
        }
    }

    private Fluent.RibbonTabItem GetTabItem(FrameworkElement? sender)
    {
        if (sender == null)
            throw new Exception("No Tab Found!");
        if (sender is Fluent.RibbonTabItem)
            return (Fluent.RibbonTabItem)sender;
        return GetTabItem(sender.Parent as FrameworkElement);
    }

    private IEnumerable<IBasePanel> Panels
    {
        get
        {
            if(PanelHost.CurrentPanel is not null)
            {
                yield return PanelHost.CurrentPanel;
            }
            foreach(var window in SecondaryWindows.Values)
            {
                yield return window.Panel;
            }
        }
    }
    
    #region LoadWindow / LoadSecondaryWindow

    private T? LoadWindow<T>(Fluent.Button sender) where T : class, IBasePanel, new()
    {
        return LoadWindow<T>(sender, new CancelEventArgs());
    }

    public IBasePanel? LoadWindow(Type t, Fluent.Button sender, CancelEventArgs cancel)
    {
        using (new WaitCursor())
        {
            UnloadWindow(cancel);
            if (cancel.Cancel)
            {
                return null;
            }

            CurrentTab = GetTabItem(sender);
            CurrentButton = sender;
            //CurrentButton.IsSelected = true;
            UpdateRibbonColors();

            var moduleName = sender.Header?.ToString() ?? "";

            var panel = PanelHost.LoadPanel(t, moduleName);

            ContentControl.Content = panel;

            Title =
                $"{moduleName} - {(String.Equals(App.Profile?.ToUpper(), "DEFAULT") ? "PRS Desktop" : App.Profile)} (Release {CoreUtils.GetVersion()})";


            PanelHost.Refresh();

            if (panel is NotificationPanel)
            {
                Logger.Send(LogType.Information, ClientFactory.UserID, "Disabling Heartbeat");
                NotificationsWatchDog.IsEnabled = false;
                Notifications.Visibility = Visibility.Collapsed;
                DockingGrid.ColumnDefinitions[1].Width = new GridLength(0, GridUnitType.Pixel);
                DockingGrid.ColumnDefinitions[2].Width = new GridLength(0, GridUnitType.Pixel);
            }
            else
            {
                ReloadNotifications();
            }

            if (sender != null)
            {
                var settings = new LocalConfiguration<AppSettings>().Load();
                var module = string.Format("{0} / {1}", CurrentTab?.Header, sender.Header);
                if (!settings.Settings.ContainsKey("CurrentPanel") || module != settings.Settings["CurrentPanel"])
                {
                    settings.Settings["CurrentPanel"] = module;
                    try
                    {
                        new LocalConfiguration<AppSettings>().Save(settings);
                    }
                    catch (Exception e)
                    {
                        Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
                    }
                }

            }

            return panel;
        }
    }
    
    private T? LoadWindow<T>(Fluent.Button sender, CancelEventArgs cancel) where T : class, IBasePanel, new()
    {
        return LoadWindow(typeof(T), sender, cancel) as T;
    }

    private void LoadSecondaryWindow(Type t, Fluent.Button sender)
    {
        var id = Guid.NewGuid();
        var window = new Tuple<string, string, double, double, double, double>(
            t.EntityName(),
            sender.Header?.ToString() ?? "",
            Left + 100,
            Top + 100,
            Width - 200,
            Height - 200
        );
        App.DatabaseSettings.SecondaryWindows[id] = window;
        new LocalConfiguration<DatabaseSettings>(App.Profile).Save(App.DatabaseSettings);
        SecondaryWindows[id] = new SecondaryWindow(
            id,
            window.Item1,
            window.Item2,
            window.Item3,
            window.Item4,
            window.Item5,
            window.Item6
        );
        SecondaryWindows[id].Show();
    }
    
    private void LoadSecondaryWindow<T>(Fluent.Button sender) where T : class, IBasePanel, new() 
        => LoadSecondaryWindow(typeof(T), sender);
    
    // private void SecondaryWindow_Click(object sender, RoutedEventArgs e)
    // {
    //     var panel = PanelHost.CurrentPanel;
    //     if (panel is null) return;
    //
    //     var id = Guid.NewGuid();
    //     var window = new Tuple<string, string, double, double, double, double>(
    //         panel.GetType().EntityName(),
    //         PanelHost.CurrentModuleName,
    //         Left + 100,
    //         Top + 100,
    //         Width - 200,
    //         Height - 200
    //     );
    //     App.DatabaseSettings.SecondaryWindows[id] = window;
    //     new LocalConfiguration<DatabaseSettings>(App.Profile).Save(App.DatabaseSettings);
    //     SecondaryWindows[id] = new SecondaryWindow(
    //         id,
    //         window.Item1,
    //         window.Item2,
    //         window.Item3,
    //         window.Item4,
    //         window.Item5,
    //         window.Item6
    //     );
    //     SecondaryWindows[id].Show();
    // }
    
    #endregion

    private void UpdateRibbonColors()
    {
        foreach (var tab in _ribbon.Tabs)
        {
            bool bFound = false;
            foreach (var grp in tab.Groups)
            {
                foreach (var btn in grp.Items)
                {
                    if (btn is Fluent.Button fluentbutton)
                    {
                        bFound = bFound || (btn == CurrentButton);
                        fluentbutton.Background = (btn == CurrentButton) ? ThemeManager.SelectedTabItemBackgroundBrush : new SolidColorBrush(Colors.White);
                        fluentbutton.Foreground = (btn == CurrentButton) ? ThemeManager.SelectedTabItemForegroundBrush : new SolidColorBrush(Colors.Black);
                    }
                }

                tab.Background = bFound ? ThemeManager.SelectedTabItemBackgroundBrush : new SolidColorBrush(Colors.White);
                tab.Foreground = bFound ? ThemeManager.SelectedTabItemForegroundBrush : new SolidColorBrush(Colors.Black);

            }
        }
    }

    private static void StartLocalDatabase(IProgress<string> progress)
    {
        var dirName = Path.GetDirectoryName(App.DatabaseSettings.FileName);
        if (!Directory.Exists(dirName) && dirName != null)
            Directory.CreateDirectory(dirName);

        var FileName = App.DatabaseSettings.FileName;

        var Exists = File.Exists(FileName);

        progress.Report("Configuring Stores");
        DbFactory.Stores = CoreUtils.TypeList(
            new[]
            {
                typeof(Store<>).Assembly,
                typeof(EquipmentStore).Assembly
            },
            myType =>
                myType.IsClass
                && !myType.IsAbstract
                && !myType.IsGenericType
                && myType.GetInterfaces().Contains(typeof(IStore))
        ).ToArray();
        DbFactory.DefaultStore = typeof(BaseStore<>);

        DbFactory.ProviderFactory = new SQLiteProviderFactory(App.DatabaseSettings.FileName);
        DbFactory.ColorScheme = App.DatabaseSettings.ColorScheme;
        DbFactory.Logo = App.DatabaseSettings.Logo;

        progress.Report("Starting Local Database");
        DbFactory.Start();

        ClientFactory.DatabaseID = DbFactory.ID;

        progress.Report("Checking Database");

        var users = DbFactory.NewProvider(Logger.Main).Load<User>();
        if (!users.Any())
        {
            var user = new User { UserID = "ADMIN", Password = "admin" };
            DbFactory.NewProvider(Logger.Main).Save(user);

            var employee = DbFactory.NewProvider(Logger.Main).Load(new Filter<Employee>(x => x.Code).IsEqualTo("ADMIN")).FirstOrDefault();
            employee ??= new Employee { Code = "ADMIN", Name = "Administrator Account" };
            employee.UserLink.ID = user.ID;
            DbFactory.NewProvider(Logger.Main).Save(employee);
        }

        StoreUtils.GoogleAPIKey = App.DatabaseSettings.GoogleAPIKey;
        Job.JobNumberPrefix = App.DatabaseSettings.JobPrefix;
        PurchaseOrder.PONumberPrefix = App.DatabaseSettings.PurchaseOrderPrefix;
    }

    #endregion

    #region Login Management

    private ValidationStatus? TryAutoLogin()
    {
        ValidationStatus? result = null;
        if (App.DatabaseSettings.LoginType == LoginType.UserID)
        {
            try
            {
                result = ClientFactory.Validate(App.DatabaseSettings.UserID, App.DatabaseSettings.Password);
            }
            catch (Exception e)
            {
                MessageWindow.ShowError("Error connecting to server.\nPlease check the server URL and port number.", e);
                result = null;
            }
            if (result == ValidationStatus.INVALID)
            {
                MessageWindow.ShowMessage("Unable to Login with User ID: " + App.DatabaseSettings.UserID, "Login failed");
            }
        }
        return result;
    }

    private ValidationStatus? DoLogin()
    {
        ValidationStatus? result = null;
        if (result != ValidationStatus.VALID)
        {
            var login = new PinLogin(CoreUtils.GetVersion(), result ?? ValidationStatus.INVALID);
            if (login.ShowDialog() == true)
            {
                result = ValidationStatus.VALID;
            }
        }

        return result ?? ValidationStatus.INVALID;
    }

    /// <summary>
    /// To be called after <see cref="DoLogin(bool)"/> and if a valid login session exists. Configures the main screen and loads the windows.
    /// </summary>
    /// <param name="progress">If not <see langword="null"/>, then rather than opening a new progress window, just uses that.</param>
    private void AfterLogin(IProgress<string>? progress)
    {
        Logger.Send(LogType.Information, "", "Checking Support Ticket Status");
        CheckSupportTicketStatus();
        
        Logger.Send(LogType.Information, "", "Loading employee");
        LoadCurrentEmployee();
        if (CheckTimesheetBypass(true))
        {
            UpdateCurrentLogin();
        }
        else
        {
            Dispatcher.Invoke(() =>
            {
                MessageWindow.ShowMessage("You must clock on before logging in to PRS!", "Not clocked in.");
            });
            ClientFactory.InvalidateUser();
            App.EmployeeID = Guid.Empty;
            App.EmployeeName = "";
            App.EmployeeCode = "";
            App.EmployeeEmail = "";
        }

        Logger.Send(LogType.Information, "", "Setting colours");
        if(progress is null)
        {
            ApplyColorScheme();
        }
        else
        {
            Dispatcher.Invoke(ApplyColorScheme);
        }

        Logger.Send(LogType.Information, "", "Configuring main window");
        ConfigureMainScreen(progress);

        Logger.Send(LogType.Information, "", "Loading current window");
        if(progress is null)
        {
            LoadApplicationState();
        }
        else
        {
            Dispatcher.Invoke(LoadApplicationState);
        }

        Logger.Send(LogType.Information, "", "Loading secondary window");
        if(progress is null)
        {
            LoadSecondaryWindows();
        }
        else
        {
            Dispatcher.Invoke(LoadSecondaryWindows);
        }

        //if (_ribbon.Menu.IsVisible)
        //{
        //    _ribbon.;
        //}
    }

    /// <summary>
    /// Creates a new <see cref="Login"/> if one does not already exist. Otherwise, updates the <see cref="Login"/> entry in the database with new Station ID.
    /// </summary>
    private void UpdateCurrentLogin()
    {
        if (CoreUtils.GetVersion().Equals("???"))
            return;

        // Register this station with the Server
        // Later on, the heartbeat will check to make sure 
        // that the StationID hasn't changed.  If it has,
        // then we've logged in somewhere else and we'll
        // drop out of this station
        var curr = new Client<Login>().Query(
            new Filter<Login>(x => x.User.ID).IsEqualTo(ClientFactory.UserGuid),
            null
        ).Rows.FirstOrDefault();
        if (curr != null)
        {
            var c = curr.ToObject<Login>();
            c.StationID = station.StationID;
            station = c;
        }
        else
        {
            station.User.ID = ClientFactory.UserGuid;
            station.TimeStamp = DateTime.Now;
        }

        new Client<Login>().Save(station, "", (o, e) => { });
    }

    private void LoadCurrentEmployee()
    {
        var me = new Client<Employee>().Query(
            new Filter<Employee>(x => x.UserLink.ID).IsEqualTo(ClientFactory.UserGuid),
            Columns.None<Employee>().Add(x => x.ID).Add(x => x.Email).Add(x => x.Name)
        );
        App.EmployeeID = me.Rows.FirstOrDefault()?.Get<Employee, Guid>(x => x.ID) ?? Guid.Empty;
        App.EmployeeName = me.Rows.FirstOrDefault()?.Get<Employee, String>(x => x.Name) ?? "";
        App.EmployeeCode = me.Rows.FirstOrDefault()?.Get<Employee, String>(x => x.Code) ?? "";
        App.EmployeeEmail = me.Rows.FirstOrDefault()?.Get<Employee, String>(x => x.Email) ?? "";
    }

    private void ExecuteLogout()
    {
        new Client<Login>().Delete(station, "");
        station.ID = Guid.Empty;
        App.EmployeeID = Guid.Empty;
        App.EmployeeName = "";
        App.EmployeeEmail = "";
    }

    /// <summary>
    /// Logs the user out and unloads windows
    /// </summary>
    /// <param name="message">A message to display as the reason for logging out, or <c>null</c> for no message.</param>
    private bool Logout(string? message = null, bool force = false)
    {
        // I really don't like all these try-catch blocks; unfortunately, if we are trying to log out and invalidate due to an unauthenticated user,
        // all the queries that get called here will throw exceptions and thus break our system, failing to log out.
        try
        {
            FinalizeAutoTimesheet();
        }
        catch
        {
            if (!force) throw;
        }

        // Try to unload the window;
        try
        {
            UnloadWindow(null);
            if (DatabaseType == DatabaseType.Standalone && !CoreUtils.GetVersion().Equals("???"))
                scheduler.Stop();
        }
        catch
        {
            if (!force) throw;
        }

        // Next, try to set things to being empty
        try
        {
            if (!CoreUtils.GetVersion().Equals("???"))
                if (station.ID != Guid.Empty)
                {
                    ExecuteLogout();
                }
            ClearTrackingKanban();
        }
        catch
        {
            if (!force) throw;
        }

        ClientFactory.InvalidateUser();
        ConfigureMainScreen(null);
        LoadSecondaryWindows();

        if (message != null)
        {
            MessageWindow.ShowMessage(message, "Logged out");
        }

        if (DoLogin() == ValidationStatus.VALID)
        {
            AfterLogin(null);
        }

        return true;
    }



    #endregion

    #region Timesheets

    private void RefreshTimeSheets()
    {
        if (App.EmployeeID == Guid.Empty)
            return;

        var filter = new Filter<TimeSheet>(x => x.EmployeeLink.ID).IsEqualTo(App.EmployeeID);
        filter = filter.And(new Filter<TimeSheet>(x => x.Confirmed).IsEqualTo(DateTime.MinValue).Or(x => x.Date).IsEqualTo(DateTime.Today));

        _timesheets = new Client<TimeSheet>().Query(
            filter,
            Columns.None<TimeSheet>().Add(
                x => x.ID,
                x => x.Date,
                x => x.Finish
            )
        );
    }
    private CoreTable GetTimesheet()
    {
        return new Client<TimeSheet>().Query(
            new Filter<TimeSheet>(x => x.Date).IsEqualTo(DateTime.Today)
                .And(x => x.EmployeeLink.ID).IsEqualTo(App.EmployeeID)
                .And(x => x.Finish).IsEqualTo(TimeSpan.Zero)
        );
    }
    private bool CheckTimesheetBypass(bool message)
    {
        if (!ClientFactory.IsSupported<TimeSheet>())
            return true;

        var isClockedOn = IsClockedOn();

        if (!Security.IsAllowed<CanBypassTimeBench>())
        {
            if (!isClockedOn)
            {
                return false;
            }

            return true;
        }

        if (Security.IsAllowed<AutoGenerateTimesheet>())
            if (!isClockedOn)
            {
                var ts = new TimeSheet();
                ts.Date = DateTime.Today;
                ts.Start = DateTime.Now.TimeOfDay;
                ts.EmployeeLink.ID = App.EmployeeID;
                ts.Notes = "Automatic Login from PRS Desktop";
                new Client<TimeSheet>().Save(ts, "AutoLogon because Timebench Bypass is enabled", (o, e) => { });
            }

        return true;
    }
    private bool IsClockedOn()
    {
        RefreshTimeSheets();

        if (_timesheets == null)
            return false;

        return _timesheets.Rows.Any(r =>
            r.Get<TimeSheet, DateTime>(c => c.Date).Date == DateTime.Today && r.Get<TimeSheet, TimeSpan>(c => c.Finish) == new TimeSpan());
    }

    private void FinalizeAutoTimesheet()
    {
        if (Security.IsAllowed<AutoGenerateTimesheet>())
        {
            var check = new Client<TimeSheet>().Query(
                new Filter<TimeSheet>(x => x.Date).IsEqualTo(DateTime.Today).And(x => x.EmployeeLink.ID).IsEqualTo(App.EmployeeID).And(x => x.Finish)
                    .IsEqualTo(TimeSpan.Zero)
            );
            if (check.Rows.Any())
            {
                var ts = check.Rows.First().ToObject<TimeSheet>();
                if (DateTime.Now.TimeOfDay < ts.Start.Add(new TimeSpan(0, 2, 0)))
                {
                    new Client<TimeSheet>().Delete(ts, "Deleting Auto TimeSheet because TimeBench Bypass is enabled", (o, ex) => { });
                }
                else
                {
                    ts.Finish = DateTime.Now.TimeOfDay;
                    new Client<TimeSheet>().Save(ts, "Clocking off Auto Timesheet because Timesheet Bypass is enabled", (o, ex) => { });
                }
            }
        }
    }


    #endregion

    private string CurrentPanelSlug()
    {
        var app = new LocalConfiguration<AppSettings>().Load();
        var module = app.Settings["CurrentPanel"].Split(new[] { " / " }, StringSplitOptions.None);
        return module.LastOrDefault()?.Replace(" ", "_").Replace("/", "") ?? "";
    }

    private bool ShowHelp()
    {
        Process.Start(new ProcessStartInfo("https://prsdigital.com.au/wiki/index.php/" + CurrentPanelSlug()) { UseShellExecute = true });
        return true;
    }

    private void Wiki_Click(object sender, RoutedEventArgs e)
    {
        ShowHelp();
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
    }
    private void UnloadWindow(CancelEventArgs? cancel)
    {
        PanelHost.UnloadPanel(cancel);
        if (cancel?.Cancel == true)
        {
            return;
        }
        Title =
            $" - {(String.Equals(App.Profile?.ToUpper(), "DEFAULT") ? "PRS Desktop" : App.Profile)} (Release {CoreUtils.GetVersion()})";

        if (CurrentTab is not null)
        {
            var border = VisualUtils.EnumChildrenOfType(CurrentTab, typeof(Border)).LastOrDefault();
            if (border != null)
            {
                ((Border)border).Background = new SolidColorBrush(Colors.Transparent);
                ((Border)border).BorderBrush = new SolidColorBrush(Colors.Transparent);
            }

            var ReportsBar = FindRibbonBar(CurrentTab, x => x.Header.Equals("Print"));
            if (ReportsBar is not null)
            {
                ReportsBar.Items.Clear();
                ReportsBar.Visibility = Visibility.Collapsed;
                ReportsBar.IsLauncherVisible = false;
            }

            var ActionBar = FindRibbonBar(CurrentTab, x => x.Header.Equals("Actions"));
            if (ActionBar is not null)
            {
                ActionBar.IsLauncherVisible = false;
                foreach (var module in CurrentModules)
                    ActionBar.Items.Remove(module);
            }
        }

        CurrentTab = null;
        CurrentButton = null;
        ContentControl.Content = null;
    }

    private void RibbonWindow_Activated(object sender, EventArgs e)
    {
    }

    private void RegisterModules(IProgress<string> progress)
    {
        foreach (Fluent.RibbonTabItem tab in _ribbon.Tabs)
            foreach (Fluent.RibbonGroupBox bar in tab.Groups)
                foreach (var item in bar.Items)
                    Dispatcher.Invoke(() =>
                    {
                        var button = item as RibbonButton;
                        if (button != null && button.Label != "Refresh")
                            if (bar.Header.Equals("Actions"))
                                Modules.Register(button.Label);
                    });
    }

    #region Visibility


    private void SetFrameworkItemVisibility(FrameworkElement button, bool visible)
    {
        var vResult = true;
        var eResult = ClientFactory.UserGuid != Guid.Empty && visible;
        button.Visibility = vResult && eResult ? Visibility.Visible : Visibility.Collapsed;

        if (button is Fluent.Button rb)
        {
            CustomModules.Register(rb.Header?.ToString() ?? "");
            rb.IsEnabled = !OutstandingDailyReports(false);
        }
    }
    
    private void SetModuleVisibility<T>(Fluent.Button button, bool visible) where T : class, IBasePanel, new()
    {
        SetFrameworkItemVisibility(button,visible);
        
        button.MinWidth = 60;
        
        if (button.Command == null)
        {
            button.Command = new SimpleCommand(() => LoadWindow<T>(button));
       
            var menu = new ContextMenu();
            menu.Items.Add(new MenuItem()
            {
                Header = "Open in New Window",
                Icon =  new System.Windows.Controls.Image() { Source = PRSDesktop.Resources.target.AsBitmapImage() },
                Command = new SimpleCommand(() => LoadSecondaryWindow<T>(button))
            });
            button.ContextMenu = menu;
        }
    }

    private static void SetVisibleIfEither(FrameworkElement separator, FrameworkElement[] left, FrameworkElement[] right)
    {
        var bLeft = false;
        foreach (var button in left)
            bLeft = bLeft || button.Visibility == Visibility.Visible;

        var bRight = false;
        foreach (var button in right)
            bRight = bRight || button.Visibility == Visibility.Visible;

        separator.Visibility = bLeft && bRight ? Visibility.Visible : Visibility.Collapsed;
    }

    private static void SetVisibleIfAny(FrameworkElement separator, params FrameworkElement[] buttons)
    {
        var bVisible = false;
        foreach (var button in buttons)
            bVisible = bVisible || button.Visibility == Visibility.Visible;
        separator.Visibility = bVisible ? Visibility.Visible : Visibility.Collapsed;
    }
    private static void SetTabVisibleIfAny(Fluent.RibbonTabItem tab, params FrameworkElement[] buttons)
    {
        var bVisible = false;
        foreach (var button in buttons)
            bVisible = bVisible || button.Visibility == Visibility.Visible;

        tab.Visibility = bVisible ? Visibility.Visible : Visibility.Collapsed;
    }

    #endregion

    private static Fluent.RibbonGroupBox? FindRibbonBar(Fluent.RibbonTabItem tab, Func<Fluent.RibbonGroupBox, bool> predicate)
    {
        foreach (var group in tab.Groups)
        {
            if (group != null)
                if (predicate.Invoke(group))
                    return group;
        }

        return null;
    }

    #region Button Event Handlers
    
    

    #region Accounts

    #endregion
    

    #region Dashboards

    #endregion

    private void Console_Click(object sender, RoutedEventArgs a)
    {
        if (_console is null)
        {
            _console = new DesktopConsole("Console");
            _console.Closing += (o, args) => _console = null;
        }

        _console.Show();
    }

    
    private void RefreshMenu_Click(object sender, RoutedEventArgs e)
    {
        PanelHost.Refresh();
    }
    
    //private void NotificationsList_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
    //{
    //    if (NotificationsList.SelectedIndex < 0)
    //        return;

    //    var editors = NotificationsList.FindVisualChildren<InABox.DynamicGrid.ExtendedRichTextEditor>().ToArray();
    //    var selected = editors[NotificationsList.SelectedIndex];
    //    selected.Text = (String)selected.Tag; //NotificationsList.SelectedIndex.ToString();
    //}

    //private void ViewNotification_Click(object sender, System.Windows.Input.MouseButtonEventArgs e)
    //{
    //    Notification notification = (sender as Label).Tag as Notification;
    //    NotificationDetails details = new NotificationDetails(notification);
    //    details.ShowDialog();
    //    ReloadNotifications();
    //}
    
    private void Library_Click(object sender, RoutedEventArgs e)
    {
        Process.Start(
            new ProcessStartInfo
            {
                FileName = App.DatabaseSettings.LibraryLocation,
                UseShellExecute = true,
                Verb = "open"
            }
        );
    }


    private void SendNotificationClick(object sender, RoutedEventArgs e)
    {
        var form = new NotificationForm { Description = "" };
        if (form.ShowDialog() == true)
            ReloadNotifications();
    }


    private void CompanyInformation_Click(object sender, RoutedEventArgs e)
    {
        var info = new Client<CompanyInformation>().Load().FirstOrDefault();
        if (info == null)
            info = new CompanyInformation();
        new DynamicDataGrid<CompanyInformation>().EditItems(new[] { info });
    }

    
    private void Setup_Click(object sender, RoutedEventArgs e)
    {
        var tab = _ribbon.SelectedTabItem;
        if (tab is null)
            return;

        var menu = new ContextMenu();
        PanelHost.InitialiseSetupMenu(menu);
        menu.IsOpen = true;
    }

    private void Issues_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            IssuesWindow.Execute();
            CheckSupportTicketStatus();
        }
        catch(Exception err)
        {
            MessageWindow.ShowError("Could not load issues.", err);
        }
    }

    private void StartForm<TEntityForm, TEntity, TEntityLink>(DigitalForm form)
        where TEntityForm : EntityForm<TEntity, TEntityLink, TEntityForm>, new()
        where TEntity : Entity, new()
        where TEntityLink : EntityLink<TEntity>, new()
    {
        var entityForm = new TEntityForm();
        entityForm.Form.CopyFrom(form);
        entityForm.Description = form.Description;
        entityForm.FormStarted = DateTime.Now;
        var entity = DFUtils.NewEntity<TEntityForm, TEntity, TEntityLink>(form);
        if (DynamicFormEditWindow.EditDigitalForm(entityForm, out var dataModel, entity))
        {
            dataModel.Update(null);
        }
    }

    private void Forms_Click(object sender, RoutedEventArgs e)
    {
        var select = new MultiSelectDialog<DigitalForm>(
            Filter<DigitalForm>.And(
                LookupFactory.DefineChildFilter<KanbanForm, DigitalForm>(Array.Empty<KanbanForm>()),
                new Filter<DigitalForm>(x => x.ID).InQuery(
                    new Filter<EmployeeDigitalForm>(x => x.Employee.ID).IsEqualTo(App.EmployeeID),
                    x => x.Form.ID)),
            LookupFactory.DefineChildColumns<KanbanForm, DigitalForm>()
                .Add(x => x.Description),
            false);
        if (select.ShowDialog() == true)
        {
            var digitalForm = select.Data().Rows.FirstOrDefault()?.ToObject<DigitalForm>();

            if (digitalForm is not null)
            {
                StartForm<KanbanForm, Kanban, KanbanLink>(digitalForm);
            }
        };
    }

    #endregion

    private bool OutstandingDailyReports(bool refresh)
    {
        if (!Security.IsAllowed<CanViewDailyReports>() || Security.IsAllowed<BypassOutstandingDailyReports>())
            return false;

        if (refresh)
            RefreshTimeSheets();

        if (_timesheets == null)
            return false;

        return _timesheets.Rows.Any(r => r.Get<TimeSheet, DateTime>(c => c.Date).Date < DateTime.Today);
    }

    private void ShutDownTransport()
    {
        if (_transport != null)
        {
            _transport.OnClose -= TransportConnectionLost;
            if (_transport.IsConnected())
                _transport.Disconnect();
            _transport = null;
        }
    }

    private void Window_Unloaded(object sender, RoutedEventArgs e)
    {
        ShutDownTransport();
    }


    private void RibbonWindow_Closed(object sender, EventArgs e)
    {

        ShutDownTransport();

        //DisconnectRecorderNotes();
        Application.Current.Shutdown();
    }

    //private bool _closingFromSystemMenu = false;

    private void Window_Closing(object sender, CancelEventArgs e)
    {
        /*if (!_closingFromSystemMenu && !CoreUtils.GetVersion().Equals("???"))
        {
            WindowState = WindowState.Minimized;
            e.Cancel = true;
            return;
        }*/
        PanelHost.UnloadPanel(e);
        if (!e.Cancel)
        {
            ISubPanelHost.Global.ShutdownSubPanels(e);
        }
        if (e.Cancel)
        {
            return;
        }

        App.IsClosing = true;

        FinalizeAutoTimesheet();

        if (!CoreUtils.GetVersion().Equals("???"))
            scheduler.Stop();

        CurrentTab = null;
        UpdateRibbonColors();

        if (!CoreUtils.GetVersion().Equals("???"))
            if (station.ID != Guid.Empty)
                ExecuteLogout();

        ShutDownTransport();

    }


    #region Notifications + Heartbeat

    private void ReceiveNotification(Notification notification)
    {
        if (Security.CanView<Notification>())
        {
            Notifications.AddNotification(notification);
        }
        foreach(var panel in Panels.OfType<NotificationPanel>())
        {
            panel.AddNotification(notification);
        }
    }

    private void Notifications_Tick(object? sender, EventArgs e)
    {
        if (ClientFactory.UserGuid != Guid.Empty)
        {
            try
            {
                ReloadNotifications();
            }
            catch (Exception err)
            {
                Logger.Send(LogType.Error, ClientFactory.UserID,
                    string.Format("Exception in Notifications_Tick:ReloadNotifications() {0}\n{1}", err.Message, err.StackTrace));
            }

            Heartbeat();

            try
            {
                CheckIsLoggedOn();
            }
            catch (Exception err2)
            {
                Logger.Send(LogType.Error, ClientFactory.UserID,
                    string.Format("Exception in Notifications_Tick:CheckIsLoggedOn() {0}\n{1}", err2.Message, err2.StackTrace));
            }
        }
        //else
        //{
        //    Logger.Send(LogType.Information, ClientFactory.UserID, "Notifications_Tick: ClientFactory.UserGuid is empty");
        //}
    }

    private void CheckIsLoggedOn()
    {
        if (CoreUtils.GetVersion().Equals("???"))
            return;

        var bLogout = false;
        if (!Security.IsAllowed<CanBypassTimeBench>())
            if (!IsClockedOn())
            {
                Logger.Send(LogType.Information, ClientFactory.UserID, "User is no longer clocked in!");
                bLogout = true;
                Dispatcher.Invoke(() => { Logout(); });
            }

        if (!bLogout)
            new Client<Login>().Query(
                new Filter<Login>(x => x.User.ID).IsEqualTo(ClientFactory.UserGuid),
                Columns.None<Login>().Add(x => x.StationID),
                null,
                CoreRange.All,
                (o, e) =>
                {
                    if (e is RemoteException remote)
                    {
                        if (remote.Status == StatusCode.Unauthenticated)
                        {
                            Logger.Send(LogType.Information, ClientFactory.UserID, "User has been logged out");
                            Dispatcher.Invoke(() =>
                            {
                                Logout("You have been logged out due to inactivity");
                            });
                        }
                        else
                        {
                            Logger.Send(LogType.Information, ClientFactory.UserID, $"Error in CheckIsLoggedOn(): {CoreUtils.FormatException(remote)}");
                        }
                    }
                    else if (e is not null)
                    {
                        Logger.Send(LogType.Information, ClientFactory.UserID, $"Error in CheckIsLoggedOn(): {CoreUtils.FormatException(e)}");
                    }
                    else if (o is not null)
                    {
                        var row = o.Rows.FirstOrDefault();
                        if (row == null)
                        {
                            station.ID = Guid.Empty;
                            new Client<Login>().Save(station, "", (o1, e1) => { });
                        }
                        else if (!row.Get<Login, string>(c => c.StationID).Equals(station.StationID))
                        {
                            Logger.Send(LogType.Information, ClientFactory.UserID, "User logged in somewhere else!");
                            bLogout = true;
                            Dispatcher.Invoke(() => { Logout(); });
                        }
                    }
                }
            );
    }

    private void Heartbeat()
    {
        //Task.Run(() =>
        //{
        try
        {

            CheckSupportTicketStatus();
            
            bool IsClockedOn = this.IsClockedOn();

            if (IsClockedOn)
            {

                if ((_kanbantrackingassignment != null) && (_kanbantrackingassignment.Actual.Finish < DateTime.Now.TimeOfDay))
                {
                    _kanbantrackingassignment.Actual.Finish = DateTime.Now.TimeOfDay;
                    new Client<Assignment>().Save(_kanbantrackingassignment, "");
                }


                if (Security.IsAllowed<MonitorApplicationWindows>())
                {
                    if (ActivityHistory == null)
                        ActivityHistory = new LocalConfiguration<DailyActivityHistory>().Load();

                    var appname = OpenWindowGetter.GetActiveWindowProcess();
                    var title = OpenWindowGetter.GetActiveWindowTitle();
                    ActivityHistory.Activities[DateTime.Now] = (!string.IsNullOrWhiteSpace(appname) ? appname.Trim() + " - " : "") + title;

                    new LocalConfiguration<DailyActivityHistory>().Save(ActivityHistory);
                }
            }

            PanelHost.Heartbeat();
            foreach(var window in SecondaryWindows.Values)
            {
                window.Heartbeat();
            }
        }
        catch (Exception err)
        {
            Logger.Send(LogType.Error, ClientFactory.UserID, string.Format("Exception in Heartbeat: {0}\n{1}", err.Message, err.StackTrace));
        }
        //});
    }

    private void CheckSupportTicketStatus()
    {
        Dispatcher.BeginInvoke(() =>
        {
            IssuesButton.Background = IssuesWindow.Check()
                ? new SolidColorBrush(Colors.Red) { Opacity = 0.5 }
                : Brushes.Transparent;

        });
    }

    private void Notifications_Changed(object sender)
    {
        if (Notifications.IsActive)
        {
            Notifications.Visibility = Visibility.Visible;
            DockingGrid.ColumnDefinitions[1].Width = new GridLength(4, GridUnitType.Pixel);
            DockingGrid.ColumnDefinitions[2].Width = Equals(0.0, DockingGrid.ColumnDefinitions[2].Width.Value)
                ? new GridLength(300, GridUnitType.Pixel)
                : DockingGrid.ColumnDefinitions[2].Width;
        }
        else
        {
            Notifications.Visibility = Visibility.Collapsed;
            DockingGrid.ColumnDefinitions[1].Width = new GridLength(0, GridUnitType.Pixel);
            DockingGrid.ColumnDefinitions[2].Width = new GridLength(0, GridUnitType.Pixel);
        }
    }

    private void ReloadNotifications()
    {
        if (Security.CanView<Notification>())
            Notifications.Refresh();

        if (!NotificationsWatchDog.IsEnabled)
        {
            //Logger.Send(LogType.Information, ClientFactory.UserID, "Enabling Heartbeat");
            NotificationsWatchDog.IsEnabled = true;
        }
    }

    #endregion

    private void RibbonWindow_PreviewMouseUp(object sender, MouseButtonEventArgs e)
    {
        PanelHost.IncrementTrackingModuleClick();
    }

    private void RibbonWindow_PreviewKeyUp(object sender, KeyEventArgs e)
    {
        PanelHost.IncrementTrackingModuleKey();
    }

    public static void ActivateWindow(Window window)
    {
        var hwnd = new WindowInteropHelper(window).EnsureHandle();

        var threadId1 = GetWindowThreadProcessId(GetForegroundWindow(), IntPtr.Zero);
        var threadId2 = GetWindowThreadProcessId(hwnd, IntPtr.Zero);

        if (threadId1 != threadId2)
        {
            AttachThreadInput(threadId1, threadId2, true);
            SetForegroundWindow(hwnd);
            AttachThreadInput(threadId1, threadId2, false);
        }
        else
        {
            SetForegroundWindow(hwnd);
        }
    }

    private static IntPtr GetForegroundWindow()
    {
        var active = GetActiveWindow();

        var window = Application.Current.Windows.OfType<Window>().SingleOrDefault(x => new WindowInteropHelper(x).Handle == active);
        var hwnd = new WindowInteropHelper(window).EnsureHandle();
        return hwnd;
    }

    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr SetForegroundWindow(IntPtr hWnd);

    [DllImport("user32.dll")]
    private static extern uint GetWindowThreadProcessId(IntPtr hWnd, IntPtr ProcessId);

    [DllImport("user32.dll")]
    private static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);

    [DllImport("user32.dll")]
    private static extern IntPtr GetActiveWindow();

    #region Modules + Reports

    public void ClearActions()
    {
        foreach (var module in CurrentModules)
        {
            if (module.Parent is Fluent.RibbonGroupBox bar)
                bar.Items.Remove(module);
        }

        CurrentModules.Clear();
    }

    public void ClearReports()
    {
        if (CurrentTab is not null)
        {
            var ReportsBar = FindRibbonBar(CurrentTab, x => x.Header.Equals("Print"));
            if (ReportsBar is not null)
            {
                ReportsBar.Visibility = Visibility.Collapsed;
                ReportsBar.Items.Clear();
            }
        }
    }

    public void CreateReport(PanelAction action)
    {
        if (CurrentTab is null)
            return;

        var ReportsBar = FindRibbonBar(CurrentTab, x => x.Header.Equals("Print"));

        if (ReportsBar is not null)
        {
            var button = new Fluent.Button
            {
                Header = action.Caption,
                LargeIcon = action.Image?.AsBitmapImage(),
                MinWidth = 60
            };

            if (action.Menu is not null)
            {
                button.ContextMenu = action.Menu;
            }
            button.Click += (o, e) =>
            {
                action.Execute();
            };

            ReportsBar.Visibility = Security.IsAllowed<CanPrintReports>() ? Visibility.Visible : Visibility.Collapsed;
            ReportsBar.Items.Add(button);
        }
    }

    private NullConverter<Visibility>? _vis = null;
    
    public void CreatePanelAction(PanelAction action)
    {
        if (CurrentTab is null)
            return;

        if (_vis == null)
        {
            _vis = new();
            _vis.Converting += (o, e) =>
            {

            };
        }
        
        var Actions = FindRibbonBar(CurrentTab, x => x.Header.Equals("Actions"));
        if (Actions is not null)
        {
            if (!CurrentModules.Any(x => x.GetType().Equals(typeof(RibbonSeparator))))
            {
                var sep = new RibbonSeparator();
                CurrentModules.Add(sep);
                Actions.Items.Add(sep);
            }

            if (action.OnPopulate != null)
            {
                Fluent.DropDownButton button;
                if (action.OnExecute != null)
                {
                    button = new Fluent.SplitButton();
                    ((Fluent.SplitButton)button).Click += (o, e) => action.Execute();
                }
                else
                    button = new Fluent.DropDownButton();
                
                button.MinWidth = 60;
                button.DataContext = action;
                button.DropDownOpened += (sender, args) => { button.ItemsSource = CreateMenuItems(action); };
                button.Bind<PanelAction, String>(Fluent.DropDownButton.HeaderProperty, x => x.Caption, null);
                button.Bind<PanelAction, Bitmap?>(Fluent.DropDownButton.LargeIconProperty, x => x.Image,
                    new BitmapToBitmapImageConverter());
                button.Bind<PanelAction, ContextMenu?>(ContextMenuProperty, x => x.Menu);
                button.Bind<PanelAction, bool>(IsEnabledProperty, x => x.IsEnabled);
                button.Bind<PanelAction, Visibility>(Fluent.DropDownButton.VisibilityProperty, x => x.Visibility, _vis);                    
                Actions.Items.Add(button);
                CurrentModules.Add(button);
            }
            
            else
            {
                var button = new Fluent.Button()
                {
                    MinWidth = 60,
                    DataContext = action
                };
                button.Bind<PanelAction, String>(Fluent.Button.HeaderProperty, x => x.Caption, null);
                button.Bind<PanelAction, Bitmap?>(Fluent.Button.LargeIconProperty, x => x.Image,
                    new BitmapToBitmapImageConverter());
                button.Bind<PanelAction, ContextMenu?>(Fluent.Button.ContextMenuProperty, x => x.Menu);
                button.Bind<PanelAction, bool>(Fluent.Button.IsEnabledProperty, x => x.IsEnabled);
                button.Bind<PanelAction, Visibility>(Fluent.Button.VisibilityProperty, x => x.Visibility, _vis);
                button.Click += (o, e) => action.Execute();
                Actions.Items.Add(button);
                CurrentModules.Add(button);
            }
        }
    }

    private static ObservableCollection<MenuItem> CreateMenuItems(PanelAction action)
    {
        var items = new ObservableCollection<MenuItem>();
        var entries = action.Populate();
        if (entries != null)
        {
            foreach (var entry in entries)
            {
                var item = new Fluent.MenuItem()
                {
                    Header = entry.Caption,
                    DataContext = entry.Data,
                    Icon = entry.Image?.AsBitmapImage()
                };
                item.Click += (o, eventArgs) => entry.Execute();
                items.Add(item);
            }
        }
        return items;
    }

    #endregion

    #region Tracking Kanban

    private class TrackingKanbanFilterItemComponent : DynamicGridFilterComponent<Kanban>
    {
        public TrackingKanbanFilterItemComponent() : base(
            new GlobalConfiguration<CoreFilterDefinitions>(nameof(Kanban)),
            new UserConfiguration<CoreFilterDefinitions>(nameof(Kanban)))
        {
            ButtonText = "Filter";
        }

        public string Text { get; private set; } = "Filter";

        public Bitmap? Image { get; private set; }

        protected override void UpdateButtonText(Bitmap image, string text)
        {
            Text = text;
            Image = image;
        }
    }
    private TrackingKanbanFilterItemComponent? _trackingKanbanFilterComponent;
    private TrackingKanbanFilterItemComponent TrackingKanbanFilterComponent
    {
        get
        {
            if(_trackingKanbanFilterComponent is null)
            {
                _trackingKanbanFilterComponent = new();
                _trackingKanbanFilterComponent.OnFiltersSelected += _trackingKanbanFilterComponent_OnFiltersSelected;
            }
            return _trackingKanbanFilterComponent;
        }
    }

    private ContextMenu? _trackingKanbanMenu;
    private MenuItem? _trackingKanbanFilterMenu;

    private void _trackingKanbanFilterComponent_OnFiltersSelected(DynamicGridSelectedFilterSettings filters)
    {
        if (_trackingKanbanMenu is null) return;

        if (!filters.MultipleFilters)
        {
            _trackingKanbanMenu.IsOpen = false;
        }
        if(_trackingKanbanFilterMenu is not null)
        {
            _trackingKanbanFilterMenu.Header = TrackingKanbanFilterComponent.Text;
            _trackingKanbanFilterMenu.Icon = new System.Windows.Controls.Image() { Source = TrackingKanbanFilterComponent.Image?.AsBitmapImage(24, 24) };
        }
    }

    private void SelectTask_Click(object sender, RoutedEventArgs e)
    {
        var menu = new ContextMenu();

        var others = new MenuItem() { Header = "Other Tasks" };
        var waiting = new MenuItem() { Header = "Waiting Tasks" };
        using (new WaitCursor())
        {
            var filter =
                new Filter<KanbanSubscriber>(x => x.Employee.UserLink.ID).IsEqualTo(ClientFactory.UserGuid)
                    .And(x => x.Kanban.Completed).IsEqualTo(DateTime.MinValue)
                    .And(x => x.Kanban.Closed).IsEqualTo(DateTime.MinValue);
            var kanbanFilter = TrackingKanbanFilterComponent.GetFilter();
            if(kanbanFilter is not null)
            {
                filter = filter.And(x => x.Kanban.ID).InQuery(kanbanFilter, x => x.ID);
            }
            var kanbans = Client.Query(
                filter,
                Columns.None<KanbanSubscriber>()
                    .Add(x => x.Kanban.ID)
                    .Add(x => x.Kanban.Number)
                    .Add(x => x.Kanban.Title)
                    .Add(x => x.Kanban.Status)
                    .Add(x => x.Assignee),
                new SortOrder<KanbanSubscriber>(x => x.Kanban.Number, SortDirection.Ascending));
            foreach (var subscriber in kanbans.ToObjects<KanbanSubscriber>())
            {
                CreateTaskMenu(subscriber.Assignee ? (subscriber.Kanban.Status != KanbanStatus.Waiting ? menu : waiting) : others,
                    $"{subscriber.Kanban.Number} {subscriber.Kanban.Title}",
                    subscriber.Kanban.ID);
            }

            menu.AddSeparatorIfNeeded();
            if(others.Items.Count > 0)
            {
                menu.Items.Add(others);
            }
            if(waiting.Items.Count > 0)
            {
                menu.Items.Add(waiting);
            }
            menu.AddSeparatorIfNeeded();
            CreateTaskMenu(menu, "(No Task Selected)", Guid.Empty);
            if(_kanbantrackingassignment is not null && _kanbantrackingassignment.Task.ID != Guid.Empty)
            {
                menu.AddItem("View Task", null, _kanbantrackingassignment.Task.ID, ViewTrackingKanban_Click);
            }
            menu.AddSeparatorIfNeeded();

            var filterItem = menu.AddItem(TrackingKanbanFilterComponent.Text, TrackingKanbanFilterComponent.Image, null);
            TrackingKanbanFilterComponent.PopulateMenu(filterItem);
            _trackingKanbanFilterMenu = filterItem;
        }
        menu.IsOpen = true;
        _trackingKanbanMenu = menu;
    }

    private void ViewTrackingKanban_Click(Guid guid)
    {
        var item = Client.Query(
            new Filter<Kanban>(x => x.ID).IsEqualTo(guid),
            DynamicGridUtils.LoadEditorColumns<Kanban>())
            .ToObjects<Kanban>().FirstOrDefault();
        if (item is null) return;

        var grid = DynamicGridUtils.CreateDynamicGrid<Kanban>(typeof(DynamicGrid<>));
        grid.EditItemsNonModal(ISubPanelHost.Global, [item], (items, saved) => { });
    }

    private Assignment? _kanbantrackingassignment = null;
    private CoreFilterDefinitions? _kanbanTrackingFilter = null;

    private void SetTrackingKanban(Guid kanbanID, string header)
    {
        SelectedTaskName.Content = header;

        var createNewAssignment = false;

        if (_kanbantrackingassignment is not null)
        {

            if (_kanbantrackingassignment.Actual.Finish < DateTime.Now.TimeOfDay)
            {
                _kanbantrackingassignment.Actual.Finish = DateTime.Now.TimeOfDay;
                Client.Save(_kanbantrackingassignment, "");
            }

            // Update Existing Kanban
            if (kanbanID == Guid.Empty)
                _kanbantrackingassignment = null;
            else if (_kanbantrackingassignment.Task.ID != kanbanID)
            {
                createNewAssignment = true;
            }
        }
        else if (kanbanID != Guid.Empty)
        {
            createNewAssignment = true;
        }

        if (createNewAssignment)
        {
            _kanbantrackingassignment = new Assignment();
            _kanbantrackingassignment.Task.ID = kanbanID;
            _kanbantrackingassignment.EmployeeLink.ID = App.EmployeeID;
            _kanbantrackingassignment.Title = header;
            _kanbantrackingassignment.Date = DateTime.Today;
            _kanbantrackingassignment.Actual.Start = DateTime.Now.TimeOfDay;
            _kanbantrackingassignment.Actual.Finish = DateTime.Now.TimeOfDay.Add(new TimeSpan(0, 2, 0));
            Client.Save(_kanbantrackingassignment, "");
        }
    }

    private void ClearTrackingKanban()
        => SetTrackingKanban(Guid.Empty, "(No Task Selected)");

    private void CreateTaskMenu(ItemsControl menu, string title, Guid id)
    {
        menu.AddCheckMenuItem(title, (title, id), TrackingKanbanMenuItem_Click, isChecked: _kanbantrackingassignment?.Task.ID == id);
    }

    private void TrackingKanbanMenuItem_Click((string title, Guid id) tuple, bool isChecked)
    {
        if (isChecked)
        {
            SetTrackingKanban(tuple.id, tuple.title);
        }
    }

    #endregion

    private void DockPanelBorder_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
    {
        if (sender is not Border border || !border.IsVisible)
            return;

        var dock = border.Child is IDockPanel panel ? panel : border.Child?.FindVisualChildren<IDockPanel>().FirstOrDefault();
        if (dock is null)
            return;

        dock.Refresh();
    }

    private void DockPanel_OnIsActiveChanged(object? sender, EventArgs e)
    {
        if (sender is not LayoutAnchorable layout)
            return;

        var content = layout.Content as DependencyObject;

        var dock = content is IDockPanel panel ? panel : content?.FindVisualChildren<IDockPanel>().FirstOrDefault();
        if (dock is null)
            return;

        if (layout.IsActive && layout.IsVisible)
            dock.Refresh();
    }

    private void _ribbon_OnPreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
    {
        e.Handled = true;
    }

    #region Backstage Functions

    private enum DatabaseConfigurationResult
    {
        RestartRequired,
        RestartNotRequired,
        Cancel
    }

    private DatabaseConfigurationResult ShowDatabaseConfiguration()
    {
        DatabaseConfigurationResult result;
        var config = new DataBaseConfiguration();
        if (config.ShowDialog() == true)
        {
            var newsettings = new LocalConfiguration<DatabaseSettings>(App.Profile).Load();
            if (newsettings.RestartRequired(App.DatabaseSettings))
            {
                result = DatabaseConfigurationResult.RestartRequired;
            }
            else
            {
                result = DatabaseConfigurationResult.RestartNotRequired;
            }
            if ((newsettings.DatabaseType == DatabaseType.Standalone) && (newsettings.ColorScheme != App.DatabaseSettings.ColorScheme))
            {
                App.DatabaseSettings.ColorScheme = newsettings.ColorScheme;
                ApplyColorScheme();
            }
        }
        else
        {
            result = DatabaseConfigurationResult.Cancel;
        }
        return result;
    }

    private void DatabaseSettings_OnClick(object sender, RoutedEventArgs e)
    {
        switch (ShowDatabaseConfiguration())
        {
            case DatabaseConfigurationResult.RestartRequired:
                MessageBox.Show("Please restart the application to apply these changes!");
                break;
        }
    }

    private void CompanyInformation_OnClick(object sender, RoutedEventArgs e)
    {
        var info = new Client<CompanyInformation>().Load().FirstOrDefault();
        if (info == null)
            info = new CompanyInformation();
        new DynamicDataGrid<CompanyInformation>().EditItems(new[] { info });
    }

    private void SecurityDefaultsButton_OnClick(object sender, RoutedEventArgs e)
    {
        var window = new GlobalTokenWindow();
        window.ShowDialog();
        Security.Reset();
    }

    private void SystemLogsButton_OnClick(object sender, RoutedEventArgs e)
    {
        var logfile = CoreUtils.GetLogFile();
        if (File.Exists(logfile))
        {
            var startInfo = new ProcessStartInfo("notepad.exe", logfile);
            startInfo.Verb = "open";
            startInfo.UseShellExecute = true;
            Process.Start(startInfo);
        }
        else
        {
            MessageBox.Show(logfile + " does not exist!");
        }
    }
    
    private void CheckForUpdates_OnClick(object sender, RoutedEventArgs e)
    {
        if (SupportUtils.CheckForUpdates())
        {
            Close();
        }
        else
        {
            if (MessageWindow.ShowYesNo(
                    "You appear to be using the latest version already!\n\nRun the installer anyway?", "Update"))
            {
                if (SupportUtils.DownloadAndRunInstaller())
                {
                    Close();
                }
            }
        }
    }
    
    private void OpenSupportSession_OnClick(object sender, RoutedEventArgs e)
    {
        SupportUtils.OpenSupportSession();
    }

    private void DocumentTypeList_OnClick(object sender, RoutedEventArgs e)
    {
        var list = new MasterList(typeof(DocumentType));
        list.ShowDialog();
    }

    private void EventList_Click(object sender, RoutedEventArgs e)
    {
        var list = new MasterList(typeof(Event));
        list.ShowDialog();
    }

    private void EditDetailsButton_OnClick(object sender, RoutedEventArgs e)
    {
        var employee = new Client<Employee>().Query(
                new Filter<Employee>(x => x.UserLink.ID).IsEqualTo(ClientFactory.UserGuid))
            .Rows.FirstOrDefault()?.ToObject<Employee>();

        var item = new MyDetailsConfiguration(employee);
        item.User = ClientFactory.UserGuid;

        var buttons = new DynamicEditorButtons();
        buttons.Add("Change Password", null, item, (sender, item) =>
        {
            var details = (item as MyDetailsConfiguration)!;
            var changePassword = new ChangePassword(details.User);
            if (changePassword.ShowDialog() == true && changePassword.Password != null)
            {
                var newUser = new User();
                newUser.SetID(details.User);

                ChangePassword.ChangeUserPassword(newUser, changePassword.Password);
                new Client<User>().Save(newUser, "Changed Password");

                MessageBox.Show("Password changed!");
            }
        });

        var editor = new DynamicEditorForm(typeof(MyDetailsConfiguration), buttons: buttons);

        if (employee == null)
        {
            editor.OnFormCustomiseEditor += (sender, items, column, editor) =>
            {
                editor.Editable = Editable.Disabled;
            };
        }

        editor.Items = new BaseObject[] { item };

        if (editor.ShowDialog() == true)
        {
            if (employee != null)
            {
                item.SaveTo(employee);
                new Client<Employee>().Save(employee, "Edited by user");
            }
        }
    }

    private void LogoutButton_OnClick(object sender, RoutedEventArgs e)
    {
        Logout();
    }

    private void LoginButton_OnClick(object sender, RoutedEventArgs e)
    {
        if (DoLogin() == ValidationStatus.VALID)
            AfterLogin(null);
    }

    private void ExitButton_OnClick(object sender, RoutedEventArgs e)
    {
        //_closingFromSystemMenu = true;
        Close();
    }

    #endregion
}