using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;

#if UNITY_EDITOR
using Unity.VisualScripting.YamlDotNet.Core.Tokens;
#endif

using UnityEngine;


namespace XericLibrary.Runtime.MacroLibrary
{
    /// <summary>
    /// 枚举宏，用于完成枚举项遍历，位操作等
    /// </summary>
    public class MacroEnum<T>
    where T: struct, Enum
	{
        /// <summary>
        /// 反射组值
        /// </summary>
        private Array valueArray;

        /// <summary>
        /// 反射组名称
        /// </summary>
        private string[] nameArray;

        /// <summary>
        /// 构建一个枚举辅助器
        /// </summary>
        public MacroEnum()
        {
			valueArray = typeof(T).GetEnumValues();
			nameArray = typeof(T).GetEnumNames();
		}


        /// <summary>
        /// 获取列表
        /// </summary>
        /// <returns></returns>
        public IEnumerable<T> GetValues() 
        {
            foreach(var type in valueArray)
                yield return (T)type;
        }

        /// <summary>
        /// 获取列表
        /// </summary>
        /// <returns></returns>
        public IEnumerable<string> GetNames() 
        {
            foreach(var type in nameArray)
                yield return type;
        }

        /// <summary>
        /// 获取枚举项目
        /// </summary>
        /// <returns></returns>
        public IEnumerable<(string, T)> GetEnums()
        {
            var output = nameArray
			.Zip(GetValues(), (name, value) => (name, value));
            return output;
		}


		/// <summary>
		/// 设置目标的枚举值
		/// </summary>
		/// <param name="target"></param>
		/// <param name="values"></param>
		public static void SetEnum(ref int target, params T[] values)
        {
            foreach(var value in values)
            {
                target |= Convert.ToInt32(value);
			}
        }

		/// <summary>
		/// 设置目标的枚举值
		/// </summary>
		/// <param name="target"></param>
		/// <param name="values"></param>
		public static void SetEnum(ref int target, T value)
        {
            target |= Convert.ToInt32(value);
        }

        /// <summary>
        /// 复位目标的枚举值
        /// </summary>
        /// <param name="target"></param>
        /// <param name="values"></param>
        public static void ResetEnum(ref int target, params T[] values)
        {
            int temp = 0;
            foreach(var value in values)
            {
				temp |= Convert.ToInt32(value);
			}
            target &= ~temp;
		}

        /// <summary>
        /// 复位目标的枚举值
        /// </summary>
        /// <param name="target"></param>
        /// <param name="values"></param>
        public static void ResetEnum(ref int target, T value)
        {
            target &= ~Convert.ToInt32(value);
		}

        /// <summary>
        /// 翻转目标的枚举值
        /// </summary>
        /// <param name="target"></param>
        /// <param name="values"></param>
        public static void FlipEnum(ref int target, params T[] values)
        {
            int temp = 0;
            foreach(var value in values)
            {
				temp |= Convert.ToInt32(value);
			}
			target ^= temp;
		}

        /// <summary>
        /// 翻转目标的枚举值
        /// </summary>
        /// <param name="target"></param>
        /// <param name="values"></param>
        public static void FlipEnum(ref int target, T value)
        {
			target ^= Convert.ToInt32(value);
		}

		/// <summary>
		/// 检查是否包含给定，且只关注是否完全包含
		/// </summary>
		/// <param name="examineCC">要检查的特征</param>
		/// <param name="filterCC">过滤的特征</param>
		/// <returns></returns>
		public static bool CheckEnum(T examineCC, T filterCC)
		{
            var cc = Convert.ToInt32(filterCC);
			var isValid = Convert.ToInt32(examineCC) & cc;
			var isFull = isValid ^ cc;

			return isValid > 0 && isFull <= 0;
		}
	}


    public static partial class MacroMath
    {
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int EnumToInt32(this Enum target)
		{
			return Convert.ToInt32(target);
		}

		/// <summary>
		/// 枚举仅此有效
		/// </summary>
		/// <param name="target"></param>
		/// <param name="value"></param>
		/// <returns></returns>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EnumJust(this Enum target, Enum value)
		{
			return target.EnumToInt32() == value.EnumToInt32();
		}

		/// <summary>
		/// 枚举至少存在一个有效的枚举项目
		/// </summary>
		/// <returns>返回是否存在至少有一个有效的枚举项目</returns>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EnumGreater(this Enum target)
		{
			return target.EnumToInt32() != 0;
		}

		/// <summary>
		/// 枚举至少存在一个有效的枚举项目
		/// </summary>
		/// <returns>返回是否存在至少有一个有效的枚举项目</returns>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EnumGreater(this Enum target, Enum value)
		{
			return (target.EnumToInt32() & value.EnumToInt32()) != 0;
		}

		/// <summary>
		/// 枚举1有效
		/// </summary>
		/// <returns></returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumGreater1(this Enum target)
		{
			return (target.EnumToInt32() & 01) != 0;
		}

		/// <summary>
		/// 枚举2有效
		/// </summary>
		/// <returns></returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumGreater2(this Enum target)
		{
			return (target.EnumToInt32() & 02) != 0;
		}

		/// <summary>
		/// 枚举3有效
		/// </summary>
		/// <returns></returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumGreater3(this Enum target)
		{
			return (target.EnumToInt32() & 04) != 0;
		}

		/// <summary>
		/// 枚举4有效
		/// </summary>
		/// <returns></returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumGreater4(this Enum target)
		{
			return (target.EnumToInt32() & 010) != 0;
		}

		/// <summary>
		/// 枚举5有效
		/// </summary>
		/// <returns></returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumGreater5(this Enum target)
		{
			return (target.EnumToInt32() & 020) != 0;
		}

		/// <summary>
		/// 枚举6有效
		/// </summary>
		/// <returns></returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumGreater6(this Enum target)
		{
			return (target.EnumToInt32() & 030) != 0;
		}

		/// <summary>
		/// 枚举7有效
		/// </summary>
		/// <returns></returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumGreater7(this Enum target)
		{
			return (target.EnumToInt32() & 040) != 0;
		}

		/// <summary>
		/// 枚举8有效
		/// </summary>
		/// <returns></returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumGreater8(this Enum target)
		{
			return (target.EnumToInt32() & 0100) != 0;
		}

		/// <summary>
		/// 枚举小于0，或者说不存在有效的枚举项目
		/// </summary>
		/// <returns>返回是否不存在有效的枚举项目</returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumLess(this Enum target)
		{
			return target.EnumToInt32() <= 0;
		}

		/// <summary>
		/// 枚举小于0，或者说不存在有效的枚举项目
		/// </summary>
		/// <returns>返回是否不存在有效的枚举项目</returns>
		 [MethodImpl(MethodImplOptions.AggressiveInlining)]
		 public static bool EnumLess(this Enum target, Enum value)
		{
			return (target.EnumToInt32() & value.EnumToInt32()) <= 0;
		}
	}
}