// 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.Diagnostics;
using Microsoft.Cci;
using Microsoft.CodeAnalysis.CSharp.Emit;
using Microsoft.CodeAnalysis.Emit;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.CSharp.Symbols
{
    internal partial class
#if DEBUG
        EventSymbolAdapter : SymbolAdapter,
#else
        EventSymbol :
#endif 
        Cci.IEventDefinition
    {
        bool Cci.IDefinition.IsEncDeleted
            => false;

        #region IEventDefinition Members

        IEnumerable<Cci.IMethodReference> Cci.IEventDefinition.GetAccessors(EmitContext context)
        {
            CheckDefinitionInvariant();

            var addMethod = AdaptedEventSymbol.AddMethod?.GetCciAdapter();
            RoslynDebug.Assert((object?)addMethod != null);
            if (addMethod.ShouldInclude(context))
            {
                yield return addMethod;
            }

            var removeMethod = AdaptedEventSymbol.RemoveMethod?.GetCciAdapter();
            RoslynDebug.Assert((object?)removeMethod != null);
            if (removeMethod.ShouldInclude(context))
            {
                yield return removeMethod;
            }
        }

        Cci.IMethodReference Cci.IEventDefinition.Adder
        {
            get
            {
                CheckDefinitionInvariant();
                var addMethod = AdaptedEventSymbol.AddMethod?.GetCciAdapter();
                RoslynDebug.Assert((object?)addMethod != null);
                return addMethod;
            }
        }

        Cci.IMethodReference Cci.IEventDefinition.Remover
        {
            get
            {
                CheckDefinitionInvariant();
                var removeMethod = AdaptedEventSymbol.RemoveMethod?.GetCciAdapter();
                RoslynDebug.Assert((object?)removeMethod != null);
                return removeMethod;
            }
        }

        bool Cci.IEventDefinition.IsRuntimeSpecial
        {
            get
            {
                CheckDefinitionInvariant();
                return AdaptedEventSymbol.HasRuntimeSpecialName;
            }
        }

        bool Cci.IEventDefinition.IsSpecialName
        {
            get
            {
                CheckDefinitionInvariant();
                return AdaptedEventSymbol.HasSpecialName;
            }
        }

        Cci.IMethodReference? Cci.IEventDefinition.Caller
        {
            get
            {
                CheckDefinitionInvariant();
                return null; // C# doesn't use the raise/fire accessor
            }
        }

        Cci.ITypeReference Cci.IEventDefinition.GetType(EmitContext context)
        {
            return ((PEModuleBuilder)context.Module).Translate(AdaptedEventSymbol.Type, syntaxNodeOpt: (CSharpSyntaxNode?)context.SyntaxNode, diagnostics: context.Diagnostics);
        }

        #endregion

        #region ITypeDefinitionMember Members

        Cci.ITypeDefinition Cci.ITypeDefinitionMember.ContainingTypeDefinition
        {
            get
            {
                CheckDefinitionInvariant();
                return AdaptedEventSymbol.ContainingType.GetCciAdapter();
            }
        }

        Cci.TypeMemberVisibility Cci.ITypeDefinitionMember.Visibility
        {
            get
            {
                CheckDefinitionInvariant();
                return AdaptedEventSymbol.MetadataVisibility;
            }
        }

        #endregion

        #region ITypeMemberReference Members

        Cci.ITypeReference Cci.ITypeMemberReference.GetContainingType(EmitContext context)
        {
            CheckDefinitionInvariant();
            return AdaptedEventSymbol.ContainingType.GetCciAdapter();
        }

        #endregion

        #region IReference Members

        void Cci.IReference.Dispatch(Cci.MetadataVisitor visitor)
        {
            CheckDefinitionInvariant();
            visitor.Visit((Cci.IEventDefinition)this);
        }

        Cci.IDefinition Cci.IReference.AsDefinition(EmitContext context)
        {
            CheckDefinitionInvariant();
            return this;
        }

        #endregion

        #region INamedEntity Members

        string Cci.INamedEntity.Name
        {
            get
            {
                CheckDefinitionInvariant();
                return AdaptedEventSymbol.MetadataName;
            }
        }

        #endregion
    }

    internal partial class EventSymbol
    {
#if DEBUG
        private EventSymbolAdapter? _lazyAdapter;

        protected sealed override SymbolAdapter GetCciAdapterImpl() => GetCciAdapter();

        internal new EventSymbolAdapter GetCciAdapter()
        {
            if (_lazyAdapter is null)
            {
                return InterlockedOperations.Initialize(ref _lazyAdapter, new EventSymbolAdapter(this));
            }

            return _lazyAdapter;
        }
#else
        internal EventSymbol AdaptedEventSymbol => this;

        internal new EventSymbol GetCciAdapter()
        {
            return this;
        }
#endif

        internal virtual bool HasRuntimeSpecialName
        {
            get
            {
                CheckDefinitionInvariant();
                return false;
            }
        }
    }

#if DEBUG
    internal partial class EventSymbolAdapter
    {
        internal EventSymbolAdapter(EventSymbol underlyingEventSymbol)
        {
            AdaptedEventSymbol = underlyingEventSymbol;
        }

        internal sealed override Symbol AdaptedSymbol => AdaptedEventSymbol;
        internal EventSymbol AdaptedEventSymbol { get; }
    }
#endif
}