// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics.CodeAnalysis;
 
// This is needed due to NativeAOT which doesn't enable nullable globally yet
#nullable enable
 
namespace ILLink.Shared.DataFlow
{
	public enum RegionKind
	{
		Try,
		Catch,
		Filter,
		Finally
	}
 
	public enum ConditionKind
	{
		Unconditional,
		WhenFalse,
		WhenTrue,
		Unknown
	}
 
	public interface IRegion<TRegion> : IEquatable<TRegion>
	{
		RegionKind Kind { get; }
	}
 
	public interface IBlock<TBlock> : IEquatable<TBlock>
	{
	}
 
	public interface IControlFlowGraph<TBlock, TRegion>
		where TBlock : struct, IBlock<TBlock>
		where TRegion : IRegion<TRegion>
	{
 
		// Represents an edge in the control flow graph, from a source to a destination basic block.
		public readonly struct ControlFlowBranch : IEquatable<ControlFlowBranch>
		{
			public readonly TBlock Source;
 
			// Might be null in a 'throw' branch.
			public readonly TBlock? Destination;
 
			public readonly ConditionKind ConditionKind;
 
			// The finally regions exited when control flows through this edge.
			// For example:
			//
			// try {
			//     try {
			//         Source();
			//     }
			//     finally {}
			// } finally {}
			// Target();
			//
			// There will be an edge in the CRFG from the block that calls
			// Source() to the block that calls Target(), which exits both
			// finally regions.
			public readonly ImmutableArray<TRegion> FinallyRegions;
 
			public ControlFlowBranch (TBlock source, TBlock? destination, ImmutableArray<TRegion> finallyRegions, ConditionKind conditionKind)
			{
				Source = source;
				Destination = destination;
				FinallyRegions = finallyRegions;
				ConditionKind = conditionKind;
			}
 
			public bool Equals (ControlFlowBranch other)
			{
				if (!Source.Equals (other.Source))
					return false;
 
				if (ConditionKind != other.ConditionKind)
					return false;
 
				if (Destination == null)
					return other.Destination == null;
 
				return Destination.Equals (other.Destination);
			}
 
			public override bool Equals (object? obj)
			{
				return obj is ControlFlowBranch other && Equals (other);
			}
 
			public override int GetHashCode ()
			{
				return HashUtils.Combine (
					Source.GetHashCode (),
					Destination?.GetHashCode () ?? typeof (ControlFlowBranch).GetHashCode (),
					ConditionKind.GetHashCode ());
			}
		}
 
		IEnumerable<TBlock> Blocks { get; }
 
		TBlock Entry { get; }
 
		// This does not include predecessor edges for exceptional control flow into
		// catch regions or finally regions. It also doesn't include edges for non-exceptional
		// control flow from try -> finally or from catch -> finally.
		IEnumerable<ControlFlowBranch> GetPredecessors (TBlock block);
 
		IEnumerable<ControlFlowBranch> GetSuccessors (TBlock block);
 
		bool TryGetEnclosingTryOrCatchOrFilter (TBlock block, [NotNullWhen (true)] out TRegion? tryOrCatchOrFilterRegion);
 
		bool TryGetEnclosingTryOrCatchOrFilter (TRegion region, [NotNullWhen (true)] out TRegion? tryOrCatchOrFilterRegion);
 
		bool TryGetEnclosingFinally (TBlock block, [NotNullWhen (true)] out TRegion? region);
 
		TRegion GetCorrespondingTry (TRegion cathOrFilterOrFinallyRegion);
 
		IEnumerable<TRegion> GetPreviousFilters (TRegion catchOrFilterRegion);
 
		bool HasFilter (TRegion catchRegion);
 
		TBlock FirstBlock (TRegion region);
 
		TBlock LastBlock (TRegion region);
	}
}