// 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.
 
#nullable disable
 
using System;
using System.Collections.Generic;
using Microsoft.CodeAnalysis.Operations;
using Microsoft.CodeAnalysis.Shared.Utilities;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.Shared.Extensions;
 
internal static class SemanticEquivalence
{
    public static bool AreEquivalent(SemanticModel semanticModel, SyntaxNode node1, SyntaxNode node2)
        => AreEquivalent(semanticModel, semanticModel, node1, node2);
 
    public static bool AreEquivalent(
        SemanticModel semanticModel1,
        SemanticModel semanticModel2,
        SyntaxNode node1,
        SyntaxNode node2,
        Func<SyntaxNode, bool> predicate = null)
    {
        // First check for syntactic equivalency.  If two nodes aren't structurally equivalent,
        // then they're not semantically equivalent.
        if (node1 == null && node2 == null)
        {
            return true;
        }
 
        if (node1 == null || node2 == null)
        {
            return false;
        }
 
        if (!node1.IsEquivalentTo(node2, topLevel: false))
        {
            return false;
        }
 
        // From this point on we can assume the tree structure is the same.  So no need to check
        // kinds, child counts or token contents.
        return AreSemanticallyEquivalentWorker(
            semanticModel1, semanticModel2, node1, node2, predicate);
    }
 
    private static bool AreSemanticallyEquivalentWorker(
        SemanticModel semanticModel1,
        SemanticModel semanticModel2,
        SyntaxNode node1,
        SyntaxNode node2,
        Func<SyntaxNode, bool> predicate)
    {
        if (node1 == node2)
        {
            return true;
        }
 
        if (predicate == null || predicate(node1))
        {
            var info1 = semanticModel1.GetSymbolInfo(node1);
            var info2 = semanticModel2.GetSymbolInfo(node2);
 
            if (!AreEquals(semanticModel1, semanticModel2, info1, info2))
            {
                return false;
            }
        }
 
        // Original expression and current node being semantically equivalent isn't enough when the original expression 
        // is a member access via instance reference (either implicit or explicit), the check only ensures that the expression
        // and current node are both backed by the same member symbol. So in this case, in addition to SemanticEquivalence check, 
        // we also check if expression and current node are both instance member access.
        //
        // For example, even though the first `c` binds to a field and we are introducing a local for it,
        // we don't want other references to that field to be replaced as well (i.e. the second `c` in the expression).
        //
        //  class C
        //  {
        //      C c;
        //      void Test()
        //      {
        //          var x = [|c|].c;
        //      }
        //  }
        var originalOperation = semanticModel1.GetOperation(node1);
        if (originalOperation != null && IsInstanceMemberReference(originalOperation))
        {
            var currentOperation = semanticModel2.GetOperation(node2);
 
            if (currentOperation is null || !IsInstanceMemberReference(currentOperation))
            {
                return false;
            }
        }
 
        var e1 = node1.ChildNodesAndTokens().GetEnumerator();
        var e2 = node2.ChildNodesAndTokens().GetEnumerator();
 
        while (true)
        {
            var b1 = e1.MoveNext();
            var b2 = e2.MoveNext();
 
            Contract.ThrowIfTrue(b1 != b2);
 
            if (b1 == false)
            {
                return true;
            }
 
            var c1 = e1.Current;
            var c2 = e2.Current;
 
            if (c1.IsNode && c2.IsNode)
            {
                if (!AreSemanticallyEquivalentWorker(semanticModel1, semanticModel2, c1.AsNode(), c2.AsNode(), predicate))
                {
                    return false;
                }
            }
        }
    }
 
    private static bool IsInstanceMemberReference(IOperation operation)
        => operation is IMemberReferenceOperation { Instance.Kind: OperationKind.InstanceReference };
 
    private static bool AreEquals(
        SemanticModel semanticModel1,
        SemanticModel semanticModel2,
        SymbolInfo info1,
        SymbolInfo info2)
    {
        if (semanticModel1 == semanticModel2)
        {
            return EqualityComparer<ISymbol>.Default.Equals(info1.Symbol, info2.Symbol);
        }
        else
        {
            return SymbolEquivalenceComparer.Instance.Equals(info1.Symbol, info2.Symbol);
        }
    }
}