private void StartSearch(Client client, SearchInformation info)
        {
            client.SetNewSearch(info);
            client.MoveToCatalog();

            this.CurrentSearch.Value = SearchInformation.GenerateEmpty();
            if (!this.HasFavoriteSearch(info))
            {
                this.SelectedTab.Value = TabMode.History;
            }
        }
        public SearchPageViewModel(ClientWindowViewModel parent)
        {
            this.parent = parent;
            var client  = parent.Client;
            var library = parent.Library;
            var core    = parent.Core;

            var searcher = library.Searcher;

            this.HistoryList  = searcher.SearchHistory.ToReadOnlyReactiveCollection().AddTo(this.Disposables);
            this.FavoriteList = searcher.FavoriteSearchList.ToReadOnlyReactiveCollection().AddTo(this.Disposables);

            this.SelectedTab = new ReactiveProperty <TabMode>
                                   ((searcher.FavoriteSearchList.Count > 0 && core.LastSearchedFavorite)
                    ? TabMode.Favorite : TabMode.History)
                               .AddTo(this.Disposables);

            this.SelectedTab
            .Subscribe(x => core.LastSearchedFavorite = (x == TabMode.Favorite))
            .AddTo(this.Disposables);

            this.IsEditing = new ReactiveProperty <bool>(false).AddTo(this.Disposables);


            this.SelectHistoryCommand  = new ReactiveCommand().AddTo(this.Disposables);
            this.SelectFavoriteCommand = new ReactiveCommand().AddTo(this.Disposables);

            var hitoryItem = this.SelectHistoryCommand
                             .OfType <SearchInformation>()
                             .Select(x => x.Clone());

            var favoriteItem = this.SelectFavoriteCommand
                               .OfType <SearchInformation>();

            this.CurrentSearch = Observable
                                 .Merge(hitoryItem, favoriteItem)//, newItem)
                                 .ToReactiveProperty(SearchInformation.GenerateEmpty())
                                 .AddTo(this.Disposables);

            this.CurrentSearch
            .Subscribe(x => this.IsEditing.Value = (x != null && !x.Key.IsNullOrEmpty()))
            .AddTo(this.Disposables);

            this.IsThumbnailVisible = this.CurrentSearch
                                      .Select(x => x.DateLastUsed > default(DateTimeOffset))
                                      .ToReadOnlyReactiveProperty()
                                      .AddTo(this.Disposables);

            searcher.FavoriteSearchList
            .ObserveAddChanged()
            .Subscribe(x =>
            {
                if (this.CurrentSearch.Value == x)
                {
                    this.SelectedTab.Value = TabMode.Favorite;
                }
            })
            .AddTo(this.Disposables);

            searcher.FavoriteSearchList
            .ObserveRemoveChanged()
            .Subscribe(x =>
            {
                if (this.CurrentSearch.Value == x && this.SelectedTab.Value == TabMode.Favorite)
                {
                    this.CurrentSearch.Value = SearchInformation.GenerateEmpty();
                }
            })
            .AddTo(this.Disposables);

            this.CurrentSearchType = this.HistoryList
                                     .CollectionChangedAsObservable()
                                     .Merge(this.FavoriteList.CollectionChangedAsObservable())
                                     .Select(_ => this.CurrentSearch.Value)
                                     .Merge(this.CurrentSearch)
                                     .Select(x => this.HasFavoriteSearch(x) ? 1
                    : this.HasHistorySearch(x) ? 0 : 2)
                                     .ToReadOnlyReactiveProperty()
                                     .AddTo(this.Disposables);

            this.IsFavoriteSearch = this.CurrentSearchType
                                    .Select(x => x == 1)
                                    .ToReadOnlyReactiveProperty()
                                    .AddTo(this.Disposables);


            this.ClickHistoryCommand  = new ReactiveCommand().AddTo(this.Disposables);
            this.ClickFavoriteCommand = new ReactiveCommand().AddTo(this.Disposables);

            this.ClickHistoryCommand
            .Select(x => x as SearchInformation)
            .Where(x => x != null)
            .Subscribe(x =>
            {
                if (!this.IsEditing.Value ||
                    this.CurrentSearch.Value == null ||
                    this.CurrentSearch.Value.Key.IsNullOrEmpty() ||
                    this.CurrentSearch.Value.Key.Equals(x.Key))
                {
                    this.StartSearch(client, x);
                }
                else
                {
                    this.SelectHistoryCommand.Execute(x);
                }
            })
            .AddTo(this.Disposables);

            this.ClickFavoriteCommand
            .Select(x => x as SearchInformation)
            .Where(x => x != null)
            .Subscribe(x =>
            {
                if (!this.IsEditing.Value ||
                    this.CurrentSearch.Value == null ||
                    this.CurrentSearch.Value.Key.IsNullOrEmpty() ||
                    this.CurrentSearch.Value.Key.Equals(x.Key))
                {
                    this.StartSearch(client, x);
                }
                else
                {
                    this.SelectFavoriteCommand.Execute(x);
                }
            })
            .AddTo(this.Disposables);

            this.StartSearchCommand = new ReactiveCommand()
                                      .WithSubscribe(_ => this.StartSearch(client, this.CurrentSearch.Value), this.Disposables);

            this.AddCriteriaCommand = new ReactiveCommand()
                                      .WithSubscribe(_ => this.EditSearch(this.CurrentSearch.Value.Root), this.Disposables);

            this.ItemClickCommand = new ReactiveCommand()
                                    .WithSubscribe(item =>
            {
                var search = item as ISqlSearch;

                if (search != null)
                {
                    this.EditSearch(search);
                }
            }, this.Disposables);

            this.AddToFavoriteCommand = new ReactiveCommand()
                                        .WithSubscribe(_ =>
            {
                var item = this.CurrentSearch.Value;
                if (item == null)
                {
                    return;
                }

                if (this.HasFavoriteSearch(item))
                {
                    searcher.MarkSearchUnfavorite(item);
                }
                else
                {
                    searcher.MarkSearchFavorite(item);
                }
            }, this.Disposables);


            this.SwitchModeCommand = new ReactiveCommand()
                                     .WithSubscribe(_ =>
            {
                var item = this.CurrentSearch.Value;
                if (item == null)
                {
                    return;
                }

                item.Root.IsOr = !item.Root.IsOr;
            }, this.Disposables);

            this.NewSearchCommand = new ReactiveCommand()
                                    .WithSubscribe(_ => this.CurrentSearch.Value = SearchInformation.GenerateEmpty(),
                                                   this.Disposables);

            this.ShowFavoriteCommand = new ReactiveCommand()
                                       .WithSubscribe(_ => this.SelectedTab.Value = TabMode.Favorite, this.Disposables);
            this.ShowHistoryCommand = new ReactiveCommand()
                                      .WithSubscribe(_ => this.SelectedTab.Value = TabMode.History, this.Disposables);
        }