// 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.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.LanguageService;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.GenerateMember;
 
internal abstract partial class AbstractGenerateMemberService<TSimpleNameSyntax, TExpressionSyntax>
    where TSimpleNameSyntax : TExpressionSyntax
    where TExpressionSyntax : SyntaxNode
{
    protected AbstractGenerateMemberService()
    {
    }
 
    protected static readonly ISet<TypeKind> EnumType = new HashSet<TypeKind> { TypeKind.Enum };
    protected static readonly ISet<TypeKind> ClassInterfaceModuleStructTypes = new HashSet<TypeKind>
    {
        TypeKind.Class,
        TypeKind.Module,
        TypeKind.Struct,
        TypeKind.Interface
    };
 
    protected static bool ValidateTypeToGenerateIn(
        [NotNullWhen(true)] INamedTypeSymbol? typeToGenerateIn,
        bool isStatic,
        ISet<TypeKind> typeKinds)
    {
        if (typeToGenerateIn == null)
            return false;
 
        if (typeToGenerateIn.IsAnonymousType)
            return false;
 
        if (!typeKinds.Contains(typeToGenerateIn.TypeKind))
            return false;
 
        if (typeToGenerateIn.TypeKind == TypeKind.Interface && isStatic)
            return false;
 
        // TODO(cyrusn): Make sure that there is a totally visible part somewhere (i.e.
        // venus) that we can generate into.
        var locations = typeToGenerateIn.Locations;
        return locations.Any(static loc => loc.IsInSource);
    }
 
    protected static bool TryDetermineTypeToGenerateIn(
        SemanticDocument document,
        INamedTypeSymbol containingType,
        TExpressionSyntax simpleNameOrMemberAccessExpression,
        CancellationToken cancellationToken,
        [NotNullWhen(true)] out INamedTypeSymbol? typeToGenerateIn,
        out bool isStatic,
        out bool isColorColorCase)
    {
        TryDetermineTypeToGenerateInWorker(
            document, containingType, simpleNameOrMemberAccessExpression, cancellationToken, out typeToGenerateIn, out isStatic, out isColorColorCase);
 
        typeToGenerateIn = typeToGenerateIn?.OriginalDefinition;
 
        return typeToGenerateIn != null;
    }
 
    private static void TryDetermineTypeToGenerateInWorker(
        SemanticDocument semanticDocument,
        INamedTypeSymbol containingType,
        TExpressionSyntax expression,
        CancellationToken cancellationToken,
        out INamedTypeSymbol? typeToGenerateIn,
        out bool isStatic,
        out bool isColorColorCase)
    {
        typeToGenerateIn = null;
        isStatic = false;
        isColorColorCase = false;
 
        var syntaxFacts = semanticDocument.Document.GetRequiredLanguageService<ISyntaxFactsService>();
        var semanticModel = semanticDocument.SemanticModel;
        if (syntaxFacts.IsSimpleMemberAccessExpression(expression))
        {
            // Figure out what's before the dot.  For VB, that also means finding out 
            // what ".X" might mean, even when there's nothing before the dot itself.
            var beforeDotExpression = syntaxFacts.GetExpressionOfMemberAccessExpression(
                expression, allowImplicitTarget: true);
 
            if (beforeDotExpression != null)
            {
                DetermineTypeToGenerateInWorker(
                    semanticModel, beforeDotExpression, out typeToGenerateIn, out isStatic, out isColorColorCase, cancellationToken);
            }
 
            return;
        }
 
        if (syntaxFacts.IsConditionalAccessExpression(expression))
        {
            var beforeDotExpression = syntaxFacts.GetExpressionOfConditionalAccessExpression(expression);
 
            if (beforeDotExpression != null)
            {
                DetermineTypeToGenerateInWorker(
                    semanticModel, beforeDotExpression, out typeToGenerateIn, out isStatic, out isColorColorCase, cancellationToken);
                if (typeToGenerateIn.IsNullable(out var underlyingType) &&
                    underlyingType is INamedTypeSymbol underlyingNamedType)
                {
                    typeToGenerateIn = underlyingNamedType;
                }
            }
 
            return;
        }
 
        if (syntaxFacts.IsPointerMemberAccessExpression(expression))
        {
            var beforeArrowExpression = syntaxFacts.GetExpressionOfMemberAccessExpression(expression);
            if (beforeArrowExpression != null)
            {
                var typeInfo = semanticModel.GetTypeInfo(beforeArrowExpression, cancellationToken);
 
                if (typeInfo.Type is IPointerTypeSymbol pointerType)
                {
                    typeToGenerateIn = pointerType.PointedAtType as INamedTypeSymbol;
                    isStatic = false;
                }
            }
 
            return;
        }
 
        if (syntaxFacts.IsAttributeNamedArgumentIdentifier(expression))
        {
            var attributeNode = expression.GetAncestors().FirstOrDefault(syntaxFacts.IsAttribute);
            Contract.ThrowIfNull(attributeNode);
 
            var attributeName = syntaxFacts.GetNameOfAttribute(attributeNode);
            var attributeType = semanticModel.GetTypeInfo(attributeName, cancellationToken);
 
            typeToGenerateIn = attributeType.Type as INamedTypeSymbol;
            isStatic = false;
            return;
        }
 
        if (syntaxFacts.IsMemberInitializerNamedAssignmentIdentifier(
                expression, out var initializedObject))
        {
            typeToGenerateIn = semanticModel.GetTypeInfo(initializedObject, cancellationToken).Type as INamedTypeSymbol;
            isStatic = false;
            return;
        }
        else if (syntaxFacts.IsNameOfSubpattern(expression))
        {
            var propertyPatternClause = expression.Ancestors().FirstOrDefault(syntaxFacts.IsPropertyPatternClause);
 
            if (propertyPatternClause != null)
            {
                // something like: { [|X|]: int i } or like: Blah { [|X|]: int i }
                var inferenceService = semanticDocument.Document.GetRequiredLanguageService<ITypeInferenceService>();
                typeToGenerateIn = inferenceService.InferType(semanticModel, propertyPatternClause, objectAsDefault: true, cancellationToken) as INamedTypeSymbol;
 
                isStatic = false;
                return;
            }
        }
 
        // Generating into the containing type.
        typeToGenerateIn = containingType;
        isStatic = syntaxFacts.IsInStaticContext(expression);
    }
 
    private static void DetermineTypeToGenerateInWorker(
        SemanticModel semanticModel,
        SyntaxNode expression,
        out INamedTypeSymbol? typeToGenerateIn,
        out bool isStatic,
        out bool isColorColorCase,
        CancellationToken cancellationToken)
    {
        var typeInfo = semanticModel.GetTypeInfo(expression, cancellationToken);
        var semanticInfo = semanticModel.GetSymbolInfo(expression, cancellationToken);
 
        typeToGenerateIn = typeInfo.Type is ITypeParameterSymbol typeParameter
            ? typeParameter.GetNamedTypeSymbolConstraint()
            : typeInfo.Type as INamedTypeSymbol;
 
        isStatic = semanticInfo.Symbol is INamedTypeSymbol;
        isColorColorCase = typeInfo.Type != null && semanticInfo.Symbol != null && semanticInfo.Symbol.Name == typeInfo.Type.Name;
    }
}