// 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.Text;
using ILLink.Shared.DataFlow;
using Mono.Cecil;
using Mono.Linker.Dataflow;
using MultiValue = ILLink.Shared.DataFlow.ValueSet<ILLink.Shared.DataFlow.SingleValue>;
 
 
namespace ILLink.Shared.TrimAnalysis
{
	internal partial record ArrayValue
	{
		public static MultiValue Create (MultiValue size, TypeReference elementType)
		{
			MultiValue result = MultiValueLattice.Top;
			foreach (var sizeValue in size.AsEnumerable ()) {
				result = MultiValueLattice.Meet (result, new MultiValue (new ArrayValue (sizeValue, elementType)));
			}
 
			return result;
		}
 
		public static ArrayValue Create (int size, TypeReference elementType)
		{
			return new ArrayValue (new ConstIntValue (size), elementType);
		}
 
		/// <summary>
		/// Constructs an array value of the given size
		/// </summary>
		ArrayValue (SingleValue size, TypeReference elementType)
		{
			Size = size;
			ElementType = elementType;
			IndexValues = new Dictionary<int, ValueBasicBlockPair> ();
		}
 
		public TypeReference ElementType { get; }
		public Dictionary<int, ValueBasicBlockPair> IndexValues { get; }
 
		public partial bool TryGetValueByIndex (int index, out MultiValue value)
		{
			if (IndexValues.TryGetValue (index, out var valuePair)) {
				value = valuePair.Value;
				return true;
			}
 
			value = default;
			return false;
		}
 
		public override int GetHashCode ()
		{
			return HashCode.Combine (GetType ().GetHashCode (), Size);
		}
 
		public bool Equals (ArrayValue? otherArr)
		{
			if (otherArr == null)
				return false;
 
			bool equals = Size.Equals (otherArr.Size);
			equals &= IndexValues.Count == otherArr.IndexValues.Count;
			if (!equals)
				return false;
 
			// Here we rely on the assumption that we can't store mutable values in arrays. The only mutable value
			// which we currently support are array values, but those are not allowed in an array (to avoid complexity).
			// As such we can rely on the values to be immutable, and thus if the counts are equal
			// then the arrays are equal if items from one can be directly found in the other.
			foreach (var kvp in IndexValues)
				if (!otherArr.IndexValues.TryGetValue (kvp.Key, out ValueBasicBlockPair value) || !kvp.Value.Equals (value))
					return false;
 
			return true;
		}
 
		public override SingleValue DeepCopy ()
		{
			var newValue = new ArrayValue (Size.DeepCopy (), ElementType);
			foreach (var kvp in IndexValues) {
#if DEBUG
				// Since it's possible to store a reference to array as one of its own elements
				// simple deep copy could lead to endless recursion.
				// So instead we simply disallow arrays as element values completely - and treat that case as "too complex to analyze".
				foreach (SingleValue v in kvp.Value.Value.AsEnumerable ()) {
					System.Diagnostics.Debug.Assert (v is not ArrayValue);
				}
#endif
 
				newValue.IndexValues.Add (kvp.Key, new ValueBasicBlockPair (kvp.Value.Value.DeepCopy (), kvp.Value.BasicBlockIndex));
			}
 
			return newValue;
		}
 
		public override string ToString ()
		{
			StringBuilder result = new ();
			result.Append ("Array Size:");
			result.Append (this.ValueToString (Size));
 
			result.Append (", Values:(");
			bool first = true;
			foreach (var element in IndexValues) {
				if (!first) {
					result.Append (',');
					first = false;
				}
 
				result.Append ('(');
				result.Append (element.Key);
				result.Append (",(");
				bool firstValue = true;
				foreach (var v in element.Value.Value.AsEnumerable ()) {
					if (firstValue) {
						result.Append (',');
						firstValue = false;
					}
 
					result.Append (v.ToString ());
				}
				result.Append ("))");
			}
			result.Append (')');
 
			return result.ToString ();
		}
	}
}