CodeExplorerViewModel.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using NLog;
using Rubberduck.Parsing.Symbols;
using Rubberduck.Parsing.VBA;
using Rubberduck.Settings;
using Rubberduck.SettingsProvider;
using Rubberduck.UI;
using Rubberduck.UI.CodeExplorer.Commands;
using Rubberduck.UI.Command;
using Rubberduck.VBEditor.SafeComWrappers;
using System.Windows;
using System.Windows.Input;
using Rubberduck.Parsing.UIContext;
using Rubberduck.Templates;
using Rubberduck.UI.UnitTesting.Commands;
using Rubberduck.VBEditor.SafeComWrappers.Abstract;

// ReSharper disable ExplicitCallerInfoArgument

namespace Rubberduck.Navigation.CodeExplorer
{
    [Flags]
    public enum CodeExplorerSortOrder
    {
        Undefined = 0,
        Name = 1,
        CodeLine = 1 << 2,
        DeclarationType = 1 << 3,
        DeclarationTypeThenName = DeclarationType | Name,
        DeclarationTypeThenCodeLine = DeclarationType | CodeLine
    }

    [SuppressMessage("ReSharper", "InconsistentNaming")]
    public sealed class CodeExplorerViewModel : ViewModelBase
    {
        // ReSharper disable NotAccessedField.Local - The settings providers aren't used, but several enhancement requests will need them.
        private readonly RubberduckParserState _state;
        private readonly RemoveCommand _externalRemoveCommand;
        private readonly IConfigProvider<GeneralSettings> _generalSettingsProvider;      
        private readonly IConfigProvider<WindowSettings> _windowSettingsProvider;
        private readonly IUiDispatcher _uiDispatcher;
        private readonly IVBE _vbe;
        private readonly ITemplateProvider _templateProvider;
        // ReSharper restore NotAccessedField.Local

        public CodeExplorerViewModel(
            RubberduckParserState state,
            RemoveCommand removeCommand,
            IConfigProvider<GeneralSettings> generalSettingsProvider, 
            IConfigProvider<WindowSettings> windowSettingsProvider, 
            IUiDispatcher uiDispatcher,
            IVBE vbe,
            ITemplateProvider templateProvider,
            ICodeExplorerSyncProvider syncProvider)
        {
            _state = state;
            _state.StateChanged += HandleStateChanged;
            _state.ModuleStateChanged += ParserState_ModuleStateChanged;

            _externalRemoveCommand = removeCommand;
            _generalSettingsProvider = generalSettingsProvider;
            _windowSettingsProvider = windowSettingsProvider;
            _uiDispatcher = uiDispatcher;
            _vbe = vbe;
            _templateProvider = templateProvider;

            CollapseAllSubnodesCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteCollapseNodes, EvaluateCanSwitchNodeState);
            ExpandAllSubnodesCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteExpandNodes, EvaluateCanSwitchNodeState);
            ClearSearchCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteClearSearchCommand);
            if (_externalRemoveCommand != null)
            {
                RemoveCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteRemoveCommand, _externalRemoveCommand.CanExecute);
            }

            OnPropertyChanged("Projects");

            SyncCodePaneCommand = syncProvider.GetSyncCommand(this);
            // Force a call to EvaluateCanExecute
            OnPropertyChanged("SyncCodePaneCommand");
        }

        public ObservableCollection<ICodeExplorerNode> Projects { get; } = new ObservableCollection<ICodeExplorerNode>();

        public ObservableCollection<Template> BuiltInTemplates =>
            new ObservableCollection<Template>(_templateProvider.GetTemplates().Where(t => !t.IsUserDefined)
                .OrderBy(t => t.Name));

        public ObservableCollection<Template> UserDefinedTemplates =>
            new ObservableCollection<Template>(_templateProvider.GetTemplates().Where(t => t.IsUserDefined)
                .OrderBy(t => t.Name));

        private ICodeExplorerNode _selectedItem;
        public ICodeExplorerNode SelectedItem
        {
            get => _selectedItem;
            set
            {
                if (_selectedItem == value)
                {
                    return;
                }

                _selectedItem = value;
                ExpandToNode(value);

                OnPropertyChanged();

                OnPropertyChanged("ExportVisibility");
                OnPropertyChanged("ExportAllVisibility");
            }
        }

        public bool AnyTemplatesCanExecute =>
            BuiltInTemplates.Concat(UserDefinedTemplates)
                .Any(template => AddTemplateCommand.CanExecuteForNode(SelectedItem));

        private CodeExplorerSortOrder _sortOrder = CodeExplorerSortOrder.Name;
        public CodeExplorerSortOrder SortOrder
        {
            get => _sortOrder;
            set
            {
                if (_sortOrder == value)
                {
                    return;
                }

                _sortOrder = value;

                foreach (var project in Projects.OfType<CodeExplorerProjectViewModel>())
                {
                    project.SortOrder = _sortOrder;
                }

                OnPropertyChanged();
            }
        }

        private bool _canSearch;
        public bool CanSearch
        {
            get => _canSearch;
            set
            {
                _canSearch = value;
                OnPropertyChanged();
            }
        }

        private bool _isBusy;
        public bool IsBusy
        {
            get => _isBusy;
            set
            {
                _isBusy = value;
                OnPropertyChanged();
            }
        }

        private bool _unparsed = true;
        public bool Unparsed
        {
            get => _unparsed;
            set
            {
                if (_unparsed == value)
                {
                    return;
                }
                _unparsed = value;
                OnPropertyChanged();
            }
        }

        private string _filterText = string.Empty;
        public string Search
        {
            get => _filterText;
            set
            {
                var input = value ?? string.Empty;
                if (_filterText.Equals(input))
                {
                    return;
                }

                _filterText = value;

                foreach (var project in Projects)
                {
                    project.Filter = _filterText;
                }

                OnPropertyChanged();
            }
        }

        private double? _fontSize = 12;
        public double? FontSize
        {
            get => _fontSize ?? 12;
            set
            {
                if (!value.HasValue || value.Equals(_fontSize))
                {
                    return;
                }

                _fontSize = value;
                OnPropertyChanged();
            }
        }

        private void HandleStateChanged(object sender, ParserStateEventArgs e)
        {
            Unparsed = false;

            if (e.State == ParserState.Ready)
            {
                // Finished up resolving references, so we can now update the reference nodes.
                _uiDispatcher.Invoke(() =>
                {
                    var referenceFolders = Projects.SelectMany(node =>
                        node.Children.OfType<CodeExplorerReferenceFolderViewModel>());
                    foreach (var library in referenceFolders)
                    {
                        library.UpdateChildren();
                    }

                    IsBusy = false;
                });
                return;
            }

            IsBusy = _state.Status != ParserState.Pending && _state.Status <= ParserState.ResolvedDeclarations;

            if (e.State != ParserState.ResolvedDeclarations)
            {
                return;
            }

            Synchronize(_state.DeclarationFinder.AllUserDeclarations.ToList());
        }

        private void Synchronize(List<Declaration> declarations)
        {
            _uiDispatcher.Invoke(() =>
            {
                var existing = Projects.OfType<CodeExplorerProjectViewModel>().ToList();

                foreach (var project in existing)
                {
                    project.Synchronize(declarations);
                    if (project.Declaration is null)
                    {
                        Projects.Remove(project);
                    }
                }

                var adding = declarations.OfType<ProjectDeclaration>().ToList();

                foreach (var project in adding)
                {
                    var model = new CodeExplorerProjectViewModel(project, declarations.Where(proj => proj.ProjectId.Equals(project.ProjectId)).ToList(), _state, _vbe);
                    Projects.Add(model);
                }

                CanSearch = Projects.Any();
            });
        }

        private void ParserState_ModuleStateChanged(object sender, ParseProgressEventArgs e)
        {
            // if we are resolving references, we already have the declarations and don't need to display error
            if (!(e.State == ParserState.Error ||
                e.State == ParserState.ResolverError &&
                e.OldState == ParserState.ResolvingDeclarations))
            {
                return;
            }

            var componentProject = _state.ProjectsProvider.Project(e.Module.ProjectId);
            
            var module = Projects.OfType<CodeExplorerProjectViewModel>()
                .FirstOrDefault(p => p.Declaration.Project?.Equals(componentProject) ?? false)?.Children
                .OfType<CodeExplorerComponentViewModel>().FirstOrDefault(component =>
                    component.QualifiedSelection?.QualifiedName.Equals(e.Module) ?? false);

            if (module == null)
            {
                return;
            }

            module.IsErrorState = true;
        }

        private void ExecuteClearSearchCommand(object parameter)
        {
            if (!string.IsNullOrEmpty(Search))
            {
                Search = string.Empty;
            }
        }

        private bool EvaluateCanSwitchNodeState(object parameter)
        {
            return SelectedItem?.Children?.Any() ?? false;
        }

        private void ExecuteCollapseNodes(object parameter)
        {
            if (!(parameter is ICodeExplorerNode node))
            {
                return;
            }

            SwitchNodeState(node, false);
        }

        private void ExecuteExpandNodes(object parameter)
        {
            if (!(parameter is ICodeExplorerNode node))
            {
                return;
            }

            SwitchNodeState(node, true);
        }

        // this is a special case--we have to reset SelectedItem to prevent a crash
        private void ExecuteRemoveCommand(object param)
        {
            var node = (CodeExplorerComponentViewModel)SelectedItem;
            SelectedItem = Projects.FirstOrDefault(p => p.QualifiedSelection.HasValue
                                                        && p.QualifiedSelection.Value.QualifiedName.ProjectId == node.Declaration.ProjectId);

            _externalRemoveCommand.Execute(param);
        }

        public ReparseCommand RefreshCommand { get; set; }
        public OpenCommand OpenCommand { get; set; }
        public AddVBFormCommand AddVBFormCommand { get; set; }
        public AddMDIFormCommand AddMDIFormCommand { get; set; }
        public AddUserFormCommand AddUserFormCommand { get; set; }
        public AddStdModuleCommand AddStdModuleCommand { get; set; }
        public AddClassModuleCommand AddClassModuleCommand { get; set; }                
        public AddUserControlCommand AddUserControlCommand { get; set; }
        public AddPropertyPageCommand AddPropertyPageCommand { get; set; }
        public AddUserDocumentCommand AddUserDocumentCommand { get; set; }
        public AddTestComponentCommand AddTestModuleCommand { get; set; }
        public AddTestModuleWithStubsCommand AddTestModuleWithStubsCommand { get; set; }
        public AddTemplateCommand AddTemplateCommand { get; set; }
        public OpenDesignerCommand OpenDesignerCommand { get; set; }
        public OpenProjectPropertiesCommand OpenProjectPropertiesCommand { get; set; }
        public SetAsStartupProjectCommand SetAsStartupProjectCommand { get; set; }
        public RenameCommand RenameCommand { get; set; }
        public IndentCommand IndenterCommand { get; set; }
        public CodeExplorerFindAllReferencesCommand FindAllReferencesCommand { get; set; }
        public CodeExplorerFindAllImplementationsCommand FindAllImplementationsCommand { get; set; }
        public CommandBase CollapseAllSubnodesCommand { get; } 
        public CopyResultsCommand CopyResultsCommand { get; set; }
        public CommandBase ExpandAllSubnodesCommand { get; }
        public ImportCommand ImportCommand { get; set; }
        public ExportCommand ExportCommand { get; set; }
        public ExportAllCommand ExportAllCommand { get; set; }
        public CommandBase RemoveCommand { get; }
        public PrintCommand PrintCommand { get; set; }
        public AddRemoveReferencesCommand AddRemoveReferencesCommand { get; set; }
        public ICommand ClearSearchCommand { get; }
        public CommandBase SyncCodePaneCommand { get; }

        public ICodeExplorerNode FindVisibleNodeForDeclaration(Declaration declaration)
        {
            if (declaration == null)
            {
                return null;
            }

            var project = Projects.OfType<CodeExplorerProjectViewModel>().FirstOrDefault(proj =>
                (proj.Declaration?.ProjectId ?? string.Empty).Equals(declaration.ProjectId));

            if (declaration.DeclarationType == DeclarationType.Project)
            {
                return project;
            }

            var child = FindChildNodeForDeclaration(project, declaration);
            return child;
        }

        private ICodeExplorerNode FindChildNodeForDeclaration(ICodeExplorerNode node, Declaration declaration)
        {
            if (node is null || declaration is null)
            {
                return null;
            }

            if (node.Declaration.DeclarationType == declaration.DeclarationType &&
                node.Declaration.QualifiedName.Equals(declaration.QualifiedName))
            {
                return node;
            }

            return node.Children.OfType<CodeExplorerItemViewModel>()
                .Select(child => FindChildNodeForDeclaration(child, declaration))
                .FirstOrDefault(child => child != null);
        }

        private void SwitchNodeState(ICodeExplorerNode node, bool expandedState)
        {
            node.IsExpanded = expandedState;

            foreach (var item in node.Children)
            {
                item.IsExpanded = expandedState;
                SwitchNodeState(item, expandedState);
            }
        }

        /// <summary>
        /// Works backward from the passed node and expands all parents to make it visible.
        /// </summary>
        /// <param name="node"></param>
        private void ExpandToNode(ICodeExplorerNode node)
        {
            while (true)
            {
                if (node == null)
                {
                    return;
                }
                node.IsExpanded = true;
                node = node.Parent;
            }
        }

        private bool CanExecuteExportAllCommand => ExportAllCommand?.CanExecute(SelectedItem) ?? false;

        public Visibility ExportVisibility => _vbe.Kind == VBEKind.Standalone || CanExecuteExportAllCommand ? Visibility.Collapsed : Visibility.Visible;

        public Visibility ExportAllVisibility => CanExecuteExportAllCommand ? Visibility.Visible : Visibility.Collapsed;

        public Visibility VB6Visibility => _vbe.Kind == VBEKind.Standalone ? Visibility.Visible : Visibility.Collapsed;

        public Visibility VBAVisibility => _vbe.Kind == VBEKind.Hosted ? Visibility.Visible : Visibility.Collapsed;

        public void Dispose()
        {
            if (_state != null)
            {
                _state.StateChanged -= HandleStateChanged;
                _state.ModuleStateChanged -= ParserState_ModuleStateChanged;
            }
        }
    }
}