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

namespace Gameplay.Level
{
    /// <summary>
    /// 用于检测整块木板和洞口位置关系 （并非木板的孔和洞的位置）
    /// </summary>
    public static class LevelUtils
    {
        /// <summary>
        /// 根据木板的洞决定层级顺序
        /// </summary>
        public static List<int> SortPlankLayer(List<List<int>> holesOfPlanksIndex)
        {
            List<int> elementCounts = holesOfPlanksIndex.Select(innerList => innerList.Count).ToList();
            List<int> sortedIndexes = elementCounts
                .Select((value, index) => new { Value = value, Index = index })
                .OrderByDescending(item => item.Value)
                .Select(item => item.Index)
                .ToList();
            return sortedIndexes;
        }

        public static bool IsCanAddThumbtack(Plank plank, Kong kong)
        {
            return IsNonOverlap(plank.Obj, kong.Obj) || IsOverlapCompletely(plank.Obj, kong.Obj);
        }

        public static bool IsOverlapCompletely(GameObject plank, GameObject hole)
        {
            return !IsIntersect(plank, hole) && JudgeContains(hole.transform.position, plank);
        }

        private static bool IsNonOverlap(GameObject plank, GameObject hole)
        {
            return !IsIntersect(plank, hole) && !JudgeContains(hole.transform.position, plank);
        }

        public static bool IsIntersect(GameObject plank, GameObject hole)
        {
            var isIntersect = false;
            var vertices = GetVertices(plank);
            var radius = GetRadius(hole);

            for (var i = 0; i < vertices.Length; i++)
            {
                var p1 = vertices[i];
                var p2 = vertices[(i + 1) % vertices.Length];

                if (IsLineCircleIntersecting(p1, p2, hole.transform.position, radius))
                {
                    isIntersect = true;
                    break;
                }
            }

            return isIntersect;
        }

        public static List<Collider2D> GetTriggerColliders(GameObject obj, string layerMask)
        {
            List<Collider2D> hitColliders = new List<Collider2D>();
            try
            {
                Collider2D collider = obj.GetComponent<Collider2D>();
                ContactFilter2D contactFilter = new ContactFilter2D();

                contactFilter.useTriggers = true;
                contactFilter.SetLayerMask(LayerMask.GetMask(layerMask));

                Physics2D.OverlapCollider(collider, contactFilter, hitColliders);

                return hitColliders;
            }
            catch (Exception e)
            {
                DebugUtil.LogError("LevelUtils.GetTriggerColliders Fail. Obj: {0}, layerMask: {1}, Error:{2}", obj.name,
                    layerMask, e);
                return hitColliders;
            }
        }

        public static Collider2D GetTriggerColliderOfPlank(GameObject obj, Plank plank)
        {
            var hits = GetTriggerColliders(obj, "HoleOfPlank");
            foreach (var hit in hits)
            {
                if (plank.HolesOfPlank.TryGetValue(hit.name, out var holeOfPlank))
                {
                    return hit;
                }
            }

            return null;
        }

        public static float GetRadius(GameObject obj)
        {
            var bounds = obj.GetComponent<SpriteRenderer>().bounds;
            return bounds.extents.x;
        }

        private static Vector2[] GetVertices(GameObject obj)
        {
            SpriteRenderer spriteRenderer = obj.GetComponent<SpriteRenderer>();
            Sprite sprite = spriteRenderer.sprite;

            Bounds spriteBounds = sprite.bounds;

            Vector2 bottomLeft = new Vector2(spriteBounds.min.x, spriteBounds.min.y);
            Vector2 bottomRight = new Vector2(spriteBounds.max.x, spriteBounds.min.y);
            Vector2 topLeft = new Vector2(spriteBounds.min.x, spriteBounds.max.y);
            Vector2 topRight = new Vector2(spriteBounds.max.x, spriteBounds.max.y);

            //var originalVertices = sprite.vertices; //所有顶点

            var originalVertices = new[] { bottomLeft, bottomRight, topLeft, topRight };
            Vector2 spriteCenter = sprite.bounds.center;

            // 计算每个顶点相对于Sprite中心的角度
            Dictionary<Vector3, float> vertexAngles = new Dictionary<Vector3, float>();
            foreach (Vector3 vertex in originalVertices)
            {
                Vector2 vertexPosition = new Vector2(vertex.x, vertex.y);
                Vector2 direction = vertexPosition - spriteCenter;
                float angle = Mathf.Atan2(direction.y, direction.x);
                vertexAngles.Add(vertex, angle);
            }

            Vector2[] sortedVertices = originalVertices.OrderBy(vertex => vertexAngles[vertex]).ToArray();
            for (var i = 0; i < sortedVertices.Length; i++)
            {
                sortedVertices[i] = obj.transform.TransformPoint(sortedVertices[i]);
            }

            return sortedVertices;
        }


        private static bool IsLineCircleIntersecting(Vector2 lineStart, Vector2 lineEnd, Vector2 circleCenter,
            float circleRadius)
        {
            float distance = 0f;

            if (Math.Abs(lineStart.x - lineEnd.x) < float.Epsilon)
            {
                distance = Mathf.Abs(circleCenter.x - lineStart.x);
            }
            else if (Math.Abs(lineStart.y - lineEnd.y) < float.Epsilon)
            {
                distance = Mathf.Abs(circleCenter.y - lineStart.y);
            }
            else
            {
                float slope = (lineEnd.y - lineStart.y) / (lineEnd.x - lineStart.x);
                float intercept = lineStart.y - slope * lineStart.x;

                distance = Mathf.Abs(slope * circleCenter.x - circleCenter.y + intercept) /
                           Mathf.Sqrt(Mathf.Pow(slope, 2) + 1);
            }

            return !(distance >= circleRadius);
        }


        public static bool JudgeContains(Vector3 point, GameObject Obj)
        {
            RaycastHit2D[] hits = Physics2D.RaycastAll(point, Vector2.zero);
            foreach (var hit in hits)
            {
                if (hit.collider != null && hit.collider.name == Obj.name)
                {
                    return true;
                }
            }

            return false;
        }

        public static List<Vector2Int> ConvertIndexToVector2Ints(List<int> indexList, int columns)
        {
            List<Vector2Int> coordinatesArray = new List<Vector2Int>();

            foreach (int index in indexList)
            {
                int row = index / columns;
                int column = index % columns;

                Vector2Int coordinates = new Vector2Int(row, column);
                coordinatesArray.Add(coordinates);
            }

            return coordinatesArray;
        }

        public static List<int> ConvertVector2IntsToIndex(List<Vector2Int> vectorList, int columns)
        {
            List<int> indexArray = new List<int>();

            foreach (Vector2Int coordinates in vectorList)
            {
                int index = coordinates.x * columns + coordinates.y;
                indexArray.Add(index);
            }

            return indexArray;
        }

        public static Vector2Int ConvertIndexToVector2Int(int index, int columns)
        {
            return new Vector2Int(index / columns, index % columns);
        }

        public static int ConvertVector2IntToIndex(Vector2Int pos, int columns)
        {
            return pos.x * columns + pos.y;
        }

        public static Color GetRgbaColor(string strColor)
        {
            var color = Convert.ToUInt32(strColor, 16);
            return new Color((color >> 24 & 0xFF) / 255f, (color >> 16 & 0xFF) / 255f,
                (color >> 8 & 0xFF) / 255f, (color & 0xFF) / 255f);
        }


        /// <summary>
        /// 根据行数和方向创造hole的位置
        /// </summary>
        public static List<float> GeneratePositions(int count, int direction)
        {
            try
            {
                var positions = new List<float>(count);
                var spacing = 2 * LevelConstants.Radius + LevelConstants.Spacing;
                var pos = 0 -
                          (count % 2 != 0
                              ? count / 2
                              : (LevelConstants.Radius + LevelConstants.Spacing / 2) + (count / 2 - 1)) * spacing;
                if (direction.Equals(-1))
                {
                    pos -= LevelConstants.Offset;
                }

                pos *= direction;
                for (var i = 0; i < count; i++)
                {
                    positions.Add(pos);
                    pos += spacing * direction;
                }

                return positions;
            }
            catch (Exception e)
            {
                DebugUtil.LogError("LevelUtils.GeneratePositions Fail. Error: {0}", e);
                return new List<float>();
            }
        }

        /// <summary>
        ///得到可以开孔的位置 
        /// </summary>
        public static List<Vector3> GetAdditionalAddedHolesPos(Vector3 firstPos, int count)
        {
            var positions = new List<Vector3>(count);
            for (var i = 0; i < count; i++)
            {
                var pos = new Vector3(firstPos.x + i * (LevelConstants.Spacing + LevelConstants.Radius * 2),
                    firstPos.y - LevelConstants.Spacing - LevelConstants.Radius * 2,
                    firstPos.z);
                positions.Add(pos);
            }

            return positions;
        }

        public static string GetPlankName(LevelData.PlankType plankType,
            LevelData.SquareNormType squareNormType)
        {
            if (!squareNormType.Equals(LevelData.SquareNormType.None))
                return plankType + squareNormType.ToString();
            return plankType.ToString();
        }

        #region 横竖方形生成

        private static Vector3 GetSquarePlankPosition(List<int> holeIndex,
            Dictionary<string, Kong> holeDic, LevelData.SquareNormType squareNormType,
            bool isHorizontal = true)
        {
            try
            {
                var limit = JudgeSquareIndexLimit(squareNormType);

                if (limit == holeIndex.Count - 1)
                {
                    var realIndex = holeIndex[limit / 2];
                    var pos = holeDic[$"Kong{realIndex}"].Obj.transform.position;
                    float offsetValue = isHorizontal
                        ? LevelConstants.Radius + LevelConstants.Spacing / 2
                        : -LevelConstants.Radius - LevelConstants.Spacing / 2;
                    float x = limit % 2 != 0 ? pos.x + offsetValue : pos.x;
                    float y = limit % 2 != 0 ? pos.y + offsetValue : pos.y;
                    var center = isHorizontal ? new Vector3(x, pos.y, pos.z) : new Vector3(pos.x, y, pos.z);
                    return center;
                }
                else
                {
                    if (holeIndex.Count % 2 == 0)
                    {
                        var realIndex = holeIndex[(holeIndex.Count - 1) / 2];
                        var offset = (LevelConstants.Radius * 2 + LevelConstants.Spacing) * limit / 2;
                        var pos = holeDic[$"Kong{realIndex}"].Obj.transform.position;
                        var center = isHorizontal
                            ? new Vector3(pos.x + offset, pos.y, pos.z)
                            : new Vector3(pos.x, pos.y - offset, pos.z);
                        return center;
                    }
                    else
                    {
                        var index = (holeIndex.Count - 1) / 2;
                        var realIndex = holeIndex[index];
                        var offset = limit % 2 != 0
                            ? (LevelConstants.Radius + LevelConstants.Spacing) * limit / 2.0f
                            : 0;
                        var pos = holeDic[$"Kong{realIndex}"].Obj.transform.position;
                        var center = isHorizontal
                            ? new Vector3(pos.x + offset, pos.y, pos.z)
                            : new Vector3(pos.x, pos.y - offset, pos.z);
                        return center;
                    }
                }
            }
            catch (Exception e)
            {
                DebugUtil.LogError("LevelUtils.GetSquarePlankPosition Fail. Error: {0}", e);
                return new Vector3();
            }
        }

        #endregion

        #region 多排方形

        private static Vector3 GetMultiSquarePlankPosition(List<int> holeIndex,
            Dictionary<string, Kong> holeDic)
        {
            var firstIndex = holeIndex[0];
            var finalIndex = holeIndex[^1];

            var firstPos = holeDic[$"Kong{firstIndex}"].Obj.transform.position;
            var finalPos = holeDic[$"Kong{finalIndex}"].Obj.transform.position;
            return (firstPos + finalPos) / 2;
        }

        #endregion

        #region 圆形

        private static Vector3 GetCirclePlankPosition(List<int> holeIndex,
            Dictionary<string, Kong> holeDic)
        {
            return holeDic[$"Kong{holeIndex[0]}"].Obj.transform.position;
        }

        #endregion

        #region 倾斜木板

        private static Vector3 GetInclinedSquarePlankPosition(List<int> holeIndex, Dictionary<string, Kong> holeDic)
        {
            //两孔木板 限制为1
            var limit = 1;
            var realIndex = holeIndex[limit / 2];
            var nextIndex = holeIndex[limit / 2 + 1];

            var pos = holeDic[$"Kong{realIndex}"].Obj.transform.position;
            var nextPos = holeDic[$"Kong{nextIndex}"].Obj.transform.position;
            var offsetPos = new Vector3((pos.x - nextPos.x) / 2 + nextPos.x, (pos.y - nextPos.y) / 2 + nextPos.y,
                pos.z);
            return limit % 2 != 0 ? offsetPos : pos;
        }

        #endregion

        #region 直角三角形

        private static Vector3 GetRightTrianglePlankPosition(List<int> holeIndex, Dictionary<string, Kong> holeDic,
            bool isLeft = true)
        {
            var pos = holeDic[$"Kong{holeIndex[0]}"].Obj.transform.position;
            var offsetX = isLeft
                ? pos.x + LevelConstants.Radius + LevelConstants.SpacingOfRightTriangle
                : pos.x - LevelConstants.Radius - LevelConstants.SpacingOfRightTriangle;
            return new Vector3(offsetX, pos.y - LevelConstants.Radius - LevelConstants.SpacingOfRightTriangle, pos.z);
        }

        #endregion

        #region 直角三角形_Down

        private static Vector3 GetRightTrianglePlankPositionDown(List<int> holeIndex, Dictionary<string, Kong> holeDic,
            bool isLeft = true)
        {
            var pos = holeDic[$"Kong{holeIndex[0]}"].Obj.transform.position;
            var offsetX = isLeft
                ? pos.x + LevelConstants.Radius + LevelConstants.SpacingOfRightTriangle
                : pos.x - LevelConstants.Radius - LevelConstants.SpacingOfRightTriangle;
            return new Vector3(offsetX, pos.y + LevelConstants.Radius + LevelConstants.SpacingOfRightTriangle, pos.z);
        }

        #endregion

        #region 倾斜三角

        private static Vector3 GetInclinedTrianglePlankPositionUp(List<int> holeIndex, Dictionary<string, Kong> holeDic,
            bool isUp = true)
        {
            var pos = holeDic[$"Kong{holeIndex[0]}"].Obj.transform.position;

            float offsetValue = Mathf.Sqrt(2) * (LevelConstants.Radius + LevelConstants.SpacingOfTriangle);

            return new Vector3(pos.x, isUp ? pos.y + offsetValue : pos.y - offsetValue, pos.z);
        }

        private static Vector3 GetInclinedTrianglePlankPositionLeft(List<int> holeIndex,
            Dictionary<string, Kong> holeDic,
            bool isLeft = true)
        {
            var pos = holeDic[$"Kong{holeIndex[0]}"].Obj.transform.position;

            float offsetValue = Mathf.Sqrt(2) * (LevelConstants.Radius + LevelConstants.SpacingOfTriangle);

            return new Vector3(isLeft ? pos.x - offsetValue : pos.x + offsetValue, pos.y, pos.z);
        }

        #endregion

        public static Vector3 GetPlankPositionInfo(Dictionary<string, Kong> holeDic, List<int> holeIndex,
            LevelData.PlankType plankType, LevelData.SquareNormType squareNormType)
        {
            switch (plankType)
            {
                case LevelData.PlankType.HorizontalSquare:
                    return GetSquarePlankPosition(holeIndex, holeDic, squareNormType);

                case LevelData.PlankType.VerticalSquare:
                    return GetSquarePlankPosition(holeIndex, holeDic, squareNormType, false);

                case LevelData.PlankType.Circle:
                    return GetCirclePlankPosition(holeIndex, holeDic);

                case LevelData.PlankType.MultiSquare:
                    return GetMultiSquarePlankPosition(holeIndex, holeDic);

                case LevelData.PlankType.InclinedSquareToLeft:
                    return GetInclinedSquarePlankPosition(holeIndex, holeDic);

                case LevelData.PlankType.InclinedSquareToRight:
                    return GetInclinedSquarePlankPosition(holeIndex, holeDic);

                case LevelData.PlankType.RightTriangleToLeft:
                    return GetRightTrianglePlankPosition(holeIndex, holeDic);

                case LevelData.PlankType.RightTriangleToRight:
                    return GetRightTrianglePlankPosition(holeIndex, holeDic, false);

                case LevelData.PlankType.InclinedTriangle:
                    return GetInclinedTrianglePlankPositionUp(holeIndex, holeDic);
                case LevelData.PlankType.InclinedTriangle_180:
                    return GetInclinedTrianglePlankPositionUp(holeIndex, holeDic, false);

                case LevelData.PlankType.InclinedTriangle_90:
                    return GetInclinedTrianglePlankPositionLeft(holeIndex, holeDic);
                case LevelData.PlankType.InclinedTriangle_270:
                    return GetInclinedTrianglePlankPositionLeft(holeIndex, holeDic, false);

                case LevelData.PlankType.RightTriangleToLeft_Down:
                    return GetRightTrianglePlankPositionDown(holeIndex, holeDic);

                case LevelData.PlankType.RightTriangleToRight_Down:
                    return GetRightTrianglePlankPositionDown(holeIndex, holeDic, false);

                default:
                    return Vector3.zero;
            }
        }

        private static int JudgeSquareIndexLimit(LevelData.SquareNormType squareNormType)
        {
            int limitIndex;
            switch (squareNormType)
            {
                case LevelData.SquareNormType.WithTwo:
                    limitIndex = 1;
                    break;
                case LevelData.SquareNormType.WithThree:
                    limitIndex = 2;
                    break;

                case LevelData.SquareNormType.WithFour:
                    limitIndex = 3;
                    break;

                case LevelData.SquareNormType.WithFive:
                    limitIndex = 4;
                    break;
                default:
                    limitIndex = 0;
                    break;
            }

            return limitIndex;
        }
    }
}