using System.Collections.Immutable;
using Dpz.Core.SourceGenerator.Models;
using Microsoft.CodeAnalysis;

namespace Dpz.Core.SourceGenerator;

/// <summary>
/// 从服务接口读取生成装饰器所需的完整契约。
/// </summary>
internal static class InterfaceContractInspector
{
    internal static ImmutableArray<InterfaceMethod> GetMethods(INamedTypeSymbol interfaceType)
    {
        return
        [
            .. GetMembers(interfaceType)
                .OfType<IMethodSymbol>()
                .Where(method => method.MethodKind == MethodKind.Ordinary)
                .Select(method => new InterfaceMethod(
                    method.Name,
                    SymbolDisplay.ToFullyQualifiedTypeName(method.ReturnType),
                    GetTypeParameterList(method),
                    GetConstraintClauses(method),
                    [
                        .. method.Parameters.Select(parameter => new CachedParameter(
                            parameter.Name,
                            SymbolDisplay.ToFullyQualifiedTypeName(parameter.Type),
                            parameter.RefKind,
                            parameter.HasExplicitDefaultValue,
                            SymbolDisplay.ToDefaultValueLiteral(parameter),
                            parameter.IsParams
                        )),
                    ]
                )),
        ];
    }

    internal static ImmutableArray<InterfaceProperty> GetProperties(INamedTypeSymbol interfaceType)
    {
        return
        [
            .. GetMembers(interfaceType)
                .OfType<IPropertySymbol>()
                .Where(property => !property.IsStatic)
                .Select(property => new InterfaceProperty(
                    property.Name,
                    SymbolDisplay.ToFullyQualifiedTypeName(property.Type),
                    property.GetMethod is not null,
                    property.SetMethod is not null
                )),
        ];
    }

    internal static ImmutableArray<InterfaceEvent> GetEvents(INamedTypeSymbol interfaceType)
    {
        return
        [
            .. GetMembers(interfaceType)
                .OfType<IEventSymbol>()
                .Where(@event => !@event.IsStatic)
                .Select(@event => new InterfaceEvent(
                    @event.Name,
                    SymbolDisplay.ToFullyQualifiedTypeName(@event.Type)
                )),
        ];
    }

    private static IEnumerable<ISymbol> GetMembers(INamedTypeSymbol interfaceType)
    {
        foreach (
            var inheritedInterface in interfaceType.AllInterfaces.OrderBy(
                type => type.ToDisplayString(),
                StringComparer.Ordinal
            )
        )
        {
            foreach (var member in inheritedInterface.GetMembers())
            {
                yield return member;
            }
        }

        foreach (var member in interfaceType.GetMembers())
        {
            yield return member;
        }
    }

    private static string GetTypeParameterList(IMethodSymbol method)
    {
        if (method.TypeParameters.Length == 0)
        {
            return string.Empty;
        }

        return "<"
            + string.Join(", ", method.TypeParameters.Select(parameter => parameter.Name))
            + ">";
    }

    private static string GetConstraintClauses(IMethodSymbol method)
    {
        if (method.TypeParameters.Length == 0)
        {
            return string.Empty;
        }

        return string.Join(
            string.Empty,
            method.TypeParameters.Select(GetConstraintClause).Where(clause => clause.Length > 0)
        );
    }

    private static string GetConstraintClause(ITypeParameterSymbol typeParameter)
    {
        var constraints = new List<string>();
        if (typeParameter.HasUnmanagedTypeConstraint)
        {
            constraints.Add("unmanaged");
        }
        else if (typeParameter.HasValueTypeConstraint)
        {
            constraints.Add("struct");
        }
        else if (typeParameter.HasReferenceTypeConstraint)
        {
            constraints.Add("class");
        }
        else if (typeParameter.HasNotNullConstraint)
        {
            constraints.Add("notnull");
        }

        constraints.AddRange(
            typeParameter.ConstraintTypes.Select(SymbolDisplay.ToFullyQualifiedTypeName)
        );

        if (typeParameter.HasConstructorConstraint)
        {
            constraints.Add("new()");
        }

        if (constraints.Count == 0)
        {
            return string.Empty;
        }

        return " where " + typeParameter.Name + " : " + string.Join(", ", constraints);
    }
}