// 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;
using System.Collections.Immutable;
using System.Diagnostics.CodeAnalysis;
using Microsoft.CodeAnalysis.Operations;
using Microsoft.CodeAnalysis.PooledObjects;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.Shared.Utilities;

internal partial struct HashCodeAnalyzer
{
    /// <summary>
    /// Breaks down complex <see cref="IOperation"/> trees, looking for particular
    /// <see cref="object.GetHashCode"/> patterns and extracting out the field and property
    /// symbols use to compute the hash.
    /// </summary>
    private struct OperationDeconstructor(
        HashCodeAnalyzer analyzer, IMethodSymbol method, ILocalSymbol? hashCodeVariable) : IDisposable
    {
        private readonly HashCodeAnalyzer _analyzer = analyzer;
        private readonly IMethodSymbol _method = method;
        private readonly ILocalSymbol? _hashCodeVariable = hashCodeVariable;

        private readonly ArrayBuilder<ISymbol> _hashedSymbols = ArrayBuilder<ISymbol>.GetInstance();
        private bool _accessesBase = false;

        public readonly void Dispose()
            => _hashedSymbols.Free();

        public readonly (bool accessesBase, ImmutableArray<ISymbol> hashedSymbol) GetResult()
            => (_accessesBase, _hashedSymbols.ToImmutable());

        /// <summary>
        /// Recursive function that decomposes <paramref name="value"/>, looking for particular
        /// forms that VS or ReSharper generate to hash fields in the containing type.
        /// </summary>
        /// <param name="seenHash">'seenHash' is used to determine if we actually saw something
        /// that indicates that we really hashed a field/property and weren't just simply
        /// referencing it.  This is used as we recurse down to make sure we've seen a
        /// pattern we explicitly recognize by the time we hit a field/prop.</param>
        public bool TryAddHashedSymbol(IOperation value, bool seenHash)
        {
            value = Unwrap(value);
            switch (value)
            {
                case IBinaryOperation topBinary:
                    // (hashCode op1 constant) op1 hashed_value
                    //
                    // This is generated by both VS and ReSharper.  Though each use different mathematical
                    // ops to combine the values.
                    return _hashCodeVariable != null &&
                           topBinary.LeftOperand is IBinaryOperation leftBinary &&
                           IsLocalReference(leftBinary.LeftOperand, _hashCodeVariable) &&
                           IsLiteralNumber(leftBinary.RightOperand) &&
                           TryAddHashedSymbol(topBinary.RightOperand, seenHash: true);

                case IInvocationOperation invocation:
                    var targetMethod = invocation.TargetMethod;
                    if (_analyzer.OverridesSystemObject(targetMethod))
                    {
                        // Either:
                        //
                        //      a.GetHashCode()
                        //
                        // or
                        //
                        //      (hashCode * -1521134295 + a.GetHashCode()).GetHashCode()
                        //
                        // recurse on the value we're calling GetHashCode on.
                        RoslynDebug.Assert(invocation.Instance is not null);
                        return TryAddHashedSymbol(invocation.Instance, seenHash: true);
                    }

                    if (targetMethod.Name == nameof(GetHashCode) &&
                        Equals(_analyzer._equalityComparerType, targetMethod.ContainingType.OriginalDefinition) &&
                        invocation.Arguments.Length == 1)
                    {
                        // EqualityComparer<T>.Default.GetHashCode(i)
                        //
                        // VS codegen only.
                        return TryAddHashedSymbol(invocation.Arguments[0].Value, seenHash: true);
                    }

                    // No other invocations supported.
                    return false;

                case IConditionalOperation conditional:
                    // (StringProperty != null ? StringProperty.GetHashCode() : 0)
                    //
                    // ReSharper codegen only.
                    if (conditional.Condition is IBinaryOperation binary &&
                        Unwrap(binary.RightOperand).IsNullLiteral() &&
                        TryGetFieldOrProperty(binary.LeftOperand, out _))
                    {
                        if (binary.OperatorKind == BinaryOperatorKind.Equals)
                        {
                            // (StringProperty == null ? 0 : StringProperty.GetHashCode())
                            RoslynDebug.Assert(conditional.WhenFalse is not null);
                            return TryAddHashedSymbol(conditional.WhenFalse, seenHash: true);
                        }
                        else if (binary.OperatorKind == BinaryOperatorKind.NotEquals)
                        {
                            // (StringProperty != null ? StringProperty.GetHashCode() : 0)
                            return TryAddHashedSymbol(conditional.WhenTrue, seenHash: true);
                        }
                    }

                    // no other conditional forms supported.
                    return false;
            }

            // Look to see if we're referencing some field/prop/base.  However, we only accept
            // this reference if we've at least been through something that indicates that we've
            // hashed the value.
            if (seenHash)
            {
                if (value is IInstanceReferenceOperation instanceReference &&
                    instanceReference.ReferenceKind == InstanceReferenceKind.ContainingTypeInstance &&
                    Equals(_method.ContainingType.BaseType, instanceReference.Type))
                {
                    if (_accessesBase)
                    {
                        // already had a reference to base.GetHashCode();
                        return false;
                    }

                    // reference to base.
                    //
                    // Happens with code like: `var hashCode = base.GetHashCode();`
                    _accessesBase = true;
                    return true;
                }

                // After decomposing all of the above patterns, we must end up with an operation that is
                // a reference to an instance-field (or prop) in our type.  If so, and this is the only
                // time we've seen that field/prop, then we're good.
                //
                // We only do this if we actually did something that counts as hashing along the way.  This
                // way
                if (TryGetFieldOrProperty(value, out var fieldOrProp) &&
                    Equals(fieldOrProp.ContainingType.OriginalDefinition, _method.ContainingType))
                {
                    return TryAddSymbol(fieldOrProp);
                }

                if (value is ITupleOperation tupleOperation)
                {
                    foreach (var element in tupleOperation.Elements)
                    {
                        if (!TryAddHashedSymbol(element, seenHash: true))
                        {
                            return false;
                        }
                    }

                    return true;
                }
            }

            // Anything else is not recognized.
            return false;
        }

        private static bool TryGetFieldOrProperty(IOperation operation, [NotNullWhen(true)] out ISymbol? symbol)
        {
            operation = Unwrap(operation);

            if (operation is IFieldReferenceOperation fieldReference)
            {
                symbol = fieldReference.Member;
                return !symbol.IsStatic;
            }

            if (operation is IPropertyReferenceOperation propertyReference)
            {
                symbol = propertyReference.Member;
                return !symbol.IsStatic;
            }

            symbol = null;
            return false;
        }

        private readonly bool TryAddSymbol(ISymbol member)
        {
            // Not a legal GetHashCode to convert if we refer to members multiple times.
            if (_hashedSymbols.Contains(member))
            {
                return false;
            }

            _hashedSymbols.Add(member);
            return true;
        }
    }
}