// 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.Collections.Generic;
 
namespace Microsoft.CodeAnalysis;
 
internal partial struct SymbolKey
{
    private sealed class SymbolKeyComparer : IEqualityComparer<SymbolKey>
    {
        private readonly ComparisonOptions _options;
 
        private SymbolKeyComparer(ComparisonOptions options)
            => _options = options;
 
        public bool Equals(SymbolKey x, SymbolKey y)
        {
            if (!_options.IgnoreAssemblyKey)
            {
                // Easiest case.  We can directly compare the raw contents of the keys.
                return x.Equals(y, _options.IgnoreCase);
            }
            else
            {
                // This is harder.  To compare these we need to remove the entries related to assemblies.
                //
                // Note: this will remove the language-string as well, so we don't have to worry about that here.
                var data1 = RemoveAssemblyKeys(x._symbolKeyData);
                var data2 = RemoveAssemblyKeys(y._symbolKeyData);
 
                var comparer = _options.IgnoreCase
                    ? StringComparer.OrdinalIgnoreCase
                    : StringComparer.Ordinal;
 
                return comparer.Equals(data1, data2);
            }
        }
 
        private static string RemoveAssemblyKeys(string data)
        {
            var reader = new RemoveAssemblySymbolKeysReader();
            reader.Initialize(data);
            return reader.RemoveAssemblySymbolKeys();
        }
 
        public int GetHashCode(SymbolKey obj)
            => obj.GetHashCode();
 
        public static IEqualityComparer<SymbolKey> GetComparer(bool ignoreCase, bool ignoreAssemblyKey)
            => GetComparer(new ComparisonOptions(ignoreCase, ignoreAssemblyKey));
 
        private static readonly SymbolKeyComparer[] s_cachedComparers = new SymbolKeyComparer[4];
 
        private static SymbolKeyComparer EnsureInitialized(ref SymbolKeyComparer location, ComparisonOptions options)
        {
            // This doesn't need to be interlocked since comparers store no state
            return location ??= new SymbolKeyComparer(options);
        }
 
        public static IEqualityComparer<SymbolKey> GetComparer(ComparisonOptions options)
            => EnsureInitialized(ref s_cachedComparers[options.FlagsValue], options);
    }
}