// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
using Microsoft.VisualStudio.Utilities;
using Roslyn.Utilities;
 
namespace Microsoft.VisualStudio.LanguageServices.Implementation.MoveStaticMembers;
 
internal class StaticMemberSelectionViewModel : AbstractNotifyPropertyChanged
{
    private readonly IUIThreadOperationExecutor _uiThreadOperationExecutor;
    private readonly ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>> _symbolToDependentsMap;
    private readonly ImmutableDictionary<ISymbol, SymbolViewModel<ISymbol>> _symbolToMemberViewMap;
 
    public StaticMemberSelectionViewModel(
        IUIThreadOperationExecutor uiThreadOperationExecutor,
        ImmutableArray<SymbolViewModel<ISymbol>> members,
        ImmutableDictionary<ISymbol, Task<ImmutableArray<ISymbol>>> dependentsMap)
    {
        _uiThreadOperationExecutor = uiThreadOperationExecutor;
        _members = members;
        _symbolToDependentsMap = dependentsMap;
        _symbolToMemberViewMap = members.ToImmutableDictionary(memberViewModel => memberViewModel.Symbol);
    }
 
    public ImmutableArray<SymbolViewModel<ISymbol>> CheckedMembers => Members.WhereAsArray(m => m.IsChecked);
 
    private ImmutableArray<SymbolViewModel<ISymbol>> _members;
    public ImmutableArray<SymbolViewModel<ISymbol>> Members
    {
        get => _members;
        set => SetProperty(ref _members, value);
    }
 
    public void SelectAll()
        => SelectMembers(Members);
 
    internal void DeselectAll()
        => SelectMembers(Members, isChecked: false);
 
    public void SelectDependents()
    {
        var checkedMembers = Members
            .WhereAsArray(member => member.IsChecked);
 
        var result = _uiThreadOperationExecutor.Execute(
            title: ServicesVSResources.Move_static_members_to_another_type_colon,
            defaultDescription: ServicesVSResources.Calculating_dependents,
            allowCancellation: true,
            showProgress: true,
            context =>
            {
                foreach (var member in Members)
                {
                    _symbolToDependentsMap[member.Symbol].Wait(context.UserCancellationToken);
                }
            });
 
        if (result == UIThreadOperationStatus.Completed)
        {
            foreach (var member in checkedMembers)
            {
                var membersToSelected = FindDependents(member.Symbol).SelectAsArray(symbol => _symbolToMemberViewMap[symbol]);
                SelectMembers(membersToSelected);
            }
        }
    }
 
    private static void SelectMembers(ImmutableArray<SymbolViewModel<ISymbol>> members, bool isChecked = true)
    {
        foreach (var member in members)
        {
            member.IsChecked = isChecked;
        }
    }
 
    private ImmutableHashSet<ISymbol> FindDependents(ISymbol member)
    {
        var queue = new Queue<ISymbol>();
        // Under situation like two methods call each other, this hashset is used to 
        // prevent the infinity loop.
        var visited = new HashSet<ISymbol>();
        var result = new HashSet<ISymbol>();
        queue.Enqueue(member);
        visited.Add(member);
        while (!queue.IsEmpty())
        {
            var currentMember = queue.Dequeue();
            result.Add(currentMember);
            visited.Add(currentMember);
            foreach (var dependent in _symbolToDependentsMap[currentMember].Result)
            {
                if (!visited.Contains(dependent))
                {
                    queue.Enqueue(dependent);
                }
            }
        }
 
        return result.ToImmutableHashSet();
    }
}