using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using JetBrains.Annotations;

namespace Fluctio.FluctioSim.Utils.General
{
	// TODO: support enums based on unsigned types?
	[SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
	[SuppressMessage("ReSharper", "UnusedMember.Global")]
	[SuppressMessage("ReSharper", "UnusedMethodReturnValue.Global")]
	public static class Flags
	{
		#region Helpers
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static long ToLong<T>(this T @enum)
			where T : struct, Enum
		{
			return Convert.ToInt64(@enum);
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static T ToEnum<T>(this long @long)
			where T : struct, Enum
		{
			return (T)Enum.ToObject(typeof(T), @long);
		}
		#endregion
		
		#region Static set-like methods
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static T Union<T>(T flags1, T flags2)
			where T : struct, Enum
		{
			return ToEnum<T>(flags1.ToLong() | flags2.ToLong());
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static T Difference<T>(T initialFlags, T flagsToRemove)
			where T : struct, Enum
		{
			return ToEnum<T>(initialFlags.ToLong() & ~flagsToRemove.ToLong());
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static T Intersection<T>(T flags1, T flags2)
			where T : struct, Enum
		{
			return ToEnum<T>(flags1.ToLong() & flags2.ToLong());
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static T SymmetricDifference<T>(T flags1, T flags2)
			where T : struct, Enum
		{
			return ToEnum<T>(flags1.ToLong() ^ flags2.ToLong());
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static T GetUpdatedFlags<T>(T totalFlags, T flagsToUpdate, bool makePresent)
			where T : struct, Enum
		{
			Func<T, T, T> operation = makePresent ? Union : Difference;
			return operation(totalFlags, flagsToUpdate);
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static bool HasAllFlags<T>(this T totalFlags, T flagsToCheck)
			where T : struct, Enum
		{
			return (totalFlags.ToLong() & flagsToCheck.ToLong()) == flagsToCheck.ToLong();
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Pure]
		public static bool HasAnyFlag<T>(this T totalFlags, T flagsToCheck)
			where T : struct, Enum
		{
			return (totalFlags.ToLong() & flagsToCheck.ToLong()) != 0;
		}
		#endregion
		
		#region Extension methods
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void AddFlags<T>(this ref T totalFlags, T flagsToAdd)
			where T : struct, Enum
		{
			totalFlags = Union(totalFlags, flagsToAdd);
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void RemoveFlags<T>(this ref T totalFlags, T flagsToRemove)
			where T : struct, Enum
		{
			totalFlags = Difference(totalFlags, flagsToRemove);
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LeaveFlagsIntersection<T>(this ref T totalFlags, T flagsToIntersectWith)
			where T : struct, Enum
		{
			totalFlags = Intersection(totalFlags, flagsToIntersectWith);
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ToggleFlags<T>(this ref T totalFlags, T flagsToToggle)
			where T : struct, Enum
		{
			totalFlags = SymmetricDifference(totalFlags, flagsToToggle);
		}
		
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void SetFlags<T>(this ref T totalFlags, T flagsToUpdate, bool isPresent)
			where T : struct, Enum
		{
			totalFlags = GetUpdatedFlags(totalFlags, flagsToUpdate, isPresent);
		}
		#endregion
	}
}