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

namespace XericUI.BubbleLayout
{
	/// <summary>
	/// 横向 / 竖向线性布局约束插件的共用基类。
	/// 提供布局框管理、元素分组排序、穿插迭代、弹簧吸附/瞬移、Editor Gizmo 框架等复用逻辑。
	/// </summary>
	public abstract class LinearLayoutConstraintBase : BubbleLayoutPluginBase, IBubbleConstraintPlugin
	{
		#region 字段

		[Header("吸附力")]
		[Tooltip("弹簧吸附力倍率，值越大吸附越快")]
		[SerializeField] protected float m_AttractionForce = 50f;

		[Header("排列")]
		[Tooltip("排序模式")]
		[SerializeField] protected LayoutSortMode m_SortMode = LayoutSortMode.HierarchyOrder;

		[Tooltip("元素间距")]
		[SerializeField] protected float m_Spacing = 10f;

		[Header("布局框")]
		[Tooltip("布局框列表（默认拥有一个全区域框）。每个框代表一个独立排列轨道，子项按框穿插排列。")]
		[SerializeField] protected List<LayoutBox> m_LayoutBoxes = new List<LayoutBox>
		{
			new LayoutBox("Default", new Rect(-200, -200, 400, 400)),
		};

		/// <summary>
		/// 元素到布局框的分配表（运行时字典的序列化后备）
		/// </summary>
		[SerializeField] private List<LayoutBoxAssignment> m_SerializedAssignments = new List<LayoutBoxAssignment>();

		[NonSerialized]
		protected Dictionary<string, int> m_BoxAssignments;

		#endregion

		#region 属性

		/// <summary>主轴名称（"X" / "Y"），用于子类在 Gizmo / 日志中标识</summary>
		protected abstract string PrimaryAxisName { get; }

		/// <summary>获取元素沿主轴方向的尺寸</summary>
		protected abstract float GetPrimarySize(BubbleItemData item);

		/// <summary>
		/// 获取元素沿主轴方向的尺寸（用于 Gizmo 预览的 RectTransform 版本）
		/// </summary>
		protected abstract float GetPrimarySizeFromRT(RectTransform rt);

		/// <summary>
		/// 根据主轴/辅轴坐标合成最终 localPosition
		/// </summary>
		protected abstract Vector2 MakeTargetPosition(float primary, float secondary);

		#endregion

		#region 布局框管理

		/// <summary>
		/// 惰性初始化运行时字典
		/// </summary>
		protected void EnsureAssignmentsInitialized()
		{
			if (m_BoxAssignments != null)
				return;

			m_BoxAssignments = new Dictionary<string, int>();
			for (int i = 0; i < m_SerializedAssignments.Count; i++)
			{
				var entry = m_SerializedAssignments[i];
				if (!string.IsNullOrEmpty(entry.ItemKey))
					m_BoxAssignments[entry.ItemKey] = entry.BoxIndex;
			}
		}

		/// <summary>
		/// 确保布局框列表至少有一项
		/// </summary>
		protected void EnsureAtLeastOneBox()
		{
			if (m_LayoutBoxes == null)
				m_LayoutBoxes = new List<LayoutBox>();
			if (m_LayoutBoxes.Count == 0)
				m_LayoutBoxes.Add(new LayoutBox("Default", new Rect(-200, -200, 400, 400)));
		}

		/// <summary>
		/// 将指定 GameObject 分配到指定编号的布局框。
		/// 默认所有子项属于第 0 号框。
		/// </summary>
		/// <param name="boxIndex">布局框索引（从 0 开始），超出范围会被钳制</param>
		/// <param name="target">要分配的子项 GameObject</param>
		public void MarkObject2LayoutBox(int boxIndex, GameObject target)
		{
			if (target == null)
				return;

			EnsureAtLeastOneBox();
			boxIndex = Mathf.Clamp(boxIndex, 0, m_LayoutBoxes.Count - 1);
			EnsureAssignmentsInitialized();

			string key = $"{target.name}_{target.GetInstanceID()}";
			m_BoxAssignments[key] = boxIndex;

			// 同步回序列化列表
			SyncDictionaryToSerialized();
		}

		/// <summary>
		/// 清除指定 GameObject 的布局框分配（恢复默认框 0）
		/// </summary>
		public void ClearBoxAssignment(GameObject target)
		{
			if (target == null)
				return;

			EnsureAssignmentsInitialized();
			string key = $"{target.name}_{target.GetInstanceID()}";
			m_BoxAssignments.Remove(key);
			SyncDictionaryToSerialized();
		}

		/// <summary>
		/// 根据屏幕空间坐标和指定 Pivot，将布局框的 Region 映射到屏幕对应位置。
		/// 适用于 Canvas ScreenSpace-Overlay / Camera 模式。
		/// </summary>
		/// <param name="boxIndex">目标布局框索引</param>
		/// <param name="screenRect">屏幕空间矩形（像素坐标）</param>
		/// <param name="camera">渲染 Canvas 的相机，ScreenSpace-Overlay 时传 null</param>
		public void SetBoxRegionFromScreenSpace(int boxIndex, Rect screenRect, Camera camera = null)
		{
			EnsureAtLeastOneBox();
			if (boxIndex < 0 || boxIndex >= m_LayoutBoxes.Count)
				return;

			var parentRT = transform as RectTransform;
			if (parentRT == null)
				return;

			Vector2 localCenter;
			RectTransformUtility.ScreenPointToLocalPointInRectangle(
				parentRT, screenRect.center, camera, out localCenter);

			Vector2 localSize = screenRect.size / parentRT.lossyScale;

			m_LayoutBoxes[boxIndex].Region = new Rect(
				localCenter.x - localSize.x * 0.5f,
				localCenter.y - localSize.y * 0.5f,
				localSize.x,
				localSize.y);
		}

		/// <summary>
		/// 获取指定 GameObject 当前分配的布局框索引
		/// </summary>
		public int GetBoxIndex(GameObject target)
		{
			if (target == null)
				return 0;

			EnsureAssignmentsInitialized();
			string key = $"{target.name}_{target.GetInstanceID()}";
			return m_BoxAssignments.TryGetValue(key, out int idx) ? idx : 0;
		}

		/// <summary>
		/// 获取所有布局框（只读）
		/// </summary>
		public IReadOnlyList<LayoutBox> GetLayoutBoxes()
		{
			EnsureAtLeastOneBox();
			return m_LayoutBoxes;
		}

		private void SyncDictionaryToSerialized()
		{
			m_SerializedAssignments.Clear();
			if (m_BoxAssignments == null)
				return;

			foreach (var kv in m_BoxAssignments)
			{
				m_SerializedAssignments.Add(new LayoutBoxAssignment
				{
					ItemKey = kv.Key,
					BoxIndex = kv.Value,
				});
			}
		}

		#endregion

		#region IBubbleConstraintPlugin 实现

		public virtual void ProcessConstraint(List<BubbleItemData> items, Vector2 layoutCenter)
		{
			if (items == null || items.Count == 0)
				return;

			EnsureAtLeastOneBox();
			EnsureAssignmentsInitialized();

			// 1. 将元素按布局框分组
			var boxGroups = new List<BubbleItemData>[m_LayoutBoxes.Count];
			for (int b = 0; b < m_LayoutBoxes.Count; b++)
				boxGroups[b] = new List<BubbleItemData>();

			for (int i = 0; i < items.Count; i++)
			{
				var item = items[i];
				int boxIdx = 0;
				if (item.rectTransform != null)
				{
					string key = $"{item.rectTransform.name}_{item.rectTransform.GetInstanceID()}";
					if (m_BoxAssignments.TryGetValue(key, out int assigned))
						boxIdx = Mathf.Clamp(assigned, 0, m_LayoutBoxes.Count - 1);
				}
				boxGroups[boxIdx].Add(item);
			}

			// 2. 各组内部排序
			for (int b = 0; b < boxGroups.Length; b++)
				SortItems(boxGroups[b]);

			// 3. 计算各组总主轴尺寸
			float[] boxTotalPrimarySize = new float[boxGroups.Length];
			float[] boxAdvance = new float[boxGroups.Length];
			for (int b = 0; b < boxGroups.Length; b++)
			{
				float total = 0f;
				for (int i = 0; i < boxGroups[b].Count; i++)
					total += GetPrimarySize(boxGroups[b][i]) + m_Spacing;
				if (boxGroups[b].Count > 0)
					total -= m_Spacing;
				boxTotalPrimarySize[b] = total;
			}

			// 4. 计算各框的起始位置（主轴方向），位于 Region 中心偏前
			for (int b = 0; b < boxGroups.Length; b++)
			{
				var region = m_LayoutBoxes[b].Region;
				float primaryCenter = IsPrimaryHorizontal
					? region.center.x
					: region.center.y;

				boxAdvance[b] = primaryCenter - boxTotalPrimarySize[b] * 0.5f;
			}

			// 5. 穿插迭代：按轨轮询各框
			int[] boxIndices = new int[boxGroups.Length];
			bool anyRemaining = true;
			var targetPositions = new List<(BubbleItemData item, int boxIndex, Vector2 targetPos)>();

			while (anyRemaining)
			{
				anyRemaining = false;
				for (int b = 0; b < boxGroups.Length; b++)
				{
					if (boxIndices[b] >= boxGroups[b].Count)
						continue;

					anyRemaining = true;
					var item = boxGroups[b][boxIndices[b]];
					var box = m_LayoutBoxes[b];

					// 计算辅轴位置（box 区域中心 ± 对齐偏移）
					float secondary = IsPrimaryHorizontal
						? box.Region.center.y + GetSecondaryAlignOffset(item, box)
						: box.Region.center.x + GetSecondaryAlignOffset(item, box);

					Vector2 targetPos = MakeTargetPosition(boxAdvance[b], secondary);

					// 确保目标在 box 区域内
					targetPos = ClampToBox(targetPos, item, box);

					targetPositions.Add((item, b, targetPos));

					// 推进主轴位置
					boxAdvance[b] += GetPrimarySize(item) + m_Spacing;
					boxIndices[b]++;
				}
			}

			// 6. 按计算顺序依次施加力（确保穿插顺序被物理系统感知）
			for (int i = 0; i < targetPositions.Count; i++)
			{
				var (item, boxIndex, targetPos) = targetPositions[i];
				var box = m_LayoutBoxes[boxIndex];

				// 检查是否超出 box 允许范围，超出则瞬移
				if (IsOutOfBox(item.position, item, box))
				{
					item.position = targetPos;
					item.velocity = Vector2.zero;
				}
				else
				{
					Vector2 springForce = (targetPos - item.position) * m_AttractionForce;
					item.force += springForce;
				}
			}
		}

		/// <summary>
		/// 判断主轴是水平还是垂直
		/// </summary>
		protected abstract bool IsPrimaryHorizontal { get; }

		/// <summary>
		/// 子类提供辅轴对齐偏移量（如横排的垂直对齐、竖排的拉链偏移）
		/// </summary>
		/// <returns>偏移量（正值 = 远离区域左上角方向）</returns>
		protected virtual float GetSecondaryAlignOffset(BubbleItemData item, LayoutBox box)
		{
			return 0f;
		}

		/// <summary>
		/// 将目标位置钳制到布局框区域内（考虑元素自身尺寸）
		/// </summary>
		protected Vector2 ClampToBox(Vector2 target, BubbleItemData item, LayoutBox box)
		{
			Rect r = box.Region;
			float halfW = item.size.x * 0.5f;
			float halfH = item.size.y * 0.5f;

			target.x = Mathf.Clamp(target.x, r.xMin + halfW, r.xMax - halfW);
			target.y = Mathf.Clamp(target.y, r.yMin + halfH, r.yMax - halfH);
			return target;
		}

		/// <summary>
		/// 判断位置是否超出布局框（用于瞬移判断）
		/// </summary>
		protected bool IsOutOfBox(Vector2 pos, BubbleItemData item, LayoutBox box)
		{
			Rect r = box.Region;
			float halfW = item.size.x * 0.5f;
			float halfH = item.size.y * 0.5f;

			return pos.x - halfW < r.xMin || pos.x + halfW > r.xMax
				|| pos.y - halfH < r.yMin || pos.y + halfH > r.yMax;
		}

		/// <summary>
		/// 排序元素列表
		/// </summary>
		protected void SortItems(List<BubbleItemData> items)
		{
			if (items.Count <= 1)
				return;

			switch (m_SortMode)
			{
				case LayoutSortMode.HierarchyOrder:
					break;
				case LayoutSortMode.PositionX:
					items.Sort((a, b) => a.position.x.CompareTo(b.position.x));
					break;
				case LayoutSortMode.PositionY:
					items.Sort((a, b) => b.position.y.CompareTo(a.position.y));
					break;
				case LayoutSortMode.Size:
					items.Sort((a, b) => (b.size.x * b.size.y).CompareTo(a.size.x * a.size.y));
					break;
			}
		}

		#endregion

		#region Editor Gizmos

#if UNITY_EDITOR
		/// <summary>
		/// Gizmo 预览数据结构
		/// </summary>
		protected struct GizmoSlot
		{
			public RectTransform rectTransform;
			public Vector2 size;
			public int index;
			public int boxIndex;
		}

		protected virtual void OnDrawGizmosSelected()
		{
			if (!isActiveAndEnabled || transform.childCount == 0)
				return;

			// 收集子元素
			var allSlots = new List<GizmoSlot>();
			for (int i = 0; i < transform.childCount; i++)
			{
				var rt = transform.GetChild(i) as RectTransform;
				if (rt == null || !rt.gameObject.activeInHierarchy)
					continue;
				allSlots.Add(new GizmoSlot { rectTransform = rt, size = rt.rect.size, index = i, boxIndex = 0 });
			}
			if (allSlots.Count == 0) return;

			// 读回分配
			EnsureAssignmentsInitialized();
			for (int i = 0; i < allSlots.Count; i++)
			{
				var slot = allSlots[i];
				string key = $"{slot.rectTransform.name}_{slot.rectTransform.GetInstanceID()}";
				if (m_BoxAssignments.TryGetValue(key, out int bIdx))
				{
					slot.boxIndex = Mathf.Clamp(bIdx, 0, m_LayoutBoxes.Count - 1);
					allSlots[i] = slot;
				}
			}

			// 按当前排序模式排序
			switch (m_SortMode)
			{
				case LayoutSortMode.PositionX:
					allSlots.Sort((a, b) => a.rectTransform.localPosition.x.CompareTo(b.rectTransform.localPosition.x));
					break;
				case LayoutSortMode.PositionY:
					allSlots.Sort((a, b) => b.rectTransform.localPosition.y.CompareTo(a.rectTransform.localPosition.y));
					break;
				case LayoutSortMode.Size:
					allSlots.Sort((a, b) => (b.size.x * b.size.y).CompareTo(a.size.x * a.size.y));
					break;
			}

			var parentRT = (RectTransform)transform;
			Vector2 layoutCenter = new Vector2(
				parentRT.rect.width  * (0.5f - parentRT.pivot.x),
				parentRT.rect.height * (0.5f - parentRT.pivot.y));

			// 1. 绘制所有布局框区域
			DrawBoxRegions();

			// 2. 委托子类绘制元素目标位置
			DrawItemTargets(allSlots, layoutCenter);
		}

		/// <summary>
		/// 绘制所有布局框的矩形区域（白色虚线框）
		/// </summary>
		protected virtual void DrawBoxRegions()
		{
			Color[] boxColors =
			{
				new Color(0.5f, 0.5f, 1f, 0.35f),   // 蓝色调
				new Color(1f, 0.5f, 0.5f, 0.35f),   // 红色调
				new Color(0.5f, 1f, 0.5f, 0.35f),   // 绿色调
				new Color(1f, 1f, 0.5f, 0.35f),     // 黄色调
				new Color(0.5f, 1f, 1f, 0.35f),     // 青色调
				new Color(1f, 0.5f, 1f, 0.35f),     // 紫色调
			};

			for (int b = 0; b < m_LayoutBoxes.Count; b++)
			{
				var box = m_LayoutBoxes[b];
				Color c = boxColors[b % boxColors.Length];

				Rect r = box.Region;
				Vector3 centerWorld = transform.TransformPoint(new Vector3(r.center.x, r.center.y, 0));
				Vector3 sizeWorld = transform.TransformVector(new Vector3(r.width, r.height, 0));

				// 半透明填充
				Gizmos.color = new Color(c.r, c.g, c.b, 0.08f);
				Gizmos.DrawCube(centerWorld, sizeWorld);

				// 虚线边框
				Gizmos.color = c;
				DrawWireRect(centerWorld, sizeWorld);

				// 中心十字
				float crossLen = Mathf.Min(r.width, r.height) * 0.08f;
				Vector3 cxWorld = transform.TransformVector(new Vector3(crossLen, 0, 0));
				Vector3 cyWorld = transform.TransformVector(new Vector3(0, crossLen, 0));
				Gizmos.DrawLine(centerWorld - cxWorld, centerWorld + cxWorld);
				Gizmos.DrawLine(centerWorld - cyWorld, centerWorld + cyWorld);
			}
		}

		/// <summary>
		/// 子类重写：根据已排序的 slots 和 layoutCenter 绘制各元素的目标位置预览
		/// </summary>
		protected abstract void DrawItemTargets(List<GizmoSlot> allSlots, Vector2 layoutCenter);

		/// <summary>
		/// 绘制一个线框矩形
		/// </summary>
		protected static void DrawWireRect(Vector3 center, Vector3 size)
		{
			Vector3 half = size * 0.5f;
			Vector3[] corners = new Vector3[5]
			{
				center + new Vector3(-half.x, -half.y, 0),
				center + new Vector3( half.x, -half.y, 0),
				center + new Vector3( half.x,  half.y, 0),
				center + new Vector3(-half.x,  half.y, 0),
				center + new Vector3(-half.x, -half.y, 0),
			};
			for (int i = 0; i < 4; i++)
				Gizmos.DrawLine(corners[i], corners[i + 1]);
		}

		/// <summary>
		/// 将 localPosition 空间的 Rect 绘制为世界空间线框
		/// </summary>
		protected void DrawLocalRectAsWireCube(Rect localRect, Color wireColor, Color? fillColor = null)
		{
			Vector3 worldCenter = transform.TransformPoint(new Vector3(localRect.center.x, localRect.center.y, 0));
			Vector3 worldSize = transform.TransformVector(new Vector3(localRect.width, localRect.height, 0));

			if (fillColor.HasValue)
			{
				Gizmos.color = fillColor.Value;
				Gizmos.DrawCube(worldCenter, worldSize);
			}

			Gizmos.color = wireColor;
			Gizmos.DrawWireCube(worldCenter, worldSize);
		}
#endif

		#endregion
	}
}