// 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.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Features.RQName.Nodes;

namespace Microsoft.CodeAnalysis.Features.RQName;

internal static class RQNodeBuilder
{
    /// <summary>
    /// Builds the RQName for a given symbol.
    /// </summary>
    /// <returns>The node if it could be created, otherwise null</returns>
    public static RQNode? Build(ISymbol symbol)
        => symbol switch
        {
            INamespaceSymbol namespaceSymbol => BuildNamespace(namespaceSymbol),
            INamedTypeSymbol namedTypeSymbol => BuildUnconstructedNamedType(namedTypeSymbol),
            IMethodSymbol methodSymbol => BuildMethod(methodSymbol),
            IFieldSymbol fieldSymbol => BuildField(fieldSymbol),
            IEventSymbol eventSymbol => BuildEvent(eventSymbol),
            IPropertySymbol propertySymbol => BuildProperty(propertySymbol),
            _ => null,
        };

    private static RQNamespace BuildNamespace(INamespaceSymbol @namespace)
        => new(RQNodeBuilder.GetNameParts(@namespace));

    private static IList<string> GetNameParts(INamespaceSymbol @namespace)
    {
        var parts = new List<string>();

        if (@namespace == null)
        {
            return parts;
        }

        while (!@namespace.IsGlobalNamespace)
        {
            parts.Add(@namespace.Name);
            @namespace = @namespace.ContainingNamespace;
        }

        parts.Reverse();
        return parts;
    }

    private static RQUnconstructedType? BuildUnconstructedNamedType(INamedTypeSymbol type)
    {
        // Anything that is a valid RQUnconstructed types is ALWAYS safe for public APIs

        if (type == null)
        {
            return null;
        }

        // Anonymous types are unsupported
        if (type.IsAnonymousType)
        {
            return null;
        }

        // the following types are supported for BuildType() used in signatures, but are not supported
        // for UnconstructedTypes
        if (type != type.ConstructedFrom || type.SpecialType == SpecialType.System_Void)
        {
            return null;
        }

        // make an RQUnconstructedType
        var namespaceNames = RQNodeBuilder.GetNameParts(@type.ContainingNamespace);
        var typeInfos = new List<RQUnconstructedTypeInfo>();

        for (var currentType = type; currentType != null; currentType = currentType.ContainingType)
        {
            typeInfos.Insert(0, new RQUnconstructedTypeInfo(currentType.Name, currentType.TypeParameters.Length));
        }

        return new RQUnconstructedType(namespaceNames, typeInfos);
    }

    private static RQMember? BuildField(IFieldSymbol symbol)
    {
        var containingType = BuildUnconstructedNamedType(symbol.ContainingType);

        if (containingType == null)
        {
            return null;
        }

        return new RQMemberVariable(containingType, symbol.Name);
    }

    private static RQProperty? BuildProperty(IPropertySymbol symbol)
    {
        RQMethodPropertyOrEventName name = symbol.IsIndexer
            ? RQOrdinaryMethodPropertyOrEventName.CreateOrdinaryIndexerName()
            : RQOrdinaryMethodPropertyOrEventName.CreateOrdinaryPropertyName(symbol.Name);

        if (symbol.ExplicitInterfaceImplementations.Any())
        {
            if (symbol.ExplicitInterfaceImplementations.Length > 1)
            {
                return null;
            }

            var interfaceType = BuildType(symbol.ExplicitInterfaceImplementations.Single().ContainingType);

            if (interfaceType != null)
            {
                name = new RQExplicitInterfaceMemberName(
                    interfaceType,
                    (RQOrdinaryMethodPropertyOrEventName)name);
            }
        }

        var containingType = BuildUnconstructedNamedType(symbol.ContainingType);

        if (containingType == null)
        {
            return null;
        }

        var parameterList = BuildParameterList(symbol.Parameters);

        if (parameterList == null)
        {
            return null;
        }

        return new RQProperty(containingType, name, typeParameterCount: 0, parameters: parameterList);
    }

    private static IList<RQParameter>? BuildParameterList(ImmutableArray<IParameterSymbol> parameters)
    {
        var parameterList = new List<RQParameter>();

        foreach (var parameter in parameters)
        {
            var parameterType = BuildType(parameter.Type);

            if (parameterType == null)
            {
                return null;
            }

            if (parameter.RefKind == RefKind.Out)
            {
                parameterList.Add(new RQOutParameter(parameterType));
            }
            else if (parameter.RefKind == RefKind.Ref)
            {
                parameterList.Add(new RQRefParameter(parameterType));
            }
            else
            {
                parameterList.Add(new RQNormalParameter(parameterType));
            }
        }

        return parameterList;
    }

    private static RQEvent? BuildEvent(IEventSymbol symbol)
    {
        var containingType = BuildUnconstructedNamedType(symbol.ContainingType);

        if (containingType == null)
        {
            return null;
        }

        RQMethodPropertyOrEventName name = RQOrdinaryMethodPropertyOrEventName.CreateOrdinaryEventName(symbol.Name);

        if (symbol.ExplicitInterfaceImplementations.Any())
        {
            if (symbol.ExplicitInterfaceImplementations.Length > 1)
            {
                return null;
            }

            var interfaceType = BuildType(symbol.ExplicitInterfaceImplementations.Single().ContainingType);

            if (interfaceType != null)
            {
                name = new RQExplicitInterfaceMemberName(interfaceType, (RQOrdinaryMethodPropertyOrEventName)name);
            }
        }

        return new RQEvent(containingType, name);
    }

    private static RQMethod? BuildMethod(IMethodSymbol symbol)
    {
        if (symbol.MethodKind is MethodKind.UserDefinedOperator or
            MethodKind.BuiltinOperator or
            MethodKind.EventAdd or
            MethodKind.EventRemove or
            MethodKind.PropertySet or
            MethodKind.PropertyGet)
        {
            return null;
        }

        RQMethodPropertyOrEventName name;

        if (symbol.MethodKind == MethodKind.Constructor)
        {
            name = RQOrdinaryMethodPropertyOrEventName.CreateConstructorName();
        }
        else if (symbol.MethodKind == MethodKind.Destructor)
        {
            name = RQOrdinaryMethodPropertyOrEventName.CreateDestructorName();
        }
        else
        {
            name = RQOrdinaryMethodPropertyOrEventName.CreateOrdinaryMethodName(symbol.Name);
        }

        if (symbol.ExplicitInterfaceImplementations.Any())
        {
            if (symbol.ExplicitInterfaceImplementations.Length > 1)
            {
                return null;
            }

            var interfaceType = BuildType(symbol.ExplicitInterfaceImplementations.Single().ContainingType);

            if (interfaceType != null)
            {
                name = new RQExplicitInterfaceMemberName(interfaceType, (RQOrdinaryMethodPropertyOrEventName)name);
            }
        }

        var containingType = BuildUnconstructedNamedType(symbol.ContainingType);

        if (containingType == null)
        {
            return null;
        }

        var typeParamCount = symbol.TypeParameters.Length;
        var parameterList = BuildParameterList(symbol.Parameters);

        if (parameterList == null)
        {
            return null;
        }

        return new RQMethod(containingType, name, typeParamCount, parameterList);
    }

    private static RQType? BuildType(ITypeSymbol symbol)
    {
        if (symbol.IsAnonymousType)
        {
            return null;
        }

        if (symbol.SpecialType == SpecialType.System_Void)
        {
            return RQVoidType.Singleton;
        }
        else if (symbol is IPointerTypeSymbol pointerType)
        {
            var pointedAtType = BuildType(pointerType.PointedAtType);
            if (pointedAtType == null)
            {
                return null;
            }

            return new RQPointerType(pointedAtType);
        }
        else if (symbol is IArrayTypeSymbol arrayType)
        {
            var elementType = BuildType(arrayType.ElementType);
            if (elementType == null)
            {
                return null;
            }

            return new RQArrayType(arrayType.Rank, elementType);
        }
        else if (symbol.TypeKind == TypeKind.TypeParameter)
        {
            return new RQTypeVariableType(symbol.Name);
        }
        else if (symbol.TypeKind == TypeKind.Unknown)
        {
            return new RQErrorType(symbol.Name);
        }
        else if (symbol.TypeKind == TypeKind.Dynamic)
        {
            // NOTE: Because RQNames were defined as an interchange format before C# had "dynamic", and we didn't want 
            // all consumers to have to update their logic to crack the attributes about whether something is object or
            // not, we just erase dynamic to object here.
            return RQType.ObjectType;
        }
        else if (symbol is INamedTypeSymbol namedTypeSymbol)
        {
            var definingType = namedTypeSymbol.ConstructedFrom ?? namedTypeSymbol;

            var typeChain = new List<INamedTypeSymbol>();
            var type = namedTypeSymbol;
            typeChain.Add(namedTypeSymbol);

            while (type.ContainingType != null)
            {
                type = type.ContainingType;
                typeChain.Add(type);
            }

            typeChain.Reverse();

            var typeArgumentList = new List<RQType>();

            foreach (var entry in typeChain)
            {
                foreach (var typeArgument in entry.TypeArguments)
                {
                    var rqType = BuildType(typeArgument);
                    if (rqType == null)
                    {
                        return null;
                    }

                    typeArgumentList.Add(rqType);
                }
            }

            var containingType = BuildUnconstructedNamedType(definingType);

            if (containingType == null)
            {
                return null;
            }

            return new RQConstructedType(containingType, typeArgumentList);
        }
        else
        {
            return null;
        }
    }
}