/// <summary>Initializes a new instance of the <see cref="Shell"/> class.</summary>
        /// <param name="msgBoxService">The msg Box Service.</param>
        /// <param name="eventAggregator"></param>
        /// <param name="commands">The commands.</param>
        /// <param name="fileManagerService">The file Manager Service.</param>
        /// <param name="buttonsCommands">The buttons Commands.</param>
        public Shell(
            IMessageBoxService msgBoxService,
            IEventAggregator eventAggregator,
            List<IToolbarCommand> commands,
            IFileManagerService fileManagerService,
            List<IButtonsCommand> buttonsCommands)
        {
            this.InitializeComponent();

            // Wire up our view presenters
            var toolbarButtonsView = new ToolbarView { Dock = DockStyle.Top };
            var toolbarViewPresenter = new ToolbarPresenter(toolbarButtonsView, commands);

            var buttonCommandView = new ButtonView { Dock = DockStyle.Bottom };
            var buttonCommandViewPresenter = new ButtonsPresenter(buttonCommandView, buttonsCommands);

            var levelsTreeView = new LevelsView { Dock = DockStyle.Fill };
            var levelsTreeViewPresenter = new LevelsViewPresenter(levelsTreeView, msgBoxService, eventAggregator);

            var infoView = new InformationView { Dock = DockStyle.Fill };
            var inforViewPresenter = new InformationViewPresenter(infoView);

            // Wire up our views
            this.toolbarView = toolbarButtonsView;
            this.buttonView = buttonCommandView;
            this.levelsView = levelsTreeView;
            this.informationView = infoView;

            // Wire up our event messaging
            this.aggregator = eventAggregator;
            this.aggregator.GetEvent<CloseShellMessage>().Subscribe(this.OnCloseShell);

            // Place the views in the correct regions
            this.InjectViews();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseController" /> class.
        /// </summary>
        /// <param name="visualStudioService">The visual studio service.</param>
        /// <param name="readMeService">The read me service.</param>
        /// <param name="settingsService">The settings service.</param>
        /// <param name="messageBoxService">The message box service.</param>
        /// <param name="dialogService">The dialog service.</param>
        /// <param name="formsService">The forms service.</param>
        protected BaseController(
            IVisualStudioService visualStudioService,
            IReadMeService readMeService,
            ISettingsService settingsService,
            IMessageBoxService messageBoxService,
            IDialogService dialogService,
            IFormsService formsService)
        {
            //// init the tracing service first!
            TraceService.Initialize(
                settingsService.LogToTrace,
                false, //// log to console.
                settingsService.LogToFile,
                settingsService.LogFilePath,
                settingsService.DisplayErrors);

            TraceService.WriteLine("BaseController::Constructor");

            this.VisualStudioService = visualStudioService;
            this.ReadMeService = readMeService;
            this.SettingsService = settingsService;
            this.MessageBoxService = messageBoxService;
            this.DialogService = dialogService;
            this.FormsService = formsService;
        }

        public MainWindowViewModel()
        {
            #region Obtain Services
            try
            {
                messageBoxService = Resolve<IMessageBoxService>();
                openFileService = Resolve<IOpenFileService>();
            }
            catch
            {
                Logger.Error( "Error resolving services");
                throw new ApplicationException("Error resolving services");
            }
            #endregion

            #region Commands

            //New VM Command
            newVMCommand = new SimpleCommand
            {
                CanExecuteDelegate = x => CanExecuteNewVMCommand,
                ExecuteDelegate = x => ExecuteNewVMCommand()
            };


            //Open VM Command
            openVMCommand = new SimpleCommand
            {
                CanExecuteDelegate = x => CanExecuteOpenVMCommand,
                ExecuteDelegate = x => ExecuteOpenVMCommand()
            };
            #endregion


        }

        public ProjectIssuesViewModel(IUnityContainer container)
        {
            HeaderTitle = "Issues";

            _container = container;
            _context = _container.Resolve<TeamManagerDomainContext>("TM_DB");
            _modalDialogService = _container.Resolve<IModalDialogService>();
            _messageBoxService = _container.Resolve<IMessageBoxService>();

            Messanger.Get<ProjectSelectionMessage>().Subscribe(OnSelectedProjectChanged);

            GroupCriteria = new ObservableCollection<GroupItem>(new List<GroupItem>
                                                                    {
                                                                        new GroupItem("Tracker", "Tracker.Name"),
                                                                        new GroupItem("Priority", "Priority.Name"),
                                                                        new GroupItem("Creator", "Creator.UserName"),
                                                                        new GroupItem("Assigned member", "AssignedUser.UserName"),
                                                                    });

            EditIssueCommand = new DelegateCommand<Issue>(ExecuteEditIssue, issue => true);
            CreateIssueCommand = new DelegateCommand(ExecuteCreateIssue, CanExecuteCreateIssue);
            DeleteIssueCommand = new DelegateCommand<Issue>(ExecuteDeleteIssue, issue => true);
            OpenIssueCommand = new DelegateCommand<Issue>(ExecuteIssueNavigate, issue => true);
            GroupChangedCommand = new DelegateCommand<SelectionChangedEventArgs>(GroupChangedHandler, e => true);
            ClearGroupingCommand = new DelegateCommand(ClearGroupingExecute, () => true);
        }

        public MainViewModel(IFileDialogService fileDialogService, IMessageBoxService messageBoxService, IDirtyService dirtyService, IViewService viewService, ILifetimeScope lifetimeScope)
        {
            if (fileDialogService == null) throw new ArgumentNullException(nameof(fileDialogService));
            if (messageBoxService == null) throw new ArgumentNullException(nameof(messageBoxService));
            if (dirtyService == null) throw new ArgumentNullException(nameof(dirtyService));
            if (viewService == null) throw new ArgumentNullException(nameof(viewService));
            if (lifetimeScope == null) throw new ArgumentNullException(nameof(lifetimeScope));
            

            _fileDialogService = fileDialogService;
            _messageBoxService = messageBoxService;
            _dirtyService = dirtyService;
            _viewService = viewService;
            _lifetimeScope = lifetimeScope;
            

            dirtyService.PropertyChanged += DirtyService_PropertyChanged;

            NewCommand = new RelayCommand(New);
            OpenCommand = new RelayCommand(Open);
            SaveCommand = new RelayCommand(() => Save(), CanSave);
            SaveAsComand = new RelayCommand(() => SaveAs());
            ExitCommand = new RelayCommand(Exit);
            AboutCommand = new RelayCommand(About);
        }

        /// <summary>Initializes a new instance of the <see cref="ShellViewPresenter"/> class.</summary>
        /// <param name="shell">The shell.</param>
        /// <param name="msgBoxService">The msg Box Service.</param>
        /// <param name="fileBrowserService">The file Browser Service.</param>
        /// <param name="eventAggregator">The event Aggregator.</param>
        /// <param name="systemInformationService">The system Information Service.</param>
        public ShellViewPresenter(
            IShellView shell, 
            IMessageBoxService msgBoxService, 
            IFileBrowserService fileBrowserService, 
            IEventAggregator eventAggregator, 
            ISystemInformationService systemInformationService)
        {
            // Wire up our services
            this.msgBoxService = msgBoxService;
            this.fileBrowserService = fileBrowserService;
            this.eventAggregator = eventAggregator;
            this.systemInformationService = systemInformationService;

            // Wire up our view
            this.view = shell;

            // Wire up view our events
            shell.FormClosed += this.ViewOnFormClosed;
            shell.Load += this.ViewOnLoad;
            shell.KeyUp += this.ViewOnKeyUp;
            shell.HelpRequested += this.ViewOnHelpRequested;

            // WindowHandle high contrast
            if (!this.systemInformationService.IsHighContrastColourScheme)
            {
                shell.BackColor = Color.White;
            }
        }

        public OrderViewModel(
            Order order, 
            IMessageBoxService messageBoxService, 
            OrderServiceInvoker orderServiceInvoker)
        {
            this.messageBoxService = messageBoxService;
            this.orderServiceInvoker = orderServiceInvoker;
            this.Order = order;

            this.GotoEditModeCommand = new SimpleCommand<object, object>(
                x => !this.IsEnabled,
                ExecuteGotoEditModeCommand
            );

            this.DeleteOrderCommand = new SimpleCommand<object, object>(
                x => !this.IsEnabled && !operationInFlight,
                ExecuteDeleteOrderCommand
            );

            this.CancelEditModeCommand = new SimpleCommand<object, object>(
                x => this.IsEnabled,
                ExecuteCancelEditModeCommand
            );

            this.ChangeOrderAddressCommand = new SimpleCommand<object, object>(
                x => this.IsEnabled && !operationInFlight,
                ExecuteChangeOrderAddressCommand
            );
        }

        /// <summary>Initializes a new instance of the <see cref="LevelsViewPresenter"/> class.</summary>
        /// <param name="view">The view.</param>
        /// <param name="msgBoxService">The msg box service.</param>
        /// <param name="fileBrowserService">The file browser service.</param>
        /// <param name="eventAggregator">The event aggregator.</param>
        /// <param name="fileManagerService">The file Manager Service.</param>
        /// <param name="strategyService"></param>
        public LevelsViewPresenter(
            ILevelsView view,
            IMessageBoxService msgBoxService,
            IFileBrowserService fileBrowserService,
            IEventAggregator eventAggregator,
            IFileManagerService fileManagerService,
            IStrategyService strategyService)
        {
            // Wire up our services
            this.msgBoxService = msgBoxService;
            this.fileBrowserService = fileBrowserService;
            this.fileManagerService = fileManagerService;
            this.eventAggregator = eventAggregator;
            this.strategyService = strategyService;

            this.view = view;

            view.ViewLoad += this.LevelsViewOnViewLoad;
            view.SelectionChanged += this.LevelsViewOnSelectionChanged;
            view.LevelDrag += this.OnLevelItemDrag;
            view.LevelDragDrop += this.OnLevelDragDrop;
            view.LevelDragEnter += this.OnLevelDragEnter;

            view.Tree.AllowDrop = true;

            this.eventAggregator.GetEvent<SaveLevelsMessage>().Subscribe(this.OnSaveLevels);
            this.eventAggregator.GetEvent<AddLevelMessage>().Subscribe(this.OnAddLevel);
            this.eventAggregator.GetEvent<RemoveLevelMessage>().Subscribe(this.OnRemoveLevel);
            this.eventAggregator.GetEvent<OpenPartMessage>().Subscribe(this.OnOpenParts);
            this.eventAggregator.GetEvent<SaveStrategyMessage>().Subscribe(this.OnSaveStrategyEvent);
            this.eventAggregator.GetEvent<OpenStrategyMessage>().Subscribe(this.OnLoadStrategyEvent);
            this.eventAggregator.GetEvent<OpenLevelsMessage>().Subscribe(this.OnOpenLevelsEvent);
        }

        public ReservationDashBoardViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService)
        {
            this._logger = logger;
            this._container = container;
            this._reservationManager = reservationManager;
            this._tableManager = tableManager;
            this._messageBoxService = messageBoxService;
            this._dialogBoxService = dialogBoxService;
            this._reservationHours = new ObservableCollection<ReservationHour>();
            this._reservations = new MappedValueCollection();


            this.AddCommand = new DelegateCommand(this.OnAddCommand, () => { return this._noOfPersons > 0; });
            this.BrowseCommand = new DelegateCommand(this.OnBrowseCommand);
            this.ImportCommand = new DelegateCommand(this.OnImportCommand, () => { return !string.IsNullOrEmpty(this._tableXMLFile); });

            this._tables = this._tableManager.GetAll();
            
            // Assumption : Reservation duration is between 10 Am and 10 Pm
            this._minFromHour = 10;
            this._maxFromHour = 22;

            for (int hour = this._minFromHour; hour <= this._maxFromHour; hour++)
            {
                this._reservationHours.Add(new ReservationHour(hour));
            }

            this.FromHour = this._minFromHour;

            TableReservation.Common.ReservationsUpdatedEvent.Instance.Subscribe(this.ReservationsUpdated);
            this.ReservationsUpdated(Guid.NewGuid());
        }

        /// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        /// <param name="listViews">A list of views to display.</param>
        /// <param name="messageBoxService">A message box service.</param>
        /// <param name="itemService">An item service.</param>
        /// <param name="navigationService">A navigation service.</param>
        public MainViewModel(IEnumerable<object> listViews, IMessageBoxService messageBoxService,
			IItemService itemService, INavigationService navigationService)
        {
            if (messageBoxService == null)
                throw new ArgumentNullException("messageBoxService");
            if (itemService == null)
                throw new ArgumentNullException("itemService");
            if (navigationService == null)
                throw new ArgumentNullException("navigationService");

            _messageBoxService = messageBoxService;
            _itemService = itemService;
            _navigationService = navigationService;

            _listViews = new ObservableCollection<object>();

            if (listViews != null)
            {
                foreach (object obj in listViews)
                {
                    _listViews.Add(obj);
                }
            }

            RegisterForMessages();
        }

 public VideoQueryForm(IMessageBoxService messageBoxService)
     : this()
 {
     if (messageBoxService == null)
         throw new ArgumentNullException("messageBoxService", "messageBoxService is null.");
     _messageBoxService = messageBoxService;
 }

        //====================================================================================================
        public AddBookingViewModel(IMessageBoxService mboxService, IConfigService configService, 
            IParentVm parent, Booking model)
        {
            _parent = parent;
            _mboxService = mboxService;
            _configService = configService;

            //Get Configuration
            AvailableDurations = _configService.GetAvailableDurations();

            //Set Commands
            SubmitCommand = new ActionCommand(OnSubmit, _=>_isFormValid);
            CancelCommand = new ActionCommand(OnCancel);

            //Set up the screen for Add or Display.
            if (model.Id == -1)
            {
                Model = model;
                Caption = "Add New Booking";
                IsAddMode = true;
            }
            else
            {
                Model = model;
                Caption = "Existing Booking";
                IsAddMode = false;
            }
        }

 public MainViewModel(IMarketplaceInformationService marketplaceInformationService, IMessageBoxService messageBoxService,
     IMarketplaceDetailService marketplaceDetailService)
 {
     _marketplaceInformationService = marketplaceInformationService;
     _messageBoxService = messageBoxService;
     _marketplaceDetailService = marketplaceDetailService;
 }

        public View2(IMessageBoxService messageBoxService)
        {
            _messageBoxService = messageBoxService;
            InitializeComponent();

            //button6.Click += (s, e) =>
            //                    {
            //                        _messageBoxService.ShowMessage("trala");
            //                    };
            button6.Click += (s, e) => _messageBoxService.ShowMessage("trala");

            //var lst = new List<Action>();
            //for(int i=0;i<5;++i)
            //{
            //    //int d = i;
            //    lst.Add(
            //        () => _messageBoxService.ShowMessage(d.ToString())
            //    );
            //}
            //lst.ForEach(e=>e());

            //var lst = new List<_____Anonymous_lambdsa_type_XY>();
            //for (int i = 0; i < 5; ++i)
            //{
            //    lst.Add(
            //        new _____Anonymous_lambdsa_type_XY(ref i, _messageBoxService)
            //    );
            //}
            //lst.ForEach(e => e.Anonymous_function_XX());
        }

        /// <summary>
        /// Initializes a new instance of the TvViewModel class.
        /// </summary>
        public TvViewModel(INavigationService navigationService, IConnectionManager connectionManager, IMessageBoxService messageBox) 
            : base(navigationService, connectionManager)
        {
            _messageBox = messageBox;
            RecentItems = new ObservableCollection<BaseItemDto>();
            Episodes = new List<BaseItemDto>();
            CanUpdateFavourites = true;
            if (IsInDesignMode)
            {
                SelectedTvSeries = new BaseItemDto
                {
                    Name = "Scrubs"
                };
                SelectedSeason = new BaseItemDto
                {
                    Name = "Season 1"
                };
                Episodes = new[]
                {
                    new BaseItemDto
                    {
                        Id = "e252ea3059d140a0274282bc8cd194cc",
                        Name = "1x01 - Pilot",
                        Overview =
                            "A Kindergarten teacher starts speaking gibberish and passed out in front of her class. What looks like a possible brain tumor does not respond to treatment and provides many more questions than answers for House and his team as they engage in a risky trial-and-error approach to her case. When the young teacher refuses any additional variations of treatment and her life starts slipping away, House must act against his code of conduct and make a personal visit to his patient to convince her to trust him one last time."
                    }
                }.ToList();
                SelectedEpisode = Episodes[0];

            }
            else
            {
                WireCommands();
            }
        }

        /// <summary>
        /// Initializes a new instance of the PushViewModel class.
        /// </summary>
        public SettingsViewModel(
            IConnectionManager connectionManager,
            INavigationService navigationService,
            IApplicationSettingsService applicationSettings, 
            IMessageBoxService messageBox,
            IServerInfoService serverInfo)
            : base(navigationService, connectionManager)
        {
            _applicationSettings = applicationSettings.Legacy;
            _messageBox = messageBox;
            _serverInfo = serverInfo;

            if (IsInDesignMode)
            {
                FoundServers = new ObservableCollection<ServerInfo>
                {
                    new ServerInfo{Id = Guid.NewGuid().ToString(), Name = "Home", LocalAddress = "http://192.168.0.2:8096"}
                };
            }
            else
            {
                LoadingFromSettings = true;
                SendTileUpdates = SendToastUpdates = true;
                RegisteredText = AppResources.DeviceNotRegistered;
                LoadingFromSettings = false;

                SetStreamingQuality();

                _ignoreRunUnderLockChanged = true;
                RunUnderLock = App.SpecificSettings.PlayVideosUnderLock;
                _ignoreRunUnderLockChanged = false;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PluginsController" /> class.
        /// </summary>
        /// <param name="fileSystem">The file system.</param>
        /// <param name="pluginsService">The plugins service.</param>
        /// <param name="nugetService">The nuget service.</param>
        /// <param name="visualStudioService">The visual studio service.</param>
        /// <param name="readMeService">The read me service.</param>
        /// <param name="settingsService">The settings service.</param>
        /// <param name="messageBoxService">The message box service.</param>
        /// <param name="dialogService">The dialog service.</param>
        /// <param name="formsService">The forms service.</param>
        /// <param name="translator">The translator.</param>
        public PluginsController(
            IFileSystem fileSystem,
            IPluginsService pluginsService,
            INugetService nugetService,
            IVisualStudioService visualStudioService,
            IReadMeService readMeService,
            ISettingsService settingsService,
            IMessageBoxService messageBoxService,
            IDialogService dialogService,
            IFormsService formsService,
            ITranslator<Tuple<DirectoryInfoBase, DirectoryInfoBase>, Plugins> translator)
            : base(visualStudioService, 
            readMeService, 
            settingsService, 
            messageBoxService,
            dialogService,
            formsService)
        {
            TraceService.WriteLine("PluginsController::Constructor");

            this.fileSystem = fileSystem;
            this.pluginsService = pluginsService;
            this.nugetService = nugetService;
            this.translator = translator;
        }

 public void SetUp()
 {
     _model = Substitute.For<ILoginModel>();
     _messageService = Substitute.For<IMessageBoxService>();
     _wos = Substitute.For<IWindowOpeningService>();
     _uut = new LoginViewModel(_model, _messageService, _wos);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProjectsController" /> class.
        /// </summary>
        /// <param name="configurationService">The configuration service.</param>
        /// <param name="projectsService">The projects service.</param>
        /// <param name="nugetService">The nuget service.</param>
        /// <param name="visualStudioService">The visual studio service.</param>
        /// <param name="readMeService">The read me service.</param>
        /// <param name="settingsService">The settings service.</param>
        /// <param name="messageBoxService">The message box service.</param>
        /// <param name="mockingServiceFactory">The mocking service factory.</param>
        /// <param name="resolverService">The resolver service.</param>
        /// <param name="viewModelViewsService">The view model views service.</param>
        /// <param name="viewModelAndViewsFactory">The view model and views factory.</param>
        public ProjectsController(
            IConfigurationService configurationService,
            IProjectsService projectsService,
            INugetService nugetService,
            IVisualStudioService visualStudioService,
            IReadMeService readMeService,
            ISettingsService settingsService,
            IMessageBoxService messageBoxService,
            IMockingServiceFactory mockingServiceFactory,
            IResolverService resolverService,
            IViewModelViewsService viewModelViewsService,
            IViewModelAndViewsFactory viewModelAndViewsFactory)
            : base(configurationService,
            visualStudioService,
            readMeService,
            settingsService,
            messageBoxService,
            resolverService)
        {
            TraceService.WriteLine("ProjectsController::Constructor");

            this.projectsService = projectsService;
            this.nugetService = nugetService;
            this.viewModelViewsService = viewModelViewsService;
            this.viewModelAndViewsFactory = viewModelAndViewsFactory;
            this.mockingService = mockingServiceFactory.GetMockingService();
        }

 public TileViewModelBase(
     IRegionManager regionManager,
     IMessageBoxService messageBoxService)
 {
     this.regionManager = regionManager;
     this.messageBoxService = messageBoxService;
     CloseViewCommand = new SimpleCommand<object, object>(ExecuteCloseViewCommand);
 }