using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using Tango.FSE.Common.Notifications;
using Tango.Core;
using System.Collections.Concurrent;
using System.Windows.Media.Imaging;
using Tango.SharedUI.Helpers;
using System.Timers;
using Tango.Core.Commands;
using Tango.SharedUI;
using System.Reflection;
using Tango.Core.DI;
using System.ComponentModel;
using System.Windows.Data;
using MaterialDesignThemes.Wpf;
using Tango.FSE.Common.Core;
using Tango.FSE.Common.BugReporting;
using Tango.FSE.Common.FSEApplication;
using Tango.FSE.Common.DemoMode;
using Tango.FSE.Common;
using System.Threading;

namespace Tango.FSE.UI.Notifications
{
    /// <summary>
    /// Represents the default FSE notification provider.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.FSE.Common.Notifications.INotificationProvider" />
    public class DefaultNotificationProvider : ExtendedObject, INotificationProvider
    {
        private HashSet<String> _reportedExceptions;
        private ConcurrentQueue<PendingNotification<MessageBoxVM, bool>> _pendingMessageBoxes;
        private ConcurrentQueue<PendingNotification<DialogAndView, DialogViewVM>> _pendingDialogs;
        private List<AppButton> _appButtons;

        [TangoInject(TangoInjectMode.WhenAvailable)]
        public IBugReporter BugReporter { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private IDemoModeManager DemoModeManager { get; set; }

        private bool _notificationsVisible;
        /// <summary>
        /// Gets or sets a value indicating whether to allow notifications visibility.
        /// </summary>
        public bool NotificationsVisible
        {
            get { return _notificationsVisible; }
            set { _notificationsVisible = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Gets the collection of notification items.
        /// </summary>
        public ObservableCollection<NotificationItem> NotificationItems { get; private set; }

        /// <summary>
        /// Gets the notification items view.
        /// </summary>
        public ICollectionView NotificationItemsView { get; private set; }

        /// <summary>
        /// Gets the collection of task items.
        /// </summary>
        public ObservableCollection<TaskItem> TaskItems { get; private set; }

        /// <summary>
        /// Gets a value indicating whether there are any task items pending.
        /// </summary>
        public bool HasTaskItems
        {
            get { return TaskItems.Count > 0; }
        }

        /// <summary>
        /// Gets the collection of snack bar items.
        /// </summary>
        public ObservableCollection<SnackbarItem> SnackbarItems { get; private set; }

        /// <summary>
        /// Gets or sets a value indicating whether this instance has snack bar items.
        /// </summary>
        public bool HasSnackbarItems
        {
            get { return SnackbarItems.Count > 0; }
        }

        private bool _holsSnackbarItemsTimeout;
        /// <summary>
        /// Gets or sets a value indicating whether to delay the snackbar items closing timeout.
        /// </summary>
        public bool HoldSnackbarItemsTimeout
        {
            get { return _holsSnackbarItemsTimeout; }
            set
            {
                _holsSnackbarItemsTimeout = value;
                RaisePropertyChangedAuto();
                SnackbarItems.ToList().ForEach(x => x.HoldTimeout = value);
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultNotificationProvider"/> class.
        /// </summary>
        public DefaultNotificationProvider()
        {
            NotificationsVisible = true;
            _reportedExceptions = new HashSet<string>();
            NotificationItems = new ObservableCollection<NotificationItem>();
            TaskItems = new ObservableCollection<TaskItem>();
            _pendingMessageBoxes = new ConcurrentQueue<PendingNotification<MessageBoxVM, bool>>();
            _pendingDialogs = new ConcurrentQueue<PendingNotification<DialogAndView, DialogViewVM>>();
            _appButtons = new List<AppButton>();
            SnackbarItems = new ObservableCollection<SnackbarItem>();

            PopNotificationCommand = new RelayCommand<NotificationItem>((x) => PopNotification(x));

            NotificationItems.EnableCrossThreadOperations();

            NotificationItemsView = CollectionViewSource.GetDefaultView(NotificationItems);
            NotificationItemsView.SortDescriptions.Add(new SortDescription(nameof(NotificationItem.Priority), ListSortDirection.Descending));
        }

        private MessageBoxVM _currentMessageBox;
        /// <summary>
        /// Gets the current message box if any.
        /// </summary>
        public MessageBoxVM CurrentMessageBox
        {
            get { return _currentMessageBox; }
            private set
            {
                _currentMessageBox = value;
                RaisePropertyChangedAuto();
                RaisePropertyChanged(nameof(HasMessageBox));
            }
        }

        /// <summary>
        /// Gets a value indicating whether a message box is available.
        /// </summary>
        public bool HasMessageBox
        {
            get
            {
                return CurrentMessageBox != null;
            }
        }

        private InputBoxVM _currentInputBox;
        /// <summary>
        /// Gets the current input box.
        /// </summary>
        public InputBoxVM CurrentInputBox
        {
            get { return _currentInputBox; }
            private set
            {
                _currentInputBox = value;
                RaisePropertyChangedAuto();
                RaisePropertyChanged(nameof(HasInputBox));
            }
        }

        /// <summary>
        /// Gets a value indicating whether this instance has input box.
        /// </summary>
        public bool HasInputBox
        {
            get
            {
                return CurrentInputBox != null;
            }
        }

        private FrameworkElement _currentDialog;
        /// <summary>
        /// Gets the current dialog if any.
        /// </summary>
        public FrameworkElement CurrentDialog
        {
            get { return _currentDialog; }
            private set
            {
                _currentDialog = value;
                RaisePropertyChangedAuto();
                RaisePropertyChanged(nameof(HasDialog));
            }
        }

        private AppButton _currentAppButton;
        /// <summary>
        /// Gets the current app button.
        /// </summary>
        public AppButton CurrentAppButton
        {
            get { return _currentAppButton; }
            private set { _currentAppButton = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Gets a value indicating whether a dialog is available.
        /// </summary>
        public bool HasDialog
        {
            get
            {
                return CurrentDialog != null;
            }
        }

        /// <summary>
        /// Shows an error message box.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public Task ShowError(string message)
        {
            return ShowMessageBox(new MessageBoxVM()
            {
                Message = message,
                Title = "Error",
                Type = MessageType.Error,
            });
        }

        /// <summary>
        /// Shows an information message box.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public Task ShowInfo(string message)
        {
            return ShowMessageBox(new MessageBoxVM()
            {
                Message = message,
                Title = "Information",
                Type = MessageType.Info,
            });
        }

        /// <summary>
        /// Shows warning message box.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public Task ShowWarning(string message)
        {
            return ShowMessageBox(new MessageBoxVM()
            {
                Message = message,
                Title = "Warning",
                Type = MessageType.Warning,
            });
        }

        /// <summary>
        /// Shows a question message box.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public Task<bool> ShowQuestion(string message, String okText = null, String cancelText = null)
        {
            return ShowMessageBox(new MessageBoxVM()
            {
                Message = message,
                Title = "Confirm",
                HasCancel = true,
                Type = MessageType.Question,
                OKText = okText != null ? okText : "YES",
                CancelText = cancelText != null ? cancelText : "NO"
            });
        }

        /// <summary>
        /// Shows a warning question message box.
        /// </summary>
        /// <param name="message">The message.</param>
        public Task<bool> ShowWarningQuestion(String message, String okText = null, String cancelText = null)
        {
            return ShowMessageBox(new MessageBoxVM()
            {
                Message = message,
                Title = "Warning",
                HasCancel = true,
                Type = MessageType.Warning,
                OKText = okText != null ? okText : "YES",
                CancelText = cancelText != null ? cancelText : "NO"
            });
        }

        /// <summary>
        /// Shows a success message box.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public Task ShowSuccess(string message)
        {
            return ShowMessageBox(new MessageBoxVM()
            {
                Message = message,
                Title = "Success",
                Type = MessageType.Success,
            });
        }

        /// <summary>
        /// Shows the message box.
        /// </summary>
        /// <param name="vm">The view model.</param>
        /// <returns></returns>
        private Task<bool> ShowMessageBox(MessageBoxVM vm)
        {
            ReleaseGlobalBusyMessage();

            LogManager.Log($"Displaying MessagBox '{vm.Message}'.");

            TaskCompletionSource<bool> source = new TaskCompletionSource<bool>();

            vm.Accepted += () => { OnMessageBoxClosed(); source.SetResult(true); };
            vm.Canceled += () => { OnMessageBoxClosed(); source.SetResult(false); };

            if (CurrentMessageBox == null)
            {
                CurrentMessageBox = vm;
            }
            else
            {
                _pendingMessageBoxes.Enqueue(new PendingNotification<MessageBoxVM, bool>(vm, source));
            }

            return source.Task;
        }

        public Task<InputBoxResult> ShowInputBox(string title, string message, PackIconKind icon = PackIconKind.InformationOutline, string defaultInput = null, string inputHint = null, int? maxChars = null, string okText = null, string cancelText = null, Func<String, String> validationFunc = null)
        {
            TaskCompletionSource<InputBoxResult> source = new TaskCompletionSource<InputBoxResult>();

            InputBoxVM vm = new InputBoxVM();
            vm.Title = title;
            vm.Message = message;
            vm.Icon = icon;
            vm.Input = defaultInput;
            vm.InputHint = inputHint;
            vm.ValidationFunction = validationFunc;

            if (maxChars != null)
            {
                vm.MaxCharacters = maxChars.Value;
            }
            if (okText != null)
            {
                vm.OKText = okText;
            }
            if (cancelText != null)
            {
                vm.CancelText = cancelText;
            }

            vm.Accepted += () =>
            {
                CurrentInputBox = null;
                source.SetResult(new InputBoxResult() { Confirmed = true, Input = vm.Input });
            };
            vm.Canceled += () =>
            {
                CurrentInputBox = null;
                source.SetResult(new InputBoxResult() { Confirmed = false, Input = vm.Input });
            };

            CurrentInputBox = vm;

            return source.Task;
        }

        /// <summary>
        /// Called when the message box has been closed.
        /// </summary>
        private void OnMessageBoxClosed()
        {
            LogManager.Log("MessageBox closed.");

            CurrentMessageBox = null;

            if (_pendingMessageBoxes.Count > 0)
            {
                PendingNotification<MessageBoxVM, bool> p = null;
                if (_pendingMessageBoxes.TryDequeue(out p))
                {
                    CurrentMessageBox = p.Item;
                }
            }
        }

        /// <summary>
        /// Inserts the notification item to the bottom of the notifications collection.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <returns></returns>
        public NotificationItem PushNotification(NotificationItem item)
        {
            LogManager.Log($"Pushing NotificationItem '{item.GetType().Name}'.");
            item.RemoveAction = () => { PopNotification(item); };
            NotificationItems.Insert(0, item);
            RaisePropertyChanged(nameof(HasNotificationItems));
            return item;
        }

        /// <summary>
        /// Pushes the notification.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public NotificationItem PushNotification<T>() where T : NotificationItem
        {
            return PushNotification(Activator.CreateInstance<T>());
        }

        /// <summary>
        /// Removed the specified notification item.
        /// </summary>
        /// <param name="item">The item.</param>
        public void PopNotification(NotificationItem item)
        {
            LogManager.Log($"Popping out NotificationItem '{item.GetType().Name}'.");
            NotificationItems.Remove(item);
            RaisePropertyChanged(nameof(HasNotificationItems));
        }

        /// <summary>
        /// Gets a value indicating whether this instance has notification items.
        /// </summary>
        public bool HasNotificationItems
        {
            get
            {
                return NotificationItems.Count > 0;
            }
        }

        /// <summary>
        /// Gets the pop notification command.
        /// </summary>
        public RelayCommand<NotificationItem> PopNotificationCommand { get; private set; }

        /// <summary>
        /// Displays the specified dialog in a modal design.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="datacontext">The data context.</param>
        /// <param name="view">The view.</param>
        /// <returns></returns>
        public async Task<T> ShowDialog<T>(T datacontext, FrameworkElement view) where T : DialogViewVM
        {
            LogManager.Log($"Invoking dialog '{view.GetType().Name}'...");

            view.DataContext = datacontext;

            TangoIOC.Default.Inject(datacontext);

            view.Loaded += (_, __) =>
            {
                view.DataContext = datacontext;
                datacontext.OnShow();
            };

            TaskCompletionSource<DialogViewVM> source = new TaskCompletionSource<DialogViewVM>();
            bool completed = false;

            datacontext.Accepted += () =>
            {
                if (!completed)
                {
                    completed = true;
                    LogManager.Log($"Dialog '{view.GetType().Name}' accepted.");
                    OnDialogClosed();
                    source.SetResult(datacontext);
                }
            };
            datacontext.Canceled += () =>
            {
                if (!completed)
                {
                    completed = true;
                    LogManager.Log($"Dialog '{view.GetType().Name}' canceled.");
                    OnDialogClosed();
                    source.SetResult(datacontext);
                }
            };

            if (CurrentDialog == null)
            {
                CurrentDialog = view;
            }
            else
            {
                _pendingDialogs.Enqueue(new PendingNotification<DialogAndView, DialogViewVM>(new DialogAndView(datacontext, view), source));
            }

            var result = await source.Task;
            return result as T;
        }

        /// <summary>
        /// Called when [dialog closed].
        /// </summary>
        private void OnDialogClosed()
        {
            CurrentDialog = null;

            if (_pendingDialogs.Count > 0)
            {
                PendingNotification<DialogAndView, DialogViewVM> p = null;
                if (_pendingDialogs.TryDequeue(out p))
                {
                    CurrentDialog = p.Item.View;
                }
            }
        }

        /// <summary>
        /// Displays the specified dialog in a modal design.
        /// The notification provider will try to locate the view automatically using conventions.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="datacontext">The data context.</param>
        /// <returns></returns>
        public Task<T> ShowDialog<T>(T datacontext) where T : DialogViewVM
        {
            var callingAssembly = datacontext.GetType().Assembly;
            String viewName = datacontext.GetType().FullName.Replace("VM", "");
            var viewType = callingAssembly.GetType(viewName);

            if (viewType == null)
            {
                throw new NullReferenceException("View type for " + datacontext.GetType().Name + " could not be found!");
            }

            var view = Activator.CreateInstance(viewType) as FrameworkElement;

            if (view == null)
            {
                throw new NullReferenceException("The view " + viewType.ToString() + " is not of type framework element.");
            }

            return ShowDialog<T>(datacontext, view);
        }

        /// <summary>
        /// Displays the specified dialog in a modal design.
        /// The data context instance will be automatically created.
        /// The notification provider will try to locate the view automatically using conventions.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public Task<T> ShowDialog<T>() where T : DialogViewVM
        {
            return ShowDialog<T>(Activator.CreateInstance<T>());
        }

        /// <summary>
        /// Sets the global busy message.
        /// </summary>
        /// <param name="message">The message.</param>
        public void SetGlobalBusyMessage(string message)
        {
            GlobalBusyMessage = message;
            IsInGlobalBusyState = true;

            RaisePropertyChanged(nameof(IsInGlobalBusyState));
            RaisePropertyChanged(nameof(GlobalBusyMessage));
        }

        /// <summary>
        /// Releases the global busy message.
        /// </summary>
        public void ReleaseGlobalBusyMessage()
        {
            GlobalBusyMessage = null;
            IsInGlobalBusyState = false;

            RaisePropertyChanged(nameof(IsInGlobalBusyState));
            RaisePropertyChanged(nameof(GlobalBusyMessage));
        }

        /// <summary>
        /// Gets the current global busy message.
        /// </summary>
        public string GlobalBusyMessage { get; private set; }

        /// <summary>
        /// Gets a value indicating whether this instance is in global busy state.
        /// </summary>
        public bool IsInGlobalBusyState { get; private set; }

        private AppBarItem _currentAppBarItem;
        /// <summary>
        /// Gets the current application bar item.
        /// </summary>
        public AppBarItem CurrentAppBarItem
        {
            get { return _currentAppBarItem; }
            set { _currentAppBarItem = value; RaisePropertyChangedAuto(); RaisePropertyChanged(nameof(HasAppBarItem)); }
        }

        /// <summary>
        /// Gets a value indicating whether this instance has application bar item.
        /// </summary>
        public bool HasAppBarItem
        {
            get { return CurrentAppBarItem != null; }
        }

        /// <summary>
        /// Pushes the application bar item.
        /// </summary>
        /// <param name="appBarItem">The application bar item.</param>
        /// <returns></returns>
        public AppBarItem PushAppBarItem(AppBarItem appBarItem)
        {
            LogManager.Log($"Pushing AppBarItem '{appBarItem.GetType().Name}'.");
            CurrentAppBarItem = appBarItem;
            appBarItem.RemoveAction = () => PopAppBarItem(appBarItem);
            return appBarItem;
        }

        /// <summary>
        /// Pushes the application bar item.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public AppBarItem PushAppBarItem<T>() where T : AppBarItem
        {
            return PushAppBarItem(Activator.CreateInstance<T>());
        }

        /// <summary>
        /// Pops the application bar item.
        /// </summary>
        /// <param name="appBarItem">The application bar item.</param>
        public void PopAppBarItem(AppBarItem appBarItem)
        {
            LogManager.Log($"Popping out AppBarItem '{appBarItem.GetType().Name}'.");
            CurrentAppBarItem = null;
        }

        /// <summary>
        /// Pushes the task item.
        /// </summary>
        /// <param name="taskBarItem">The task bar item.</param>
        /// <returns></returns>
        public TaskItem PushTaskItem(TaskItem taskBarItem)
        {
            InvokeUI(() =>
            {
                TaskItems.Add(taskBarItem);
                RaisePropertyChanged(nameof(HasTaskItems));
            });
            return taskBarItem;
        }

        /// <summary>
        /// Handles the Push Task Item event.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public TaskItem PushTaskItem<T>() where T : TaskItem
        {
            return PushTaskItem(Activator.CreateInstance<T>());
        }

        /// <summary>
        /// Pushes the task item with the specified message.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="canCancel">Indicates whether the cancel button will be enabled.</param>
        /// <param name="cancelAction">Specify the action to execute when cancel button is pressed.</param>
        /// <returns></returns>
        public TaskItem PushTaskItem(String message, bool canCancel = false, Action cancelAction = null)
        {
            if (canCancel || cancelAction != null)
            {
                return PushTaskItem(new TaskItem(message, cancelAction));
            }
            else
            {
                return PushTaskItem(new TaskItem(message));
            }
        }

        /// <summary>
        /// Pops the task item.
        /// </summary>
        /// <param name="taskBarItem"></param>
        public void PopTaskItem(TaskItem taskBarItem)
        {
            InvokeUI(() =>
            {
                TaskItems.Remove(taskBarItem);
                RaisePropertyChanged(nameof(HasTaskItems));
            });
        }

        /// <summary>
        /// Pushes the app button.
        /// </summary>
        /// <param name="appButton">The app button.</param>
        public void PushAppButton(AppButton appButton)
        {
            _appButtons.Insert(0, appButton);
            CurrentAppButton = appButton;
        }

        /// <summary>
        /// Pops the app button.
        /// </summary>
        /// <param name="appButton">The app button.</param>
        public void PopAppButton(AppButton appButton)
        {
            _appButtons.RemoveAll(x => x == appButton);

            CurrentAppButton = _appButtons.FirstOrDefault();
        }

        /// <summary>
        /// Pushes the snack bar item.
        /// </summary>
        /// <param name="snackbarItem">The snack bar item.</param>
        /// <returns></returns>
        public SnackbarItem PushSnackbarItem(SnackbarItem snackbarItem)
        {
            InvokeUI(() =>
            {
                SnackbarItems.Insert(0, snackbarItem);
                RaisePropertyChanged(nameof(HasSnackbarItems));
            });
            return snackbarItem;
        }

        /// <summary>
        /// Pushes the snack bar item.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="title">The title.</param>
        /// <param name="canClose">if set to <c>true</c> [can close].</param>
        /// <param name="message">The message.</param>
        /// <param name="timeout">The timeout.</param>
        /// <param name="closeAction">The close action.</param>
        /// <param name="pressAction">The press action.</param>
        /// <returns></returns>
        public SnackbarItem PushSnackbarItem(MessageType type, String title, bool canClose, String message = null, TimeSpan? timeout = null, Action closeAction = null, Action pressAction = null)
        {
            if (pressAction == null && (type == MessageType.Error || type == MessageType.Warning))
            {
                pressAction = () =>
                {
                    if (type == MessageType.Error)
                    {
                        ShowError((title.EndsWith(".") ? title : title + ".") + "\n" + message);
                    }
                    else if (type == MessageType.Warning)
                    {
                        ShowError((title.EndsWith(".") ? title : title + ".") + "\n" + message);
                    }
                };
            }

            return PushSnackbarItem(new SnackbarItem(type, title, canClose, message, timeout, closeAction, pressAction));
        }

        /// <summary>
        /// Display a new error SnackBar. Pressing the snack bar will display the issue reporting dialog.
        /// </summary>
        /// <param name="exception">The exception.</param>
        /// <param name="title">The title.</param>
        /// <param name="message">The message.</param>
        /// <param name="messageType">The message type.</param>
        /// <returns></returns>
        public SnackbarItem PushErrorReportingSnackbar(Exception exception, String title, String message, MessageType messageType = MessageType.BugReport)
        {
            String exceptionText = exception.ToString();

            if (!_reportedExceptions.Contains(exceptionText))
            {
                _reportedExceptions.Add(exceptionText);

                return PushSnackbarItem(messageType, title, true, $"{message}\nTap to report this issue.", null, null, () =>
                 {
                     BugReporter.ShowBugReportDialog(new Bug()
                     {
                         Type = BugType.FSE,
                         Description = message,
                         Exception = exception,
                         Title = title + " - " + message,
                     });
                 });
            }
            else
            {
                return PushSnackbarItem(messageType == MessageType.BugReport ? MessageType.Error : messageType, title, true, $"{message}.", TimeSpan.FromSeconds(10), null, () =>
                {
                    ShowInfo("This error has been reported to the development team.");
                });
            }
        }

        /// <summary>
        /// Displays a indeterminate progress Snackbar. Should use <see cref="M:Tango.FSE.Common.Notifications.SnackbarItem.ProgressCompleted(System.String,System.Nullable{System.TimeSpan})" /> and <see cref="M:Tango.FSE.Common.Notifications.SnackbarItem.ProgressFailed(System.String,System.Nullable{System.TimeSpan})" />.
        /// </summary>
        /// <param name="title">The title.</param>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public SnackbarItem PushProgressSnackbar(String title, String message)
        {
            SnackbarItem item = new SnackbarItem(MessageType.Busy, title, false, message, null, () => { }, () => { });
            item.IsProgress = true;
            PushSnackbarItem(item);
            return item;
        }

        /// <summary>
        /// Pops the snack bar item.
        /// </summary>
        /// <param name="snackbarItem">The snack bar item.</param>
        public void PopSnackbarItem(SnackbarItem snackbarItem)
        {
            InvokeUI(() =>
            {
                SnackbarItems.Remove(snackbarItem);
                RaisePropertyChanged(nameof(HasSnackbarItems));
            });
        }

        /// <summary>
        /// Called when is ready and user is logged-in. (happens every time a user logs-in)
        /// </summary>
        /// <param name="applicationManager"></param>
        public void OnApplicationReady(IFSEApplicationManager applicationManager)
        {
            if (applicationManager.DemoMode)
            {
                DemoModeManager.InsertCommand(() =>
                {
                    ShowInfo("This is a standard information message.");
                }, "Emulate Info Message", "Emulates a standard information message box.");

                DemoModeManager.InsertCommand(() =>
                {
                    ShowWarning("Something bad is about to happen.");
                }, "Emulate Warning Message", "Emulates a standard warning message box.");

                DemoModeManager.InsertCommand(() =>
                {
                    ShowWarningQuestion("Something bad is about to happen. Are you sure?");
                }, "Emulate Warning Question Message", "Emulates a standard warning question message box.");

                DemoModeManager.InsertCommand(() =>
                {
                    ShowError("Something bad happened.");
                }, "Emulate Error Message", "Emulates a standard error message box.");

                DemoModeManager.InsertCommand(() =>
                {
                    ShowSuccess("The operation completed successfully.");
                }, "Emulate Success Message", "Emulates a standard success message box.");

                DemoModeManager.InsertCommand(() =>
                {
                    PushSnackbarItem(MessageType.Info, "Some Information", true, "This is a standard information message.\nTap to see more details.", TimeSpan.FromSeconds(5), null, () =>
                    {
                        ShowInfo("This is a standard information message.");
                    });
                }, "Emulate Info Snackbar", "Creates an information snackbar with timeout and press action.");

                DemoModeManager.InsertCommand(() =>
                {
                    PushSnackbarItem(MessageType.Warning, "Some Warning", true, "This is a standard warning message.\nTap to see more details.", TimeSpan.FromSeconds(5), null, () =>
                    {
                        ShowWarning("This is a standard warning message.");
                    });
                }, "Emulate Warning Snackbar", "Creates a warning snackbar with timeout and press action.");

                DemoModeManager.InsertCommand(() =>
                {
                    PushSnackbarItem(MessageType.Error, "Fake Error Occurred", false, "This is a standard error message.\nTap to see more details.", null, null, () =>
                     {
                         ShowError("This is a standard warning message.");
                     });
                }, "Emulate Error Snackbar", "Creates an error snackbar with no timeout and no ability to close.");

                DemoModeManager.InsertCommand(() =>
                {
                    PushSnackbarItem(MessageType.Success, "Operation Completed", true, "This is a standard success message.\nTap to close", TimeSpan.FromSeconds(5));
                }, "Emulate Success Snackbar", "Creates a success snackbar with timeout and close press action.");

                DemoModeManager.InsertCommand(() =>
                {
                    var snackbar = PushProgressSnackbar("Background Operation", "The application is doing stuff in the background...");

                    Task.Factory.StartNew(() =>
                    {
                        for (int i = 0; i < 100; i++)
                        {
                            snackbar.Message = $"The application is doing stuff in the background ({i}/100)...";
                            Thread.Sleep(50);
                        }

                        snackbar.ProgressCompleted("Operation completed.", TimeSpan.FromSeconds(2));
                    });

                }, "Emulate Progress Snackbar", "Creates a success snackbar with timeout and close press action.");

                DemoModeManager.InsertCommand(() =>
                {
                    throw new TimeoutException("This is a fake exception.");
                }, "Emulate Bug Reporting Error", "Creates a snackbar notification with a fake error and bug reporting option.");
            }
        }
    }
}