// 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.Collections.Generic;
using System.Linq;
using System.Threading;
using Microsoft.CodeAnalysis.CodeGeneration;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.CSharp.CodeGeneration;
 
using static CodeGenerationHelpers;
using static CSharpCodeGenerationHelpers;
using static CSharpSyntaxTokens;
using static SyntaxFactory;
 
internal static class EventGenerator
{
    private static MemberDeclarationSyntax? AfterMember(
        SyntaxList<MemberDeclarationSyntax> members,
        MemberDeclarationSyntax eventDeclaration)
    {
        if (eventDeclaration.Kind() == SyntaxKind.EventFieldDeclaration)
        {
            // Field style events go after the last field event, or after the last field.
            var lastEvent = members.LastOrDefault(m => m is EventFieldDeclarationSyntax);
 
            return lastEvent ?? LastField(members);
        }
 
        if (eventDeclaration.Kind() == SyntaxKind.EventDeclaration)
        {
            // Property style events go after existing events, then after existing constructors.
            var lastEvent = members.LastOrDefault(m => m is EventDeclarationSyntax);
 
            return lastEvent ?? LastConstructor(members);
        }
 
        return null;
    }
 
    private static MemberDeclarationSyntax? BeforeMember(
        SyntaxList<MemberDeclarationSyntax> members,
        MemberDeclarationSyntax eventDeclaration)
    {
        // If it's a field style event, then it goes before everything else if we don't have any
        // existing fields/events.
        if (eventDeclaration.Kind() == SyntaxKind.FieldDeclaration)
        {
            return members.FirstOrDefault();
        }
 
        // Otherwise just place it before the methods.
        return FirstMethod(members);
    }
 
    internal static CompilationUnitSyntax AddEventTo(
        CompilationUnitSyntax destination,
        IEventSymbol @event,
        CSharpCodeGenerationContextInfo info,
        IList<bool> availableIndices,
        CancellationToken cancellationToken)
    {
        var declaration = GenerateEventDeclaration(@event, CodeGenerationDestination.CompilationUnit, info, cancellationToken);
 
        // Place the event depending on its shape.  Field style events go with fields, property
        // style events go with properties.  If there 
        var members = Insert(destination.Members, declaration, info, availableIndices,
            after: list => AfterMember(list, declaration), before: list => BeforeMember(list, declaration));
        return destination.WithMembers([.. members]);
    }
 
    internal static TypeDeclarationSyntax AddEventTo(
        TypeDeclarationSyntax destination,
        IEventSymbol @event,
        CSharpCodeGenerationContextInfo info,
        IList<bool>? availableIndices,
        CancellationToken cancellationToken)
    {
        var declaration = GenerateEventDeclaration(@event, GetDestination(destination), info, cancellationToken);
 
        var members = Insert(destination.Members, declaration, info, availableIndices,
            after: list => AfterMember(list, declaration),
            before: list => BeforeMember(list, declaration));
 
        // Find the best place to put the field.  It should go after the last field if we already
        // have fields, or at the beginning of the file if we don't.
 
        return AddMembersTo(destination, members, cancellationToken);
    }
 
    public static MemberDeclarationSyntax GenerateEventDeclaration(
        IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info, CancellationToken cancellationToken)
    {
        var reusableSyntax = GetReuseableSyntaxNodeForSymbol<MemberDeclarationSyntax>(@event, info);
        if (reusableSyntax != null)
        {
            return reusableSyntax;
        }
 
        var declaration = !info.Context.GenerateMethodBodies || @event.IsAbstract || @event.AddMethod == null || @event.RemoveMethod == null
            ? GenerateEventFieldDeclaration(@event, destination, info)
            : GenerateEventDeclarationWorker(@event, destination, info);
 
        return AddAnnotationsTo(@event,
            ConditionallyAddDocumentationCommentTo(declaration, @event, info, cancellationToken));
    }
 
    private static MemberDeclarationSyntax GenerateEventFieldDeclaration(
        IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info)
    {
        return AddFormatterAndCodeGeneratorAnnotationsTo(
            AddAnnotationsTo(@event,
                EventFieldDeclaration(
                    AttributeGenerator.GenerateAttributeLists(@event.GetAttributes(), info),
                    GenerateModifiers(@event, destination, info),
                    VariableDeclaration(
                        @event.Type.GenerateTypeSyntax(),
                        [VariableDeclarator(@event.Name.ToIdentifierToken())]))));
    }
 
    private static MemberDeclarationSyntax GenerateEventDeclarationWorker(
        IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info)
    {
        var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(@event.ExplicitInterfaceImplementations);
 
        var isExplicit = explicitInterfaceSpecifier is not null;
        return AddFormatterAndCodeGeneratorAnnotationsTo(EventDeclaration(
            attributeLists: GenerateAttributes(@event, isExplicit, info),
            modifiers: GenerateModifiers(@event, destination, info),
            type: @event.Type.GenerateTypeSyntax(),
            explicitInterfaceSpecifier: explicitInterfaceSpecifier,
            identifier: @event.Name.ToIdentifierToken(),
            accessorList: GenerateAccessorList(@event, destination, info)));
    }
 
    private static SyntaxList<AttributeListSyntax> GenerateAttributes(
        IEventSymbol @event, bool isExplicit, CSharpCodeGenerationContextInfo info)
    {
        if (isExplicit)
        {
            return default;
        }
 
        var attributes = @event.GetAttributes();
        if (attributes.Length == 0)
        {
            return default;
        }
 
        return AttributeGenerator.GenerateAttributeLists(attributes, info);
    }
 
    private static AccessorListSyntax GenerateAccessorList(
        IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info)
    {
        var accessors = new List<AccessorDeclarationSyntax?>
        {
            GenerateAccessorDeclaration(@event, @event.AddMethod, SyntaxKind.AddAccessorDeclaration, destination, info),
            GenerateAccessorDeclaration(@event, @event.RemoveMethod, SyntaxKind.RemoveAccessorDeclaration, destination, info),
        };
 
        return AccessorList([.. accessors.WhereNotNull()]);
    }
 
    private static AccessorDeclarationSyntax? GenerateAccessorDeclaration(
        IEventSymbol @event,
        IMethodSymbol? accessor,
        SyntaxKind kind,
        CodeGenerationDestination destination,
        CSharpCodeGenerationContextInfo info)
    {
        var hasBody = info.Context.GenerateMethodBodies && HasAccessorBodies(@event, destination, accessor);
        return accessor == null
            ? null
            : GenerateAccessorDeclaration(accessor, kind, hasBody);
    }
 
    private static AccessorDeclarationSyntax GenerateAccessorDeclaration(
        IMethodSymbol accessor,
        SyntaxKind kind,
        bool hasBody)
    {
        return AddAnnotationsTo(accessor, AccessorDeclaration(kind)
                            .WithBody(hasBody ? GenerateBlock(accessor) : null)
                            .WithSemicolonToken(hasBody ? default : SemicolonToken));
    }
 
    private static BlockSyntax GenerateBlock(IMethodSymbol accessor)
    {
        return Block(
            StatementGenerator.GenerateStatements(CodeGenerationMethodInfo.GetStatements(accessor)));
    }
 
    private static bool HasAccessorBodies(
        IEventSymbol @event,
        CodeGenerationDestination destination,
        IMethodSymbol? accessor)
    {
        return destination != CodeGenerationDestination.InterfaceType &&
            !@event.IsAbstract &&
            accessor != null &&
            !accessor.IsAbstract;
    }
 
    private static SyntaxTokenList GenerateModifiers(
        IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info)
    {
        using var _ = ArrayBuilder<SyntaxToken>.GetInstance(out var tokens);
 
        // Only "static" allowed if we're an explicit impl.
        if (@event.ExplicitInterfaceImplementations.Any())
        {
            if (@event.IsStatic)
                tokens.Add(StaticKeyword);
        }
        else
        {
            // If we're generating into an interface, then allow modifiers for static abstract members
            if (destination is CodeGenerationDestination.InterfaceType)
            {
                if (@event.IsStatic)
                {
                    tokens.Add(StaticKeyword);
 
                    // We only generate the abstract keyword in interfaces for static abstract members
                    if (@event.IsAbstract)
                        tokens.Add(AbstractKeyword);
                }
            }
            else
            {
                AddAccessibilityModifiers(@event.DeclaredAccessibility, tokens, info, Accessibility.Private);
 
                if (@event.IsStatic)
                    tokens.Add(StaticKeyword);
 
                // An event is readonly if its accessors are readonly.
                // If one accessor is readonly and the other one is not,
                // the event is malformed and cannot be properly displayed.
                // See https://github.com/dotnet/roslyn/issues/34213
                // Don't show the readonly modifier if the containing type is already readonly
                if (@event.AddMethod?.IsReadOnly == true && !@event.ContainingType.IsReadOnly)
                    tokens.Add(ReadOnlyKeyword);
 
                if (@event.IsAbstract)
                    tokens.Add(AbstractKeyword);
 
                if (@event.IsOverride)
                    tokens.Add(OverrideKeyword);
            }
        }
 
        if (CodeGenerationEventInfo.GetIsUnsafe(@event))
            tokens.Add(UnsafeKeyword);
 
        return [.. tokens];
    }
}