// 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.Linq;
using System.Collections.Immutable;
using System.Diagnostics;
using Microsoft.CodeAnalysis.PooledObjects;
using System.Runtime.CompilerServices;
 
namespace Microsoft.CodeAnalysis
{
    internal partial struct SymbolKey
    {
        private sealed class TupleTypeSymbolKey : AbstractSymbolKey<INamedTypeSymbol>
        {
            public static readonly TupleTypeSymbolKey Instance = new();
 
            public sealed override void Create(INamedTypeSymbol symbol, SymbolKeyWriter visitor)
            {
                Debug.Assert(symbol.IsTupleType);
 
                var isError = symbol.TupleUnderlyingType!.TypeKind == TypeKind.Error;
 
                using var _1 = ArrayBuilder<string?>.GetInstance(out var friendlyNames);
                using var _2 = ArrayBuilder<Location>.GetInstance(out var locations);
 
                foreach (var element in symbol.TupleElements)
                {
                    friendlyNames.Add(element.IsImplicitlyDeclared ? null : element.Name);
                    locations.Add(element.Locations.FirstOrDefault() ?? Location.None);
                }
 
                visitor.WriteBoolean(isError);
                visitor.WriteStringArray(friendlyNames.ToImmutable());
                visitor.WriteLocationArray(locations.ToImmutable());
 
                if (isError)
                {
                    using var _3 = ArrayBuilder<ISymbol>.GetInstance(out var elementTypes);
 
                    foreach (var element in symbol.TupleElements)
                        elementTypes.Add(element.Type);
 
                    visitor.WriteSymbolKeyArray(elementTypes.ToImmutable());
                }
                else
                {
                    visitor.WriteSymbolKey(symbol.TupleUnderlyingType);
                }
            }
 
            protected sealed override SymbolKeyResolution Resolve(
                SymbolKeyReader reader, INamedTypeSymbol? contextualSymbol, out string? failureReason)
            {
                contextualSymbol = contextualSymbol is { IsTupleType: true } ? contextualSymbol : null;
                var isError = reader.ReadBoolean();
 
                return isError
                    ? ResolveErrorTuple(reader, contextualSymbol, out failureReason)
                    : ResolveNormalTuple(reader, contextualSymbol, out failureReason);
            }
 
            private static SymbolKeyResolution ResolveNormalTuple(
                SymbolKeyReader reader, INamedTypeSymbol? contextualSymbol, out string? failureReason)
            {
                using var elementNames = reader.ReadStringArray();
                var elementLocations = ReadElementLocations(reader, out var elementLocationsFailureReason);
                var underlyingTypeResolution = reader.ReadSymbolKey(
                    contextualSymbol?.TupleUnderlyingType,
                    out var underlyingTypeFailureReason);
 
                if (underlyingTypeFailureReason != null)
                {
                    failureReason = $"({nameof(TupleTypeSymbolKey)} {nameof(underlyingTypeResolution)} failed -> {underlyingTypeFailureReason})";
                    return default;
                }
 
                using var result = PooledArrayBuilder<INamedTypeSymbol>.GetInstance();
 
                var elementNamesArray = elementNames.ToImmutable();
                foreach (var namedType in underlyingTypeResolution.OfType<INamedTypeSymbol>())
                {
                    // Suppression on elementLocations due to https://github.com/dotnet/roslyn/issues/46527
                    result.AddIfNotNull(reader.Compilation.CreateTupleTypeSymbol(
                        namedType, elementNamesArray, elementLocations!));
                }
 
                return CreateResolution(result, $"({nameof(TupleTypeSymbolKey)} failed)", out failureReason);
            }
 
            private static SymbolKeyResolution ResolveErrorTuple(
                SymbolKeyReader reader, INamedTypeSymbol? contextualType, out string? failureReason)
            {
                using var elementNames = reader.ReadStringArray();
                var elementLocations = ReadElementLocations(reader, out var elementLocationsFailureReason);
                using var elementTypes = reader.ReadSymbolKeyArray<INamedTypeSymbol, ITypeSymbol>(
                    contextualType,
                    static (contextualType, i) => SafeGet(contextualType.TupleElements, i)?.Type,
                    out var elementTypesFailureReason);
 
                if (elementLocationsFailureReason != null)
                {
                    failureReason = $"({nameof(TupleTypeSymbolKey)} {nameof(elementLocations)} failed -> {elementLocationsFailureReason})";
                    return default;
                }
 
                if (elementTypesFailureReason != null)
                {
                    failureReason = $"({nameof(TupleTypeSymbolKey)} {nameof(elementTypes)} failed -> {elementTypesFailureReason})";
                    return default;
                }
 
                if (elementTypes.IsDefault)
                {
                    failureReason = $"({nameof(TupleTypeSymbolKey)} {nameof(elementTypes)} failed)";
                    return default;
                }
 
                // Suppression on elementLocations due to https://github.com/dotnet/roslyn/issues/46527
                var result = reader.Compilation.CreateTupleTypeSymbol(
                    elementTypes.ToImmutable(), elementNames.ToImmutable(), elementLocations!);
                failureReason = null;
                return new SymbolKeyResolution(result);
            }
 
            private static ImmutableArray<Location> ReadElementLocations(SymbolKeyReader reader, out string? failureReason)
            {
                using var elementLocations = reader.ReadLocationArray(out failureReason);
                if (failureReason != null)
                    return default;
 
                // Compiler API requires that all the locations are non-null, or that there is a default
                // immutable array passed in.
                if (elementLocations.Builder.All(loc => loc == null))
                    return default;
 
                return elementLocations.ToImmutable()!;
            }
        }
    }
}