using Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax;

namespace Microsoft.CodeAnalysis.CSharp.Syntax;

public sealed class SwitchExpressionArmSyntax : CSharpSyntaxNode
{
	private PatternSyntax? pattern;

	private WhenClauseSyntax? whenClause;

	private ExpressionSyntax? expression;

	public PatternSyntax Pattern => ((SyntaxNode)this).GetRedAtZero<PatternSyntax>(ref pattern);

	public WhenClauseSyntax? WhenClause => ((SyntaxNode)this).GetRed<WhenClauseSyntax>(ref whenClause, 1);

	public SyntaxToken EqualsGreaterThanToken => new SyntaxToken((SyntaxNode)(object)this, (GreenNode)(object)((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SwitchExpressionArmSyntax)(object)((SyntaxNode)this).Green).equalsGreaterThanToken, ((SyntaxNode)this).GetChildPosition(2), ((SyntaxNode)this).GetChildIndex(2));

	public ExpressionSyntax Expression => ((SyntaxNode)this).GetRed<ExpressionSyntax>(ref expression, 3);

	internal SwitchExpressionArmSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)
		: base((GreenNode)(object)green, parent, position)
	{
	}

	internal override SyntaxNode? GetNodeSlot(int index)
	{
		return (SyntaxNode?)(index switch
		{
			0 => ((SyntaxNode)this).GetRedAtZero<PatternSyntax>(ref pattern), 
			1 => ((SyntaxNode)this).GetRed<WhenClauseSyntax>(ref whenClause, 1), 
			3 => ((SyntaxNode)this).GetRed<ExpressionSyntax>(ref expression, 3), 
			_ => null, 
		});
	}

	internal override SyntaxNode? GetCachedSlot(int index)
	{
		return (SyntaxNode?)(index switch
		{
			0 => pattern, 
			1 => whenClause, 
			3 => expression, 
			_ => null, 
		});
	}

	public override void Accept(CSharpSyntaxVisitor visitor)
	{
		visitor.VisitSwitchExpressionArm(this);
	}

	public override TResult? Accept<TResult>(CSharpSyntaxVisitor<TResult> visitor)
	{
		return visitor.VisitSwitchExpressionArm(this);
	}

	public SwitchExpressionArmSyntax Update(PatternSyntax pattern, WhenClauseSyntax? whenClause, SyntaxToken equalsGreaterThanToken, ExpressionSyntax expression)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (pattern != Pattern || whenClause != WhenClause || equalsGreaterThanToken != EqualsGreaterThanToken || expression != Expression)
		{
			SwitchExpressionArmSyntax switchExpressionArmSyntax = SyntaxFactory.SwitchExpressionArm(pattern, whenClause, equalsGreaterThanToken, expression);
			SyntaxAnnotation[] annotations = ((SyntaxNode)this).GetAnnotations();
			if (annotations == null || annotations.Length == 0)
			{
				return switchExpressionArmSyntax;
			}
			return switchExpressionArmSyntax.WithAnnotations(annotations);
		}
		return this;
	}

	public SwitchExpressionArmSyntax WithPattern(PatternSyntax pattern)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		return Update(pattern, WhenClause, EqualsGreaterThanToken, Expression);
	}

	public SwitchExpressionArmSyntax WithWhenClause(WhenClauseSyntax? whenClause)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		return Update(Pattern, whenClause, EqualsGreaterThanToken, Expression);
	}

	public SwitchExpressionArmSyntax WithEqualsGreaterThanToken(SyntaxToken equalsGreaterThanToken)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		return Update(Pattern, WhenClause, equalsGreaterThanToken, Expression);
	}

	public SwitchExpressionArmSyntax WithExpression(ExpressionSyntax expression)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		return Update(Pattern, WhenClause, EqualsGreaterThanToken, expression);
	}
}