// 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 System.Linq;
 
namespace Microsoft.CodeAnalysis.Shared.Extensions
{
    internal partial class ITypeSymbolExtensions
    {
        private class SubstituteTypesVisitor<TType1, TType2> : SymbolVisitor<ITypeSymbol>
            where TType1 : ITypeSymbol
            where TType2 : ITypeSymbol
        {
            // private readonly Compilation compilation;
            private readonly IDictionary<TType1, TType2> _map;
            private readonly ITypeGenerator _typeGenerator;
 
            internal SubstituteTypesVisitor(
                IDictionary<TType1, TType2> map,
                ITypeGenerator typeGenerator)
            {
                _map = map;
                _typeGenerator = typeGenerator;
            }
 
            public override ITypeSymbol DefaultVisit(ISymbol node)
                => throw new NotImplementedException();
 
            private ITypeSymbol VisitType(ITypeSymbol symbol)
            {
                if (symbol is TType1 && _map.TryGetValue((TType1)symbol, out var converted))
                {
                    return converted;
                }
 
                return symbol;
            }
 
            public override ITypeSymbol VisitDynamicType(IDynamicTypeSymbol symbol)
                => VisitType(symbol);
 
            public override ITypeSymbol VisitTypeParameter(ITypeParameterSymbol symbol)
                => VisitType(symbol);
 
            public override ITypeSymbol VisitFunctionPointerType(IFunctionPointerTypeSymbol symbol)
            {
                // TODO(https://github.com/dotnet/roslyn/issues/43890): also visit the underlying types of
                // the parameters and return value
                return VisitType(symbol);
            }
 
            public override ITypeSymbol VisitNamedType(INamedTypeSymbol symbol)
            {
                var mapped = VisitType(symbol);
                if (!Equals(mapped, symbol))
                {
                    return mapped;
                }
 
                if (symbol.IsAnonymousType)
                {
                    return symbol;
                }
 
                // If we don't even have any type arguments, then there's nothing to do.
                var allTypeArguments = symbol.GetAllTypeArguments().ToList();
                if (allTypeArguments.Count == 0)
                {
                    return symbol;
                }
 
                // If we have a containing type, make sure its type arguments are updated as well.
                var updatedContainingType = symbol.ContainingType?.Accept(this);
 
                // If our containing type changed, then find us again in the new containing type.
                if (!Equals(updatedContainingType, symbol.ContainingType))
                {
                    symbol = updatedContainingType.GetTypeMembers(symbol.Name, symbol.Arity).First(m => m.TypeKind == symbol.TypeKind);
                }
 
                var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this));
                if (symbol.TypeArguments.SequenceEqual(substitutedArguments))
                {
                    return symbol;
                }
 
                return _typeGenerator.Construct(symbol.OriginalDefinition, substitutedArguments.ToArray()).WithNullableAnnotation(symbol.NullableAnnotation);
            }
 
            public override ITypeSymbol VisitArrayType(IArrayTypeSymbol symbol)
            {
                var mapped = VisitType(symbol);
                if (!Equals(mapped, symbol))
                {
                    return mapped;
                }
 
                var elementType = symbol.ElementType.Accept(this);
                if (elementType != null && elementType.Equals(symbol.ElementType))
                {
                    return symbol;
                }
 
                return _typeGenerator.CreateArrayTypeSymbol(elementType, symbol.Rank);
            }
 
            public override ITypeSymbol VisitPointerType(IPointerTypeSymbol symbol)
            {
                var mapped = VisitType(symbol);
                if (!Equals(mapped, symbol))
                {
                    return mapped;
                }
 
                var pointedAtType = symbol.PointedAtType.Accept(this);
                if (pointedAtType != null && pointedAtType.Equals(symbol.PointedAtType))
                {
                    return symbol;
                }
 
                return _typeGenerator.CreatePointerTypeSymbol(pointedAtType);
            }
        }
    }
}