using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Microsoft.Cci;
using Microsoft.CodeAnalysis.CSharp.Emit;
using Microsoft.CodeAnalysis.CSharp.Emit.NoPia;
using Microsoft.CodeAnalysis.CSharp.Symbols.PublicModel;
using Microsoft.CodeAnalysis.Emit;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.CSharp.Symbols;

internal abstract class EventSymbol : Symbol, IEventDefinition, ITypeDefinitionMember, ITypeMemberReference, IReference, INamedEntity, IDefinition
{
	IMethodReference IEventDefinition.Adder => (IMethodReference)(object)AdaptedEventSymbol.AddMethod?.GetCciAdapter();

	IMethodReference IEventDefinition.Remover => (IMethodReference)(object)AdaptedEventSymbol.RemoveMethod?.GetCciAdapter();

	bool IEventDefinition.IsRuntimeSpecial => AdaptedEventSymbol.HasRuntimeSpecialName;

	bool IEventDefinition.IsSpecialName => AdaptedEventSymbol.HasSpecialName;

	IMethodReference? IEventDefinition.Caller => null;

	ITypeDefinition ITypeDefinitionMember.ContainingTypeDefinition => (ITypeDefinition)(object)AdaptedEventSymbol.ContainingType.GetCciAdapter();

	TypeMemberVisibility ITypeDefinitionMember.Visibility => PEModuleBuilder.MemberVisibility(AdaptedEventSymbol);

	string INamedEntity.Name => AdaptedEventSymbol.MetadataName;

	internal EventSymbol AdaptedEventSymbol => this;

	internal virtual bool HasRuntimeSpecialName => false;

	public new virtual EventSymbol OriginalDefinition => this;

	protected sealed override Symbol OriginalSymbolDefinition => OriginalDefinition;

	public abstract TypeWithAnnotations TypeWithAnnotations { get; }

	public TypeSymbol Type => TypeWithAnnotations.Type;

	public abstract MethodSymbol? AddMethod { get; }

	public abstract MethodSymbol? RemoveMethod { get; }

	internal bool HasAssociatedField => (object)AssociatedField != null;

	public virtual bool RequiresInstanceReceiver => !IsStatic;

	public abstract bool IsWindowsRuntimeEvent { get; }

	internal virtual bool IsDirectlyExcludedFromCodeCoverage => false;

	internal abstract bool HasSpecialName { get; }

	internal virtual FieldSymbol? AssociatedField => null;

	public EventSymbol? OverriddenEvent
	{
		get
		{
			if (IsOverride)
			{
				if (base.IsDefinition)
				{
					return (EventSymbol)OverriddenOrHiddenMembers.GetOverriddenMember();
				}
				return (EventSymbol)OverriddenOrHiddenMembersResult.GetOverriddenMember(this, OriginalDefinition.OverriddenEvent);
			}
			return null;
		}
	}

	internal virtual OverriddenOrHiddenMembersResult OverriddenOrHiddenMembers => this.MakeOverriddenOrHiddenMembers();

	internal bool HidesBaseEventsByName => (AddMethod ?? RemoveMethod)?.HidesBaseMethodsByName ?? false;

	internal virtual bool IsExplicitInterfaceImplementation => ExplicitInterfaceImplementations.Any();

	public abstract ImmutableArray<EventSymbol> ExplicitInterfaceImplementations { get; }

	public sealed override SymbolKind Kind => (SymbolKind)5;

	internal abstract bool MustCallMethodsDirectly { get; }

	public sealed override bool HasUnsupportedMetadata
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			DiagnosticInfo diagnosticInfo = GetUseSiteInfo().DiagnosticInfo;
			bool flag = diagnosticInfo != null;
			if (flag)
			{
				int code = diagnosticInfo.Code;
				bool flag2 = ((code == 570 || code == 9041) ? true : false);
				flag = flag2;
			}
			return flag;
		}
	}

	IEnumerable<IMethodReference> IEventDefinition.GetAccessors(EmitContext context)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		MethodSymbol methodSymbol = AdaptedEventSymbol.AddMethod?.GetCciAdapter();
		if (Extensions.ShouldInclude((ITypeDefinitionMember)(object)methodSymbol, context))
		{
			yield return (IMethodReference)(object)methodSymbol;
		}
		MethodSymbol methodSymbol2 = AdaptedEventSymbol.RemoveMethod?.GetCciAdapter();
		if (Extensions.ShouldInclude((ITypeDefinitionMember)(object)methodSymbol2, context))
		{
			yield return (IMethodReference)(object)methodSymbol2;
		}
	}

	ITypeReference IEventDefinition.GetType(EmitContext context)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		return ((PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, EmbeddedTypesManager, ModuleCompilationState>)(PEModuleBuilder)(object)context.Module).Translate(AdaptedEventSymbol.Type, (SyntaxNode)(object)(CSharpSyntaxNode)(object)((EmitContext)(ref context)).SyntaxNode, context.Diagnostics);
	}

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

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

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

	internal new EventSymbol GetCciAdapter()
	{
		return this;
	}

	internal EventSymbol()
	{
	}

	public ImmutableArray<CSharpAttributeData> GetFieldAttributes()
	{
		if ((object)AssociatedField != null)
		{
			return AssociatedField.GetAttributes();
		}
		return ImmutableArray<CSharpAttributeData>.Empty;
	}

	internal EventSymbol GetLeastOverriddenEvent(NamedTypeSymbol? accessingTypeOpt)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		accessingTypeOpt = accessingTypeOpt?.OriginalDefinition;
		EventSymbol eventSymbol = this;
		while (eventSymbol.IsOverride && !eventSymbol.HidesBaseEventsByName)
		{
			EventSymbol overriddenEvent = eventSymbol.OverriddenEvent;
			CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
			if ((object)overriddenEvent == null || ((object)accessingTypeOpt != null && !AccessCheck.IsSymbolAccessible(overriddenEvent, accessingTypeOpt, ref useSiteInfo)))
			{
				break;
			}
			eventSymbol = overriddenEvent;
		}
		return eventSymbol;
	}

	internal override TResult Accept<TArgument, TResult>(CSharpSymbolVisitor<TArgument, TResult> visitor, TArgument argument)
	{
		return visitor.VisitEvent(this, argument);
	}

	public override void Accept(CSharpSymbolVisitor visitor)
	{
		visitor.VisitEvent(this);
	}

	public override TResult Accept<TResult>(CSharpSymbolVisitor<TResult> visitor)
	{
		return visitor.VisitEvent(this);
	}

	internal EventSymbol AsMember(NamedTypeSymbol newOwner)
	{
		if (!newOwner.IsDefinition)
		{
			return new SubstitutedEventSymbol(newOwner as SubstitutedNamedTypeSymbol, this);
		}
		return this;
	}

	internal override UseSiteInfo<AssemblySymbol> GetUseSiteInfo()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		if (base.IsDefinition)
		{
			return new UseSiteInfo<AssemblySymbol>(base.PrimaryDependency);
		}
		return OriginalDefinition.GetUseSiteInfo();
	}

	internal bool CalculateUseSiteDiagnostic(ref UseSiteInfo<AssemblySymbol> result)
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		if (DeriveUseSiteInfoFromType(ref result, TypeWithAnnotations, AllowedRequiredModifierType.None))
		{
			return true;
		}
		if (ContainingModule.HasUnifiedReferences)
		{
			HashSet<TypeSymbol> checkedTypes = null;
			DiagnosticInfo result2 = result.DiagnosticInfo;
			if (TypeWithAnnotations.GetUnificationUseSiteDiagnosticRecursive(ref result2, this, ref checkedTypes))
			{
				result = result.AdjustDiagnosticInfo(result2);
				return true;
			}
			result = result.AdjustDiagnosticInfo(result2);
		}
		return false;
	}

	protected sealed override bool IsHighestPriorityUseSiteErrorCode(int code)
	{
		if (code == 570 || code == 9041)
		{
			return true;
		}
		return false;
	}

	protected sealed override ISymbol CreateISymbol()
	{
		return (ISymbol)(object)new Microsoft.CodeAnalysis.CSharp.Symbols.PublicModel.EventSymbol(this);
	}

	public override bool Equals(Symbol? obj, TypeCompareKind compareKind)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		if (!(obj is EventSymbol eventSymbol))
		{
			return false;
		}
		if ((object)this == eventSymbol)
		{
			return true;
		}
		if (TypeSymbol.Equals(ContainingType, eventSymbol.ContainingType, compareKind))
		{
			return (object)OriginalDefinition == eventSymbol.OriginalDefinition;
		}
		return false;
	}

	public override int GetHashCode()
	{
		int num = 1;
		num = Hash.Combine<NamedTypeSymbol>(ContainingType, num);
		return Hash.Combine<string>(Name, num);
	}
}