using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 网格合并工具类
/// </summary>
public static class MeshCombineUtils
{
    /// <summary>
    /// 无限制常量，用于表示某个维度无边界限制
    /// </summary>
    public const float UNLIMITED = -1f;

    /// <summary>
    /// 收集渲染器
    /// </summary>
    public static List<Renderer> CollectRenderers(List<Transform> roots)
    {
        List<Renderer> allRenderers = new();
        foreach (var root in roots)
        {
            if (!root)
            {
                continue;
            }

            var render = root.GetComponentsInChildren<Renderer>();
            if (render is not { Length: > 0 })
            {
                continue;
            }

            allRenderers.AddRange(render);
        }

        return allRenderers;
    }

    /// <summary>
    /// 查找第一个未处理的渲染器
    /// </summary>
    private static Renderer FindFirstUnprocessedRenderer(List<Renderer> renderers, HashSet<Renderer> processedRenderers)
    {
        foreach (var renderer in renderers)
        {
            if (!processedRenderers.Contains(renderer))
            {
                return renderer;
            }
        }

        return null;
    }

    /// <summary>
    /// 通过邻近距离扩展组
    /// </summary>
    private static void ExpandGroupByProximity(List<Renderer> allRenderers, List<Renderer> currentGroup,
        HashSet<Renderer> processedRenderers, float maxDistance)
    {
        bool addedNew = true;
        while (addedNew)
        {
            addedNew = false;

            // 查找与当前组中任意一个渲染器距离在阈值内的未处理渲染器
            foreach (var renderer in allRenderers)
            {
                if (processedRenderers.Contains(renderer))
                    continue;

                // 检查是否与组内任何一个渲染器距离小于阈值
                if (IsCloseToAnyInGroup(renderer, currentGroup, maxDistance))
                {
                    currentGroup.Add(renderer);
                    processedRenderers.Add(renderer);
                    addedNew = true;
                }
            }
        }
    }

    /// <summary>
    /// 检查渲染器是否与组内任一渲染器距离小于阈值
    /// </summary>
    private static bool IsCloseToAnyInGroup(Renderer renderer, List<Renderer> group, float maxDistance)
    {
        foreach (var groupRenderer in group)
        {
            float distance = CalculateDistance(renderer, groupRenderer);
            if (distance <= maxDistance)
            {
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 计算两个渲染器之间的距离
    /// </summary>
    private static float CalculateDistance(Renderer renderer1, Renderer renderer2)
    {
        return Vector3.Distance(renderer1.transform.position, renderer2.transform.position);
    }

    /// <summary>
    /// 计算渲染组的中心点
    /// </summary>
    public static Vector3 CalculateGroupCenter(List<Renderer> group)
    {
        if (group.Count == 0)
            return Vector3.zero;

        var sum = Vector3.zero;
        foreach (var renderer in group)
        {
            sum += renderer.transform.position;
        }

        return sum / group.Count;
    }

    /// <summary>
    /// 根据相互距离对渲染器进行分组（优化算法）
    /// 只要物体与组内任意一个物体距离小于 maxDistance，就将其加入该组
    /// 可选择性添加最大宽高限制，防止组范围过大
    /// </summary>
    /// <param name="renderers">要分组的渲染器列表</param>
    /// <param name="maxDistance">相邻物体的最大距离</param>
    /// <param name="maxWidth">组的最大宽度（-1表示宽度无限制）</param>
    /// <param name="maxHeight">组的最大高度（-1表示高度无限制）</param>
    /// <returns>分组结果</returns>
    public static Dictionary<string, List<Renderer>> GroupRenderersByProximity(List<Renderer> renderers,
        float maxDistance, float maxWidth = UNLIMITED, float maxHeight = UNLIMITED)
    {
        var groups = new Dictionary<string, List<Renderer>>();
        var groupIndex = 0;

        // 检查是否有边界限制（只要有一个维度限制就启用边界检查）
        bool hasBoundingLimit = maxWidth > 0 || maxHeight > 0;
        var maxGroupBounds = hasBoundingLimit ? new Vector2(maxWidth, maxHeight) : Vector2.zero;

        // 已分组的渲染器
        var processedRenderers = new HashSet<Renderer>();

        // 对所有渲染器进行处理
        while (processedRenderers.Count < renderers.Count)
        {
            // 找到第一个未处理的渲染器作为新组的起点
            Renderer startRenderer = FindFirstUnprocessedRenderer(renderers, processedRenderers);

            if (startRenderer == null)
                break;

            // 创建新组并添加起点渲染器
            var currentGroup = new List<Renderer> { startRenderer };
            processedRenderers.Add(startRenderer);
            
            // 扩展当前组
            if (hasBoundingLimit)
            {
                ExpandGroupWithBoundingBoxCheck(renderers, currentGroup, processedRenderers, maxDistance,
                    maxGroupBounds);
            }
            else
            {
                ExpandGroupByProximity(renderers, currentGroup, processedRenderers, maxDistance);
            }

            // 添加组到结果
            groups.Add($"Group_{groupIndex}", currentGroup);
            
            // 计算最终组的边界
            var finalBounds = CalculateGroupBounds(currentGroup);
            float finalWidth = finalBounds.max.x - finalBounds.min.x;
            float finalHeight = finalBounds.max.z - finalBounds.min.z;
            
            Debug.Log($"[分组] 组{groupIndex}完成，包含{currentGroup.Count}个物体，最终尺寸:{finalWidth:F2}x{finalHeight:F2}");
            Debug.Log($"[分组] =====================================");
            
            groupIndex++;
        }

        string limitInfo;
        if (!hasBoundingLimit)
        {
            limitInfo = "，无边界限制";
        }
        else
        {
            string widthLimit = maxWidth > 0 ? maxWidth.ToString() : "无限制";
            string heightLimit = maxHeight > 0 ? maxHeight.ToString() : "无限制";
            limitInfo = $"，最大范围为{widthLimit}x{heightLimit}";
        }

        return groups;
    }

    /// <summary>
    /// 计算正六边形地图边界
    /// </summary>
    /// <param name="hexagonCountWidth">水平方向六边形个数</param>
    /// <param name="hexagonCountHeight">垂直方向六边形个数</param>
    /// <param name="hexagonInscribedDiameter">内接圆直径</param>
    /// <param name="pointyTop">是否为尖头向上排列（true=尖头向上, false=平边向上）</param>
    /// <returns>边界范围(x=宽度, y=高度)</returns>
    public static Vector2 CalculateHexagonMapBounds(int hexagonCountWidth, int hexagonCountHeight, float hexagonInscribedDiameter, bool pointyTop = true)
    {
        // 六边形内接圆半径
        float inscribedRadius = hexagonInscribedDiameter / 2f;

        // 六边形边长 = 内接圆半径 / cos(30°) = 内接圆半径 / (√3/2) = 内接圆半径 * 2 / √3
        float hexagonSideLength = inscribedRadius * 2f / Mathf.Sqrt(3f);

        float singleHexWidth, singleHexHeight;
        
        if (pointyTop)
        {
            // 尖头向上排列 ◊（如图所示的排列方式）
            // 单个六边形水平宽度 = √3 * 边长
            singleHexWidth = Mathf.Sqrt(3f) * hexagonSideLength;
            // 垂直方向：蜂窝排列时，行与行之间的间距 = 1.5 * 边长
            singleHexHeight = 1.5f * hexagonSideLength;
        }
        else
        {
            // 平边向上排列
            // 水平方向：蜂窝排列时，列与列之间的间距 = 1.5 * 边长
            singleHexWidth = 1.5f * hexagonSideLength;
            // 单个六边形垂直高度 = √3 * 边长
            singleHexHeight = Mathf.Sqrt(3f) * hexagonSideLength;
        }
        
        // 总的最大范围
        float maxWidth = hexagonCountWidth * singleHexWidth;
        float maxHeight = hexagonCountHeight * singleHexHeight;
        
        return new Vector2(maxWidth, maxHeight);
    }

    /// <summary>
    /// 为当前项目六边形地图计算边界的便利方法
    /// </summary>
    /// <param name="hexagonCountWidth">水平方向六边形个数</param>
    /// <param name="hexagonCountHeight">垂直方向六边形个数</param>
    /// <returns>边界范围</returns>
    public static Vector2 CalculateCurrentHexagonMapBounds(int hexagonCountWidth = 12, int hexagonCountHeight = 9)
    {
        // 使用项目配置：内接圆直径3，尖头向上排列
        return CalculateHexagonMapBounds(hexagonCountWidth, hexagonCountHeight, 3f, true);
    }
    
    /// <summary>
    /// 带边界框检查的组扩展
    /// </summary>
    private static void ExpandGroupWithBoundingBoxCheck(List<Renderer> allRenderers, List<Renderer> currentGroup,
        HashSet<Renderer> processedRenderers, float maxDistance, Vector2 maxGroupBounds)
    {
        bool addedNew = true;
        while (addedNew)
        {
            addedNew = false;

            // 查找与当前组中任意一个渲染器距离在阈值内的未处理渲染器
            foreach (var renderer in allRenderers)
            {
                if (processedRenderers.Contains(renderer))
                    continue;

                // 检查是否与组内任何一个渲染器距离小于阈值
                if (!IsCloseToAnyInGroup(renderer, currentGroup, maxDistance))
                    continue;
                
                // 检查添加该渲染器后组的边界框是否超过最大范围
                if (WouldExceedGroupBounds(renderer, currentGroup, maxGroupBounds))
                    continue;
                
                currentGroup.Add(renderer);
                processedRenderers.Add(renderer);
                addedNew = true;
            }
        }
    }

    /// <summary>
    /// 检查添加新渲染器后是否会超过组的最大边界
    /// </summary>
    private static bool WouldExceedGroupBounds(Renderer newRenderer, List<Renderer> currentGroup,
        Vector2 maxGroupBounds)
    {
        // 计算当前组的边界框
        var bounds = CalculateGroupBounds(currentGroup);

        // 添加新渲染器的位置
        var newPos = newRenderer.transform.position;

        // 计算添加新渲染器后的边界框
        float minX = Mathf.Min(bounds.min.x, newPos.x);
        float maxX = Mathf.Max(bounds.max.x, newPos.x);
        float minZ = Mathf.Min(bounds.min.z, newPos.z);
        float maxZ = Mathf.Max(bounds.max.z, newPos.z);

        // 计算新的宽度和高度（在XZ平面上，因为相机是倾斜的）
        float newWidth = maxX - minX;
        float newHeight = maxZ - minZ;

        // 检查是否超过最大范围（只检查大于0的限制维度）
        bool exceedsWidth = maxGroupBounds.x > 0 && newWidth > maxGroupBounds.x;
        bool exceedsHeight = maxGroupBounds.y > 0 && newHeight > maxGroupBounds.y;

        bool wouldExceed = exceedsWidth || exceedsHeight;

        return wouldExceed;
    }

    /// <summary>
    /// 计算组的边界框
    /// </summary>
    private static Bounds CalculateGroupBounds(List<Renderer> group)
    {
        if (group.Count == 0)
            return new Bounds();

        var firstPos = group[0].transform.position;
        var bounds = new Bounds(firstPos, Vector3.zero);

        foreach (var renderer in group)
        {
            bounds.Encapsulate(renderer.transform.position);
        }

        return bounds;
    }

    /// <summary>
    /// 根据圆形区域对渲染器进行分组（原始算法，保留作参考）
    /// </summary>
    public static Dictionary<string, List<Renderer>> GroupRenderersByCircularDistance(List<Renderer> renderers,
        float maxDistance)
    {
        var groups = new Dictionary<string, List<Renderer>>();
        var groupIndex = 0;

        // 已分组的渲染器
        var processedRenderers = new HashSet<Renderer>();

        // 对所有渲染器进行处理
        while (processedRenderers.Count < renderers.Count)
        {
            // 找到第一个未处理的渲染器作为新组的起点
            Renderer startRenderer = FindFirstUnprocessedRenderer(renderers, processedRenderers);

            if (startRenderer == null)
                break;

            // 创建新组
            var currentGroup = new List<Renderer>();
            currentGroup.Add(startRenderer);
            processedRenderers.Add(startRenderer);

            bool addedNew = true;
            while (addedNew)
            {
                addedNew = false;

                // 计算当前组的中心点
                var groupCenter = CalculateGroupCenter(currentGroup);

                // 查找距离中心点在阈值内的未处理渲染器
                foreach (var renderer in renderers)
                {
                    if (processedRenderers.Contains(renderer))
                        continue;

                    var distance = Vector3.Distance(groupCenter, renderer.transform.position);
                    if (!(distance <= maxDistance)) continue;
                    currentGroup.Add(renderer);
                    processedRenderers.Add(renderer);
                    addedNew = true;
                }
            }

            groups.Add($"Group_{groupIndex}", currentGroup);
            groupIndex++;
        }

        Debug.Log($"基于圆形区域分组：将{renderers.Count}个渲染器分成{groups.Count}个组，半径为{maxDistance}");
        return groups;
    }
}