// 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.Immutable;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
using Microsoft.CodeAnalysis.Editor.EditorConfigSettings.Data;
using Microsoft.CodeAnalysis.EditorConfig.Parsing.NamingStyles;
using Microsoft.CodeAnalysis.NamingStyles;
 
namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.Updater
{
    internal static class EditorConfigNamingStylesExtensions
    {
        public static bool TryGetParseResultForRule(
            this EditorConfigNamingStyles editorConfigNamingStyles,
            NamingStyleSetting namingStyleSetting,
            [NotNullWhen(true)] out NamingStyleOption? namingStyleOption)
        {
            namingStyleOption = null;
            foreach (var (option, optionAsNamingStyle) in editorConfigNamingStyles.Rules.AsNamingStyleSettings())
            {
                if (AreSameRule(optionAsNamingStyle, namingStyleSetting))
                {
                    namingStyleOption = option;
                    return true;
                }
            }
 
            return false;
 
            static bool AreSameRule(NamingStyleSetting left, NamingStyleSetting right)
                => left.Severity == right.Severity &&
                   AreSameSymbolSpec(left.Type, right.Type) &&
                   AreSameNamingStyle(left.Style, right.Style);
 
            static bool AreSameSymbolSpec(SymbolSpecification? left, SymbolSpecification? right)
            {
                if (left is null && right is null)
                {
                    return true;
                }
 
                if (left is null || right is null)
                {
                    return false;
                }
 
                return left.ApplicableSymbolKindList.SequenceEqual(right!.ApplicableSymbolKindList) &&
                       left.ApplicableAccessibilityList.SequenceEqual(right.ApplicableAccessibilityList) &&
                       left.RequiredModifierList.SequenceEqual(right.RequiredModifierList);
            }
 
            static bool AreSameNamingStyle(NamingStyle left, NamingStyle right)
                => left.Prefix == right.Prefix &&
                   left.Suffix == right.Suffix &&
                   left.WordSeparator == right.WordSeparator &&
                   left.CapitalizationScheme == right.CapitalizationScheme;
        }
 
        public static ImmutableArray<(NamingStyleOption namingStyleOption, NamingStyleSetting namingStyleSetting)> AsNamingStyleSettings(this ImmutableArray<NamingStyleOption> namingStyleOptions)
            => namingStyleOptions.SelectAsArray(rule => (rule, NamingStyleSetting.FromParseResult(rule)));
 
        public static NamingStyle AsNamingStyle(this NamingScheme namingScheme)
            => new(
                Guid.NewGuid(),
                namingScheme.OptionName,
                namingScheme.Prefix,
                namingScheme.Suffix,
                namingScheme.WordSeparator,
                namingScheme.Capitalization);
 
        public static SymbolSpecification AsSymbolSpecification(this ApplicableSymbolInfo applicableSymbolInfo)
            => new(
                Guid.NewGuid(),
                applicableSymbolInfo.OptionName,
                applicableSymbolInfo.SymbolKinds,
                applicableSymbolInfo.Accessibilities,
                applicableSymbolInfo.Modifiers);
    }
}