using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Text;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
using SourceGenerators.Utils;

namespace SourceGenerators;

[Generator]
public class VContainerAutoRegistrationGenerator : IIncrementalGenerator
{
    private const string Attribute = "CodeBase.CompositionRoot.Helpers.VContainerAutoRegistrationAttribute";

    private static Dictionary<string, (TargetLifetime, RegisterType)> preparedInterfaces = new()
    {
        {"Scellecs.Morpeh.IInitializer", (TargetLifetime.Singleton, RegisterType.Self)},
    };

    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // Шаг 1: Собираем все классы-кандидаты
        var classProvider = context.SyntaxProvider
            .CreateSyntaxProvider(
                predicate: static (s, _) => IsClassCandidate(s),
                transform: static (ctx, _) => GetClassSymbol(ctx))
            .Where(static m => m is not null);

        // Шаг 2: Комбинируем классы с информацией о компиляции
        var combinedProvider = classProvider
            .Combine(context.CompilationProvider);

        // Шаг 3: Обрабатываем каждый класс и находим подходящий интерфейс
        var processedClasses = combinedProvider
            .Select(static (combined, token) =>
                ProcessClass(combined.Left, combined.Right))
            .Where(static m => m is not null);

        // Шаг 4: Группируем регистрации по интерфейсам для эффективной кодогенерации
        var groupedRegistrations = processedClasses
            .Collect()
            .Select(static (registrations, _) =>
                registrations
                    .GroupBy(r => r.InterfaceSymbol.ToDisplayString())
                    .Select(g => new InterfaceRegistrationGroup
                    {
                        InterfaceFullName = g.Key,
                        InterfaceSymbol = g.First().InterfaceSymbol,
                        ClassRegistrations = g.ToList(),
                        Lifetime = g.First().Lifetime,
                        RegisterType = g.First().RegisterType
                    })
                    .ToList());

        // Шаг 5: Генерируем код
        context.RegisterSourceOutput(groupedRegistrations,
            static (spc, source) => GenerateRegistrationCode(source, spc));
    }

    private static bool IsClassCandidate(SyntaxNode node)
    {
        return node is ClassDeclarationSyntax classDecl
               && !classDecl.IsAbstract()
               && !classDecl.IsStatic();
    }

    private static ClassInfo? GetClassSymbol(GeneratorSyntaxContext context)
    {
        var classDeclaration = (ClassDeclarationSyntax)context.Node;
        var classSymbol = context.SemanticModel.GetDeclaredSymbol(classDeclaration) as INamedTypeSymbol;

        if (classSymbol == null || classSymbol.IsAbstract)
            return null;

        return new ClassInfo
        {
            Symbol = classSymbol,
            FullName = classSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
            Name = classSymbol.Name
        };
    }

    private static ClassRegistration? ProcessClass(ClassInfo? classInfo, Compilation compilation)
    {
        if (!classInfo.HasValue)
            return null;

        var classSymbol = classInfo.Value.Symbol;

        // Собираем все интерфейсы, которые реализует класс
        var allInterfaces = classSymbol.AllInterfaces;

        // Ищем первый подходящий интерфейс
        foreach (var interfaceSymbol in allInterfaces)
        {
            var interfaceFullName = interfaceSymbol.ToDisplayString();

            // Проверяем наличие атрибута VContainerAutoRegistration
            var hasAttribute = HasAutoRegistrationAttribute(interfaceSymbol, compilation);
            if (hasAttribute.hasAttribute)
            {
                return new ClassRegistration
                {
                    ClassSymbol = classSymbol,
                    InterfaceSymbol = interfaceSymbol,
                    Lifetime = hasAttribute.lifetime,
                    RegisterType = hasAttribute.registerType,
                    FoundBy = "Attribute"
                };
            }

            // Проверяем вхождение в preparedInterfaces
            if (preparedInterfaces.TryGetValue(interfaceFullName, out var preparedSettings))
            {
                return new ClassRegistration
                {
                    ClassSymbol = classSymbol,
                    InterfaceSymbol = interfaceSymbol,
                    Lifetime = preparedSettings.Item1,
                    RegisterType = preparedSettings.Item2,
                    FoundBy = "PreparedList"
                };
            }
        }

        return null;
    }

    private static (bool hasAttribute, TargetLifetime lifetime, RegisterType registerType)
        HasAutoRegistrationAttribute(INamedTypeSymbol interfaceSymbol, Compilation compilation)
    {
        var autoRegistrationAttribute = compilation.GetTypeByMetadataName(Attribute);

        if (autoRegistrationAttribute == null)
            return (false, default, default);

        var attribute = interfaceSymbol.GetAttributes()
            .FirstOrDefault(attr =>
                attr.AttributeClass?.Equals(autoRegistrationAttribute, SymbolEqualityComparer.Default) == true);

        if (attribute == null)
            return (false, default, default);

        var lifetime = GetLifetimeFromAttribute(attribute);
        var registerType = GetRegisterTypeFromAttribute(attribute);

        return (true, lifetime, registerType);
    }

    private static TargetLifetime GetLifetimeFromAttribute(AttributeData attribute)
    {
        foreach (var namedArgument in attribute.NamedArguments)
        {
            if (namedArgument.Key == "Lifetime" && namedArgument.Value.Value is int lifetimeValue)
            {
                return (TargetLifetime)lifetimeValue;
            }
        }
        return TargetLifetime.Transient;
    }

    private static RegisterType GetRegisterTypeFromAttribute(AttributeData attribute)
    {
        foreach (var namedArgument in attribute.NamedArguments)
        {
            if (namedArgument.Key == "RegisterAs" && namedArgument.Value.Value is int registerAsValue)
            {
                return (RegisterType)registerAsValue;
            }
        }
        return RegisterType.ImplementedInterfaces;
    }

    private static void GenerateRegistrationCode(
        List<InterfaceRegistrationGroup> groups,
        SourceProductionContext context)
    {
        if (!groups.Any())
            return;

        // Генерируем основной файл регистраций
        GenerateMainRegistrationFile(groups, context);

        // Генерируем отдельные файлы для каждой группы интерфейсов
        foreach (var group in groups)
        {
            GenerateInterfaceRegistrationFile(group, context);
        }
    }

    private static void GenerateMainRegistrationFile(
        List<InterfaceRegistrationGroup> groups,
        SourceProductionContext context)
    {
        var sourceBuilder = StringBuilderPool.Get();

        sourceBuilder.AppendLine("// <auto-generated />");
        sourceBuilder.AppendLine("#nullable enable");
        sourceBuilder.AppendLine("using VContainer;");
        sourceBuilder.AppendLine();
        sourceBuilder.AppendLine("namespace VContainer.AutoRegistration.Generated");
        sourceBuilder.AppendLine("{");
        sourceBuilder.AppendLine("    public static partial class AutoGeneratedRegistrations");
        sourceBuilder.AppendLine("    {");
        sourceBuilder.AppendLine("        public static IContainerBuilder RegisterAllAutoDiscoveredTypes(this IContainerBuilder builder)");
        sourceBuilder.AppendLine("        {");

        foreach (var group in groups)
        {
            var methodName = GetSafeMethodName(group.InterfaceSymbol);
            sourceBuilder.AppendLine($"            builder.{methodName}();");
        }

        sourceBuilder.AppendLine("            return builder;");
        sourceBuilder.AppendLine("        }");
        sourceBuilder.AppendLine("    }");
        sourceBuilder.AppendLine("}");

        context.AddSource("AutoGeneratedRegistrations.Main.g.cs",
            SourceText.From(sourceBuilder.ToStringAndReturn(), Encoding.UTF8));
    }

    private static string GetSafeMethodName(INamedTypeSymbol interfaceSymbol)
    {
        var interfaceName = SafeInterfaceName(interfaceSymbol);

        return $"Register{interfaceName}Implementations";
    }

    private static string SafeInterfaceName(INamedTypeSymbol interfaceSymbol)
    {
        return interfaceSymbol.ToDisplayString()
            .Replace(".", "_")
            .Replace("<", "_")
            .Replace(">", "_")
            .Replace(",", "_");
    }

    private static string GetSafeFileName(INamedTypeSymbol interfaceSymbol)
    {
        var interfaceName = SafeInterfaceName(interfaceSymbol);
        return interfaceName;
    }

    private static void GenerateInterfaceRegistrationFile(
            InterfaceRegistrationGroup group,
            SourceProductionContext context)
        {
            var sourceBuilder = StringBuilderPool.Get();

            sourceBuilder.AppendLine("// <auto-generated />");
            sourceBuilder.AppendLine("#nullable enable");
            sourceBuilder.AppendLine("using VContainer;");
            sourceBuilder.AppendLine();
            sourceBuilder.AppendLine("namespace VContainer.AutoRegistration.Generated");
            sourceBuilder.AppendLine("{");
            sourceBuilder.AppendLine("    public static partial class AutoGeneratedRegistrations");
            sourceBuilder.AppendLine("    {");

            var methodName = GetSafeMethodName(group.InterfaceSymbol);
            var interfaceFullName = group.InterfaceSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);

            sourceBuilder.AppendLine($"        public static IContainerBuilder {methodName}(this IContainerBuilder builder)");
            sourceBuilder.AppendLine("        {");

            foreach (var registration in group.ClassRegistrations)
            {
                var className = registration.ClassSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);

                sourceBuilder.AppendLine($"            // {registration.ClassSymbol.Name} -> {registration.InterfaceSymbol.Name} ({registration.FoundBy})");

                var registrationLine = registration.RegisterType switch
                {
                    RegisterType.Self =>
                        $"builder.Register<{className}>(Lifetime.{registration.Lifetime}).AsSelf();",
                    RegisterType.ImplementedInterfaces =>
                        $"builder.Register<{className}>(Lifetime.{registration.Lifetime}).AsImplementedInterfaces();",
                    RegisterType.Both =>
                        $"builder.Register<{className}>(Lifetime.{registration.Lifetime}).AsImplementedInterfaces().AsSelf();",
                    _ => string.Empty
                };

                if (!string.IsNullOrEmpty(registrationLine))
                {
                    sourceBuilder.AppendLine($"            {registrationLine}");
                }
                sourceBuilder.AppendLine();
            }

            sourceBuilder.AppendLine("            return builder;");
            sourceBuilder.AppendLine("        }");
            sourceBuilder.AppendLine("    }");
            sourceBuilder.AppendLine("}");

            var fileName = $"AutoGeneratedRegistrations.{GetSafeFileName(group.InterfaceSymbol)}.g.cs";
            context.AddSource(fileName, SourceText.From(sourceBuilder.ToStringAndReturn(), Encoding.UTF8));
        }
}

// Вспомогательные структуры
internal struct ClassInfo
{
    public INamedTypeSymbol Symbol { get; set; }
    public string FullName { get; set; }
    public string Name { get; set; }
}

internal class ClassRegistration
{
    public INamedTypeSymbol ClassSymbol { get; set; } = null!;
    public INamedTypeSymbol InterfaceSymbol { get; set; } = null!;
    public TargetLifetime Lifetime { get; set; }
    public RegisterType RegisterType { get; set; }
    public string FoundBy { get; set; } = string.Empty;
}

internal class InterfaceRegistrationGroup
{
    public string InterfaceFullName { get; set; } = string.Empty;
    public INamedTypeSymbol InterfaceSymbol { get; set; } = null!;
    public List<ClassRegistration> ClassRegistrations { get; set; } = new();
    public TargetLifetime Lifetime { get; set; }
    public RegisterType RegisterType { get; set; }
}

public enum TargetLifetime
{
    Transient,
    Scoped,
    Singleton
}

public enum RegisterType
{
    Self,
    ImplementedInterfaces,
    Both
}