// 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.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Operations;
using Microsoft.CodeAnalysis.Shared.Extensions;
 
namespace Microsoft.CodeAnalysis;
 
internal static class NullableHelpers
{
    /// <summary>
    /// Gets the declared symbol and root operation from the passed in declarationSyntax and calls
    /// <see cref="IsSymbolAssignedPossiblyNullValue(SemanticModel, IOperation, ISymbol)"/>. Note
    /// that this is bool and not bool? because we know that the symbol is at the very least declared, 
    /// so there's no need to return a null value. 
    /// </summary>
    public static bool IsDeclaredSymbolAssignedPossiblyNullValue(SemanticModel semanticModel, SyntaxNode declarationSyntax, CancellationToken cancellationToken)
    {
        var declaredSymbol = semanticModel.GetRequiredDeclaredSymbol(declarationSyntax, cancellationToken);
        var declaredOperation = semanticModel.GetRequiredOperation(declarationSyntax, cancellationToken);
 
        var rootOperation = declaredOperation;
 
        // Walk up the tree to find a root for the operation
        // that contains the declaration
        while (rootOperation is not IBlockOperation &&
            rootOperation.Parent is not null)
        {
            rootOperation = rootOperation.Parent;
        }
 
        return IsSymbolAssignedPossiblyNullValue(semanticModel, rootOperation, declaredSymbol) == true;
    }
 
    /// <summary>
    /// Given an operation, goes through all decendent operations and returns true if the symbol passed in
    /// is ever assigned a possibly null value as determined by nullable flow state. Returns
    /// null if no references are found, letting the caller determine what to do with that information
    /// </summary>
    public static bool? IsSymbolAssignedPossiblyNullValue(SemanticModel semanticModel, IOperation operation, ISymbol symbol)
    {
        var references = operation.DescendantsAndSelf()
            .Where(o => IsSymbolReferencedByOperation(o, symbol));
 
        var hasReference = false;
 
        foreach (var reference in references)
        {
            hasReference = true;
 
            // foreach statements are handled special because the iterator is not assignable, so the elementtype 
            // annotation is accurate for determining if the loop declaration has a reference that allows the symbol
            // to be null
            if (reference is IForEachLoopOperation forEachLoop)
            {
                var foreachInfo = semanticModel.GetForEachStatementInfo((CommonForEachStatementSyntax)forEachLoop.Syntax);
 
                if (foreachInfo.ElementType is null)
                {
                    continue;
                }
 
                // Use NotAnnotated here to keep both Annotated and None (oblivious) treated the same, since
                // this is directly looking at the annotation and not the flow state
                if (foreachInfo.ElementType.NullableAnnotation != NullableAnnotation.NotAnnotated)
                {
                    return true;
                }
 
                continue;
            }
 
            var syntax = reference is IVariableDeclaratorOperation variableDeclarator
                ? variableDeclarator.GetVariableInitializer()!.Value.Syntax
                : reference.Syntax;
 
            var typeInfo = semanticModel.GetTypeInfo(syntax);
 
            if (typeInfo.Nullability.FlowState == NullableFlowState.MaybeNull)
            {
                return true;
            }
        }
 
        return hasReference ? (bool?)false : null;
    }
 
    /// <summary>
    /// Determines if an operations references a specific symbol. Note that this will recurse in some
    /// cases to work for operations like IAssignmentOperation, which logically references a symbol even if it
    /// is the Target operation that actually does. 
    /// </summary>
    private static bool IsSymbolReferencedByOperation(IOperation operation, ISymbol symbol)
        => operation switch
        {
            ILocalReferenceOperation localReference => localReference.Local.Equals(symbol),
            IParameterReferenceOperation parameterReference => parameterReference.Parameter.Equals(symbol),
            IAssignmentOperation assignment => IsSymbolReferencedByOperation(assignment.Target, symbol),
            ITupleOperation tupleOperation => tupleOperation.Elements.Any(static (element, symbol) => IsSymbolReferencedByOperation(element, symbol), symbol),
            IForEachLoopOperation { LoopControlVariable: IVariableDeclaratorOperation variableDeclarator } => variableDeclarator.Symbol.Equals(symbol),
 
            // A variable initializer is required for this to be a meaningful operation for determining possible null assignment
            IVariableDeclaratorOperation variableDeclarator => variableDeclarator.GetVariableInitializer() != null && variableDeclarator.Symbol.Equals(symbol),
            _ => false
        };
}