using System.Collections.Generic;
using UnityEngine;

namespace TKS
{
    /// <summary>피해 공식과 전장 기하 질의(경로 위 적·이동 가능 거리·최종 목표점 명중).</summary>
    public static class Combat
    {
        const float CastRadiusScale = 0.9f;
        const float Epsilon = 0.02f;

        // ---------- 피해 공식 ----------

        public static int Damage(BalanceConfig cfg, Unit attacker, Unit defender, bool crit, System.Random rng)
        {
            float mult = cfg.Matchup(attacker.Type, defender.Type);
            float raw = attacker.Atk * mult * (crit ? cfg.critMultiplier : 1f) - defender.Def * cfg.defenseFactor;
            float variance = 1f + ((float)rng.NextDouble() * 2f - 1f) * cfg.damageVariance;
            return Mathf.Max(1, Mathf.RoundToInt(raw * variance));
        }

        public static int CounterDamage(BalanceConfig cfg, Unit defender, Unit attacker, System.Random rng)
        {
            int baseDmg = Damage(cfg, defender, attacker, false, rng);
            return Mathf.Max(1, Mathf.RoundToInt(baseDmg * cfg.counterRatio));
        }

        public static int OverwatchDamage(BalanceConfig cfg, Unit spear, Unit mover, System.Random rng)
        {
            int baseDmg = Damage(cfg, spear, mover, false, rng);
            return Mathf.Max(1, Mathf.RoundToInt(baseDmg * cfg.overwatchDamageRatio));
        }

        // ---------- 기하 질의 ----------

        static RaycastHit2D[] Cast(Unit actor, Vector2 origin, Vector2 dir, float dist)
        {
            Physics2D.SyncTransforms();
            var hits = Physics2D.CircleCastAll(origin, actor.Radius * CastRadiusScale, dir, dist);
            System.Array.Sort(hits, (a, b) => a.distance.CompareTo(b.distance));
            return hits;
        }

        static Unit UnitOf(Collider2D c)
        {
            return c != null ? c.GetComponent<Unit>() : null;
        }

        /// <summary>경로(원 캐스트) 위 가장 가까운 적. hitDist = 그 적에 닿기까지 이동 거리.</summary>
        public static Unit FirstEnemyOnPath(Unit actor, Vector2 origin, Vector2 dir, float dist, out float hitDist)
        {
            hitDist = 0f;
            foreach (var h in Cast(actor, origin, dir, dist))
            {
                var u = UnitOf(h.collider);
                if (u == null || u == actor || !u.IsAlive || u.Faction == actor.Faction) continue;
                hitDist = h.distance;
                return u;
            }
            return null;
        }

        /// <summary>경로 위의 모든 적(가까운 순)과 각 접촉 거리.</summary>
        public static List<Unit> EnemiesOnPath(Unit actor, Vector2 origin, Vector2 dir, float dist, List<float> distances)
        {
            var list = new List<Unit>();
            distances.Clear();
            foreach (var h in Cast(actor, origin, dir, dist))
            {
                var u = UnitOf(h.collider);
                if (u == null || u == actor || !u.IsAlive || u.Faction == actor.Faction) continue;
                if (list.Contains(u)) continue;
                list.Add(u);
                distances.Add(h.distance);
            }
            return list;
        }

        /// <summary>벽·(옵션) 유닛에 막히기 전까지 실제로 나아갈 수 있는 거리.</summary>
        public static float FreeTravel(Unit actor, Vector2 origin, Vector2 dir, float dist, bool enemiesBlock, bool friendsBlock = true)
        {
            float min = dist;
            foreach (var h in Cast(actor, origin, dir, dist))
            {
                if (h.collider.GetComponent<BoardWall>() != null)
                {
                    min = Mathf.Min(min, h.distance);
                    continue;
                }
                var u = UnitOf(h.collider);
                if (u == null || u == actor || !u.IsAlive) continue;
                bool enemy = u.Faction != actor.Faction;
                if (enemy && !enemiesBlock) continue;
                if (!enemy && !friendsBlock) continue;
                min = Mathf.Min(min, h.distance);
            }
            return Mathf.Max(0f, min - Epsilon);
        }

        /// <summary>목표점이 적 원 안(여유 포함)에 들어왔으면 그 적.</summary>
        public static Unit EnemyAtPoint(Unit actor, Vector2 point, float tolerance)
        {
            Physics2D.SyncTransforms();
            Unit best = null;
            float bestD = float.MaxValue;
            foreach (var c in Physics2D.OverlapCircleAll(point, tolerance))
            {
                var u = UnitOf(c);
                if (u == null || u == actor || !u.IsAlive || u.Faction == actor.Faction) continue;
                float d = Vector2.Distance(point, u.Position);
                if (d < bestD)
                {
                    bestD = d;
                    best = u;
                }
            }
            return best;
        }

        /// <summary>점 p 에서 가장 가까운 지정 진영 유닛(터치 여유 extra 포함).</summary>
        public static Unit UnitNear(IEnumerable<Unit> units, Vector2 p, Faction? faction, float extra)
        {
            Unit best = null;
            float bestD = float.MaxValue;
            foreach (var u in units)
            {
                if (!u.IsAlive) continue;
                if (faction.HasValue && u.Faction != faction.Value) continue;
                float d = Vector2.Distance(p, u.Position);
                if (d <= u.Radius + extra && d < bestD)
                {
                    bestD = d;
                    best = u;
                }
            }
            return best;
        }

        /// <summary>선분 ab 와 점 p 의 최단 거리.</summary>
        public static float SegmentPointDistance(Vector2 a, Vector2 b, Vector2 p)
        {
            Vector2 ab = b - a;
            float len2 = ab.sqrMagnitude;
            if (len2 < 1e-6f) return Vector2.Distance(a, p);
            float t = Mathf.Clamp01(Vector2.Dot(p - a, ab) / len2);
            return Vector2.Distance(a + ab * t, p);
        }
    }
}