// 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;
using System.Diagnostics.CodeAnalysis;
using Microsoft.CodeAnalysis.EditorConfig.Parsing;
using Microsoft.CodeAnalysis.EditorConfig.Parsing.NamingStyles;
using Microsoft.CodeAnalysis.NamingStyles;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
 
internal static partial class EditorConfigNamingStyleParser
{
    internal static bool TryGetNamingStyleData(
        Section section,
        string namingRuleName,
        IReadOnlyDictionary<string, (string value, TextLine? line)> properties,
        [NotNullWhen(true)] out NamingScheme? namingScheme)
    {
        return TryGetNamingStyleData(
            namingRuleName,
            properties,
            s => s.value,
            x => x.line,
            s => (s.value, s.line),
            (nameTuple, prefixTuple, suffixTuple, wordSeparatorTuple, capitalizationTuple) =>
            {
                var (name, nameTextLine) = nameTuple;
                var (prefix, prefixTextLine) = prefixTuple;
                var (suffix, suffixTextLine) = suffixTuple;
                var (wordSeparator, wordSeparatorTextLine) = wordSeparatorTuple;
                var (capitalization, capitalizationTextLine) = capitalizationTuple;
 
                return new NamingScheme(
                    OptionName: (section, nameTextLine?.Span, name),
                    Prefix: (section, prefixTextLine?.Span, prefix),
                    Suffix: (section, suffixTextLine?.Span, suffix),
                    WordSeparator: (section, wordSeparatorTextLine?.Span, wordSeparator),
                    Capitalization: (section, capitalizationTextLine?.Span, capitalization));
            },
            out namingScheme);
    }
 
    private static bool TryGetNamingStyleData(
        string namingRuleName,
        IReadOnlyDictionary<string, string> rawOptions,
        out NamingStyle namingStyle)
    {
        return TryGetNamingStyleData<string, object?, NamingStyle>(
            namingRuleName,
            rawOptions,
            s => s,
            x => null,
            s => (s ?? string.Empty, null),
            (nameTuple, prefixTuple, suffixTuple, wordSeparatorTuple, capitalizationTuple) =>
            {
                var (namingStyleName, _) = nameTuple;
                var (prefix, _) = prefixTuple;
                var (suffix, _) = suffixTuple;
                var (wordSeparator, _) = wordSeparatorTuple;
                var (capitalization, _) = capitalizationTuple;
 
                return new NamingStyle(
                    Guid.NewGuid(),
                    namingStyleName,
                    prefix,
                    suffix,
                    wordSeparator,
                    capitalization);
            },
            out namingStyle);
    }
 
    private static bool TryGetNamingStyleData<T, TData, TResult>(
        string namingRuleName,
        IReadOnlyDictionary<string, T> rawOptions,
        Func<T, string> nameSelector,
        Func<T, TData> dataSelector,
        Func<T?, (string value, TData data)> tupleSelector,
        Func<(string namingStyleName, TData data),
             (string prefix, TData data),
             (string suffix, TData data),
             (string wordSeparator, TData data),
             (Capitalization capitalization, TData data), TResult> constructor,
        [NotNullWhen(true)] out TResult? namingStyle)
    {
        namingStyle = default;
        if (!TryGetNamingStyleTitle(namingRuleName, rawOptions, nameSelector, dataSelector, out var namingStyleTitle))
        {
            return false;
        }
 
        var requiredPrefix = GetNamingRequiredPrefix(namingStyleTitle.name, rawOptions, tupleSelector);
        var requiredSuffix = GetNamingRequiredSuffix(namingStyleTitle.name, rawOptions, tupleSelector);
        var wordSeparator = GetNamingWordSeparator(namingStyleTitle.name, rawOptions, tupleSelector);
        if (!TryGetNamingCapitalization(namingStyleTitle.name, rawOptions, tupleSelector, out var capitalization))
        {
            return false;
        }
 
        namingStyle = constructor(namingStyleTitle, requiredPrefix, requiredSuffix, wordSeparator, capitalization);
        return namingStyle is not null;
    }
 
    private static bool TryGetNamingStyleTitle<T, TData>(
        string namingRuleName,
        IReadOnlyDictionary<string, T> conventionsDictionary,
        Func<T, string> nameSelector,
        Func<T, TData> dataSelector,
        out (string name, TData data) result)
    {
        if (conventionsDictionary.TryGetValue($"dotnet_naming_rule.{namingRuleName}.style", out var namingStyleName))
        {
            var name = nameSelector(namingStyleName);
            result = (name, dataSelector(namingStyleName));
            return name != null;
        }
 
        result = default;
        return false;
    }
 
    private static (string prefix, TData data) GetNamingRequiredPrefix<T, TData>(
        string namingStyleName,
        IReadOnlyDictionary<string, T> properties,
        Func<T?, (string value, TData data)> tupleSelector)
        => GetValueFromDictionary(namingStyleName, "required_prefix", properties, tupleSelector);
 
    private static (string suffix, TData data) GetNamingRequiredSuffix<T, TData>(
        string namingStyleName,
        IReadOnlyDictionary<string, T> properties,
        Func<T?, (string value, TData data)> tupleSelector)
        => GetValueFromDictionary(namingStyleName, "required_suffix", properties, tupleSelector);
 
    private static (string wordSeparator, TData data) GetNamingWordSeparator<T, TData>(
        string namingStyleName,
        IReadOnlyDictionary<string, T> properties,
        Func<T?, (string value, TData data)> tupleSelector)
        => GetValueFromDictionary(namingStyleName, "word_separator", properties, tupleSelector);
 
    private static bool TryGetNamingCapitalization<T, TData>(
        string namingStyleName,
        IReadOnlyDictionary<string, T> properties,
        Func<T?, (string value, TData data)> tupleSelector,
        out (Capitalization capitalization, TData data) result)
    {
        var (value, data) = GetValueFromDictionary(namingStyleName, "capitalization", properties, tupleSelector);
        if (TryParseCapitalizationScheme(value, out var capitalization))
        {
            result = (capitalization.Value, data);
            return true;
        }
 
        result = default;
        return false;
    }
 
    private static (string value, TData data) GetValueFromDictionary<T, TData>(
        string namingStyleName,
        string optionName,
        IReadOnlyDictionary<string, T> conventionsDictionary,
        Func<T?, (string value, TData data)> tupleSelector)
    {
        _ = conventionsDictionary.TryGetValue($"dotnet_naming_style.{namingStyleName}.{optionName}", out var result);
        return tupleSelector(result);
    }
 
    private static bool TryParseCapitalizationScheme(
        string namingStyleCapitalization,
        [NotNullWhen(true)] out Capitalization? capitalization)
    {
        capitalization = namingStyleCapitalization switch
        {
            "pascal_case" => Capitalization.PascalCase,
            "camel_case" => Capitalization.CamelCase,
            "first_word_upper" => Capitalization.FirstUpper,
            "all_upper" => Capitalization.AllUpper,
            "all_lower" => Capitalization.AllLower,
            _ => null,
        };
 
        return capitalization is not null;
    }
 
    public static string ToEditorConfigString(this Capitalization capitalization)
        => capitalization switch
        {
            Capitalization.PascalCase => "pascal_case",
            Capitalization.CamelCase => "camel_case",
            Capitalization.FirstUpper => "first_word_upper",
            Capitalization.AllUpper => "all_upper",
            Capitalization.AllLower => "all_lower",
            _ => throw ExceptionUtilities.UnexpectedValue(capitalization),
        };
}