using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.UI;
using Object = UnityEngine.Object;
using System.Globalization;
#if UNITY_EDITOR
using UnityEditor;
#endif

namespace AibisDream.Utility
{
    public static class CommonUtil
    {
        private const float Epsilon = 1e-5f;

        private static Camera _mainCam;

        /// <summary>
        /// 判断为0
        /// </summary>
        /// <param name="value">浮点数</param>
        /// <returns>是否为0</returns>
        public static bool IsZero(float value)
        {
            // 如果value小于epsilon，则认为它等于0
            return Mathf.Abs(value) < Epsilon;
        }

        /// <summary>
        /// 判断浮点数是否相等
        /// </summary>
        /// <param name="value1">value1</param>
        /// <param name="value2">value2</param>
        /// <returns>是否相等</returns>
        public static bool IsEqual(float value1, float value2)
        {
            return Mathf.Abs(value1 - value2) < Epsilon;
        }

        /// <summary>
        /// 简单延时实现
        /// </summary>
        /// <param name="delayTime">延时</param>
        /// <param name="action">函数</param>
        public static async Task Delay(int delayTime, Action action)
        {
            await Task.Delay(delayTime);
            action?.Invoke();
        }

        /// <summary>
        /// 受限数值
        /// </summary>
        /// <param name="target">目标数</param>
        /// <param name="max">上限</param>
        /// <param name="min">下限</param>
        /// <returns>结果</returns>
        public static float Limit(float target, float max, float min)
        {
            if (target <= min)
            {
                return min;
            }

            if (target >= max)
            {
                return max;
            }

            return target;
        }

        public static int Limit(int target, int max, int min)
        {
            if (target <= min)
            {
                return min;
            }

            if (target >= max)
            {
                return max;
            }

            return target;
        }

        /// <summary>
        /// 步进循环
        /// </summary>
        /// <param name="target">操作数</param>
        /// <param name="min">最小值</param>
        /// <param name="max">最大值</param>
        /// <param name="step">步进</param>
        /// <returns></returns>
        /// <exception cref="ArgumentException">范围错误</exception>
        public static int LoopStep(int target, int min, int max, int step = 1)
        {
            if (min > max)
            {
                throw new ArgumentException("min should be less than or equal to max.");
            }

            var range = max - min + 1;

            // 计算新的目标值
            var newTarget = target + step;

            // 计算结果在范围内的值
            if (newTarget > max)
            {
                newTarget = min + (newTarget - max - 1) % range;
            }
            else if (newTarget < min)
            {
                newTarget = max - (min - newTarget - 1) % range;
            }

            return newTarget;
        }

        /// <summary>
        /// 属性复制
        /// </summary>
        /// <param name="source">属性源</param>
        /// <param name="target">属性目标</param>
        public static void CopyFields(object source, object target)
        {
            var sourceFields = source.GetType().GetFields();
            var targetFields = target.GetType().GetFields();

            foreach (var sourceField in sourceFields)
            {
                if (sourceField.IsStatic) return;

                var targetField = targetFields.FirstOrDefault(p =>
                    p.Name == sourceField.Name && p.FieldType == sourceField.FieldType);
                if (targetField != null && !targetField.IsStatic())
                {
                    targetField.SetValue(target, sourceField.GetValue(source));
                }
            }
        }

        /// <summary>
        /// 角度转换
        /// </summary>
        /// <param name="angle">180度角</param>
        /// <returns>360度角</returns>
        public static float Angle360(float angle)
        {
            return angle < 0 ? angle + 360 : angle;
        }

        #region 链式扩展

        public static T As<T>(this object selfObj) where T : class
        {
            return selfObj as T;
        }

        public static T Self<T>(this T self, Action<T> onDo)
        {
            onDo?.Invoke(self);
            return self;
        }

        public static T Self<T>(this T self, Func<T, T> onDo)
        {
            return onDo.Invoke(self);
        }

        #endregion

        #region 静态扩展

        public static void SetAlpha(this SpriteRenderer renderer, float targetAlpha)
        {
            Color color = renderer.color;
            color.a = targetAlpha;
            renderer.color = color;
        }

        public static void SetAlpha(this Image image, float targetAlpha)
        {
            Color color = image.color;
            color.a = targetAlpha;
            image.color = color;
        }

        public static void DestroyAllChildren(this Transform self)
        {
            if (self == null)
            {
                return;
            }
            
            List<Transform> children = new List<Transform>();
            foreach (Transform child in self)
            {
                children.Add(child);
            }

            foreach (var child in children)
            {
#if UNITY_EDITOR
                if (!EditorApplication.isPlaying)
                {
                    Object.DestroyImmediate(child.gameObject);
                    continue;
                }
#endif
                Object.Destroy(child.gameObject);
            }
        }

        #endregion

        ///<summary>
        /// 去除原始对话中名称部分
        /// </summary>
        /// <param name="lineText">对话原文</param>
        /// <returns>去除名称后结果</returns>
        public static string RemoveName(string lineText)
        {
            var textArr = lineText.Split(":");
            return textArr.Length > 1 ? textArr[1].Trim() : lineText;
        }

        public static Vector2 GetPivotByType(PivotType pivotType)
        {
            return pivotType switch
            {
                PivotType.Top => new Vector2(0.5f, 1),
                PivotType.Bottom => new Vector2(0.5f, 0),
                PivotType.Left => new Vector2(0, 0.5f),
                PivotType.Right => new Vector2(1, 0.5f),
                PivotType.TopLeft => new Vector2(0, 1),
                PivotType.TopRight => new Vector2(1, 1),
                PivotType.BottomLeft => new Vector2(0, 0),
                PivotType.BottomRight => new Vector2(1, 0),
                PivotType.Center => new Vector2(0.5f, 0.5f),
                _ => Vector2.zero
            };
        }

        public static string Escape(string rawText)
        {
            return rawText.Replace("^", "#").Replace("[[", "{").Replace("]]", "}");
        }
        
        public static List<Type> FindTypesWithAttribute<TAttribute>()
            where TAttribute : Attribute
        {
            return Assembly.GetExecutingAssembly()
                .GetTypes()
                .Where(t => t.GetCustomAttributes(typeof(TAttribute), false).Length > 0)
                .ToList();
        }

        public static string RemoveRichTextTags(this string str)
        {
            return Regex.Replace(str.Replace("<br>", "\n"), "[<|{].*?[>|}]", string.Empty);
        }

        public static int[,] DeserializeIntArray(string str)
        {
            if (string.IsNullOrWhiteSpace(str))
            {
                return new int[0, 0];
            }

            var array = str.Trim().Split(';');
            var result = new int[array.Length, array[0].Split(',').Length];
            for (int i = 0; i < array.Length; i++)
            {
                var row = array[i].Split(',');
                for (int j = 0; j < row.Length; j++)
                {
                    result[i, j] = int.Parse(row[j], NumberStyles.Integer, CultureInfo.InvariantCulture);
                }
            }
            return result;
        }

        public static string SerializeIntArray(int[,] array)
        {
            var result = new StringBuilder();
            for (int i = 0; i < array.GetLength(0); i++)
            {
                for (int j = 0; j < array.GetLength(1); j++)
                {
                    result.Append(array[i, j]);
                    if (j < array.GetLength(1) - 1)
                    {
                        result.Append(',');
                    }
                }

                if (i < array.GetLength(0) - 1)
                {
                    result.Append(';');
                }
            }
            return result.ToString();
        }
    }
}