using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace TyphoonUI
{
    /// <summary>
    /// 布局选择器
    /// </summary>
    [RequireComponent(typeof(RectTransform))]
    public class RectTransformLayoutSelector : MonoBehaviour
    {
        /// <summary>
        /// 布局数据
        /// </summary>
        [Serializable]
        public class LayoutData
        {
            public string Name;
            public Vector3 AnchoredPosition3D;
            public Vector2 SizeDelta;
            public Vector2 AnchorMin;
            public Vector2 AnchorMax;
            public Vector2 Pivot;
            public Vector3 LocalEulerAngles;
            public Vector3 LocalScale;
        }

        //属性类型
        public enum PropertyType
        {
            AnchoredPosition3D = 1,
            SizeDelta = 2,
            AnchorMin = 4,
            AnchorMax = 8,
            Pivot = 16,
            LocalEulerAngles = 32,
            LocalScale = 64,
        }

        public static List<PropertyType> PropertyTypes = new List<PropertyType>()
        {
            PropertyType.AnchoredPosition3D,
            PropertyType.SizeDelta,
            PropertyType.AnchorMin,
            PropertyType.AnchorMax,
            PropertyType.Pivot,
            PropertyType.LocalEulerAngles,
            PropertyType.LocalScale,
        };

        public RectTransform Root;

        [HideInInspector] public int CullingMask = -1;

        //布局集合
        public List<LayoutData> Layouts = new List<LayoutData>();

        protected virtual void Reset()
        {
            Root = transform.GetComponent<RectTransform>();
        }

        /// <summary>
        /// 设置布局
        /// </summary>
        /// <param name="layoutName">布局名</param>
        public void SetLayout(string layoutName)
        {
            var match = Layouts.Where(e => e.Name == layoutName).FirstOrDefault();
            if (match != null)
            {
                SetLayout(match);
                return;
            }

            throw new Exception($"找不到布局：{layoutName}");
        }

        /// <summary>
        /// 设置布局
        /// </summary>
        /// <param name="index">布局索引</param>
        public void SetLayout(int index)
        {
            var layout = Layouts[index];
            SetLayout(layout);
        }

        /// <summary>
        /// 设置布局
        /// </summary>
        /// <param name="data">布局数据</param>
        public void SetLayout(LayoutData data)
        {
            if (IsContain(PropertyType.AnchoredPosition3D))
            {
                Root.anchoredPosition3D = data.AnchoredPosition3D;
            }

            if (IsContain(PropertyType.SizeDelta))
            {
                Root.sizeDelta = data.SizeDelta;
            }

            if (IsContain(PropertyType.AnchorMin))
            {
                Root.anchorMin = data.AnchorMin;
            }

            if (IsContain(PropertyType.AnchorMax))
            {
                Root.anchorMax = data.AnchorMax;
            }

            if (IsContain(PropertyType.Pivot))
            {
                Root.pivot = data.Pivot;
            }

            if (IsContain(PropertyType.LocalEulerAngles))
            {
                Root.localEulerAngles = data.LocalEulerAngles;
            }

            if (IsContain(PropertyType.LocalScale))
            {
                Root.localScale = data.LocalScale;
            }
        }

        //获取层级String
        public string GetCullMaskString()
        {
            if (CullingMask == -1)
            {
                return "Everything";
            }

            var result = string.Empty;
            var match = PropertyTypes.Where(e => (((int)e) & CullingMask) > 0);
            var count = match.Count();
            if (count == 0)
            {
                return "Nothing";
            }

            if (count == 1)
            {
                return match.First().ToString();
            }

            if (count == PropertyTypes.Count)
            {
                return "Everything";
            }

            return "Mixed...";
        }

        public void Nothing()
        {
            CullingMask = 0;
        }

        public void Everything()
        {
            CullingMask = -1;
        }

        public void SetMask(PropertyType type, bool isOn)
        {
            if (isOn)
            {
                CullingMask |= (int)type;
            }
            else
            {
                CullingMask &= (int)type ^ -1;
            }
        }

        public bool IsContain(PropertyType type)
        {
            return (((int)type) & CullingMask) > 0;
        }

        public void AddLayout()
        {
            if (Root == null)
            {
                throw new Exception("缺少 Root");
            }

            var data = new LayoutData()
            {
                Name = "UnKnown",
                AnchoredPosition3D = Root.anchoredPosition3D,
                SizeDelta = Root.sizeDelta,
                AnchorMin = Root.anchorMin,
                AnchorMax = Root.anchorMax,
                Pivot = Root.pivot,
                LocalEulerAngles = Root.localEulerAngles,
                LocalScale = Root.localScale,
            };
            Layouts.Add(data);
        }

        public void UpdateLayout(int index)
        {
            if (index < Layouts.Count)
            {
                var layout = Layouts[index];
                layout.AnchoredPosition3D = Root.anchoredPosition3D;
                layout.SizeDelta = Root.sizeDelta;
                layout.AnchorMin = Root.anchorMin;
                layout.AnchorMax = Root.anchorMax;
                layout.Pivot = Root.pivot;
                layout.LocalEulerAngles = Root.localEulerAngles;
                layout.LocalScale = Root.localScale;
            }
        }


        public void RemoveLayout(int index)
        {
            Layouts.RemoveAt(index);
        }
    }
}