using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using System.Collections;

namespace Northbound
{
    /// <summary>
    /// 몬스터와 적대 세력의 AI 컨트롤러
    /// </summary>
    [RequireComponent(typeof(NavMeshAgent))]
    [RequireComponent(typeof(EnemyUnit))]
    public class EnemyAIController : NetworkBehaviour
    {
        [Header("AI Type")]
        [Tooltip("Monster: 코어로 이동, Hostile: 제자리에서 대기")]
        public TeamType aiType = TeamType.Monster;

        [Header("Detection")]
        [Tooltip("플레이어 감지 범위")]
        public float detectionRange = 15f;

        [Tooltip("시야 각도 (0-360, 360=전방향)")]
        [Range(0, 360)]
        public float detectionAngle = 120f;

        [Tooltip("탐지할 레이어")]
        public LayerMask playerLayer = ~0;

        [Tooltip("시야 체크 장애물 레이어")]
        public LayerMask obstacleLayer = ~0;

        [Header("Chase Settings")]
        [Tooltip("추적 최대 거리 (이 거리 이상 추적하면 중단)")]
        public float maxChaseDistance = 30f;

        [Tooltip("추적 포기 거리 (플레이어와 이 거리 이상 멀어지면 추적 중단)")]
        public float chaseGiveUpDistance = 25f;

        [Header("Combat")]
        [Tooltip("공격 범위")]
        public float attackRange = 2f;

        [Tooltip("공격 간격 (초)")]
        public float attackInterval = 1.5f;

        [Tooltip("공격 데미지")]
        public int attackDamage = 10;

        [Header("Movement")]
        [Tooltip("이동 속도")]
        public float moveSpeed = 3.5f;

        [Tooltip("추적 중 속도 배율")]
        public float chaseSpeedMultiplier = 1.5f;

        [Header("Debug")]
        [Tooltip("디버그 정보 표시")]
        public bool showDebugInfo = true;

        [Header("Events")]
        public System.Action<GameObject> OnAttackPerformed;

        private NavMeshAgent _agent;
        private EnemyUnit _enemyUnit;
        private Transform _coreTransform;
        private Collider _coreCollider;
        private Vector3 _originPosition;
        private Vector3 _chaseStartPosition;
        private float _lastAttackTime;
        private bool _hasSetCoreDestination;
        private float _lastDetectionLogTime;
        private bool _isRecalculatingPath = false; // NavMesh 갱신 대기 플래그

        private NetworkVariable<EnemyAIState> _currentState = new NetworkVariable<EnemyAIState>(
            EnemyAIState.Idle,
            NetworkVariableReadPermission.Everyone,
            NetworkVariableWritePermission.Server
        );

        private NetworkVariable<ulong> _targetPlayerId = new NetworkVariable<ulong>(
            0,
            NetworkVariableReadPermission.Everyone,
            NetworkVariableWritePermission.Server
        );

        private GameObject _cachedTargetPlayer;

        public override void OnNetworkSpawn()
        {
            base.OnNetworkSpawn();

            _agent = GetComponent<NavMeshAgent>();
            _enemyUnit = GetComponent<EnemyUnit>();
            _originPosition = transform.position;

            if (IsServer)
            {
                // NavMeshAgent 초기 설정
                _agent.speed = moveSpeed;
                _agent.acceleration = 8f;
                _agent.angularSpeed = 120f;
                _agent.stoppingDistance = attackRange * 0.7f;
                 _agent.autoBraking = true;
                 _agent.updateRotation = true;
                 _agent.updateUpAxis = false;
 
                 if (!_agent.isOnNavMesh)
                 {
                 }
 
                 if (aiType == TeamType.Monster)
                {
                    FindCore();
                    TransitionToState(EnemyAIState.MoveToCore);
                }
                else if (aiType == TeamType.Hostile)
                {
                    TransitionToState(EnemyAIState.Idle);
                }

                // 사망 이벤트 구독
                if (_enemyUnit != null)
                {
                    _enemyUnit.OnDeath += HandleDeath;
                }
            }
        }

        public override void OnNetworkDespawn()
        {
            if (_enemyUnit != null)
            {
                _enemyUnit.OnDeath -= HandleDeath;
            }
            base.OnNetworkDespawn();
        }

        private void Update()
        {
            if (!IsServer) return;
            if (!_agent.isOnNavMesh) return;

            switch (_currentState.Value)
            {
                case EnemyAIState.Idle: UpdateIdle(); break;
                case EnemyAIState.MoveToCore: UpdateMoveToCore(); break;
                case EnemyAIState.ChasePlayer: UpdateChasePlayer(); break;
                case EnemyAIState.Attack: UpdateAttack(); break;
                case EnemyAIState.ReturnToOrigin: UpdateReturnToOrigin(); break;
                case EnemyAIState.Dead: break; // 사망 상태에서는 아무것도 하지 않음
            }
        }

        #region State Updates

        private void UpdateIdle()
        {
            GameObject player = DetectTarget();
            if (player != null)
            {
                SetTargetPlayer(player);
                TransitionToState(EnemyAIState.ChasePlayer);
            }
        }

        private void UpdateMoveToCore()
        {
            if (_isRecalculatingPath) return; // 코루틴 대기 중이면 중단
            if (_coreTransform == null) { FindCore(); return; }

            // 0. Player 감지 (코어로 가는 도중에도 Player를 타겟팅)
            GameObject detectedPlayer = DetectTarget();
            if (detectedPlayer != null)
            {
                SetTargetPlayer(detectedPlayer);
                TransitionToState(EnemyAIState.ChasePlayer);
                return;
            }

            // 1. 코어로 가는 경로가 '완전(Complete)'한지 먼저 확인
            // NavMesh가 갱신되었다면 에이전트는 즉시 Complete 상태가 됩니다.
            if (_agent.hasPath && _agent.pathStatus == NavMeshPathStatus.PathComplete)
            {
                if (!_hasSetCoreDestination)
                {
                    _agent.SetDestination(_coreTransform.position);
                    _hasSetCoreDestination = true;
                }
                // [중요] 길이 열렸으므로 아래의 장애물 탐지 로직을 아예 실행하지 않고 리턴!
                return;
            }

            // 2. 코어 도달 확인
            if (GetDistanceToCoreSurface() <= attackRange)
            {
                TransitionToState(EnemyAIState.Attack);
                return;
            }

            // 3. 길이 막혔을 때(Partial)만 아주 좁은 범위에서 장애물을 찾음
            GameObject obstacle = DetectObstacle();
            if (obstacle != null)
            {
                SetTargetPlayer(obstacle);
                TransitionToState(EnemyAIState.Attack);
                return;
            }

            // 4. 경로가 유효하지 않을 때만 재설정
            if (!_agent.hasPath || _agent.pathStatus == NavMeshPathStatus.PathInvalid)
            {
                _agent.SetDestination(_coreTransform.position);
                _hasSetCoreDestination = true;
            }
        }

        private void UpdateChasePlayer()
        {
            GameObject targetPlayer = GetTargetPlayer();
            if (targetPlayer == null) { OnLostTarget(); return; }

            float distanceToPlayer = Vector3.Distance(transform.position, targetPlayer.transform.position);
            Vector3 chaseReferencePoint = (aiType == TeamType.Monster) ? _chaseStartPosition : _originPosition;
            float distanceFromReference = Vector3.Distance(transform.position, chaseReferencePoint);

            if (distanceToPlayer > chaseGiveUpDistance || distanceFromReference > maxChaseDistance)
            {
                OnLostTarget();
                return;
            }

            if (distanceToPlayer <= attackRange)
            {
                TransitionToState(EnemyAIState.Attack);
                return;
            }

            if (_agent.isOnNavMesh && !_agent.isStopped)
            {
                _agent.SetDestination(targetPlayer.transform.position);
            }
        }

        private void UpdateAttack()
        {
            GameObject target = GetTargetPlayer();
            if (target == null)
            {
                if (showDebugInfo) {}
                OnLostTarget();
                return;
            }

            // 핵심: ClosestPoint를 사용해 '벽 표면'까지의 실제 거리 계산
            float distance = GetDistanceToTarget(target);

            // 코어 혹은 일반 타겟 공격 범위 체크 (공격 시 약간의 거리 여유 1.2f 부여)
            if (distance <= attackRange * 1.2f)
            {
                // 타겟 바라보기
                Vector3 direction = (target.transform.position - transform.position).normalized;
                direction.y = 0;
                if (direction != Vector3.zero)
                {
                    transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(direction), Time.deltaTime * 5f);
                }

                // 공격 실행
                if (Time.time - _lastAttackTime >= attackInterval)
                {
                    AttackTarget(target);
                }
            }
            else
            {
                // 거리가 멀어지면 타겟 종류에 따라 상태 전환
                if (target == _coreTransform?.gameObject) TransitionToState(EnemyAIState.MoveToCore);
                else TransitionToState(EnemyAIState.ChasePlayer);
            }
        }

        private void UpdateReturnToOrigin()
        {
            GameObject target = DetectTarget();
            if (target != null)
            {
                SetTargetPlayer(target);
                TransitionToState(EnemyAIState.ChasePlayer);
                return;
            }

            if (!_agent.pathPending && _agent.remainingDistance <= _agent.stoppingDistance)
            {
                if (!_agent.hasPath || _agent.velocity.sqrMagnitude == 0f)
                {
                    TransitionToState(EnemyAIState.Idle);
                }
            }
        }

        #endregion

        #region Detection & Target Management

        private GameObject DetectTarget()
        {
            LayerMask targetMask = playerLayer | obstacleLayer;
            Collider[] colliders = Physics.OverlapSphere(transform.position, detectionRange, targetMask);

            GameObject closestTarget = null;
            float closestDistance = float.MaxValue;

            foreach (Collider col in colliders)
            {
                if (col.transform.root == transform.root) continue;

                IDamageable damageable = col.GetComponentInParent<IDamageable>();
                if (damageable == null) continue;

                ITeamMember teamMember = col.GetComponentInParent<ITeamMember>();
                bool isAttackable = (teamMember != null && teamMember.GetTeam() == TeamType.Player) || (teamMember == null);
                if (!isAttackable) continue;

                float distance = Vector3.Distance(transform.position, col.transform.position);

                if (detectionAngle < 360f)
                {
                    Vector3 directionToTarget = (col.transform.position - transform.position).normalized;
                    if (Vector3.Angle(transform.forward, directionToTarget) > detectionAngle / 2f) continue;
                }

                if (distance < closestDistance)
                {
                    closestDistance = distance;
                    // 부모(Walls)가 아닌 실제 콜라이더가 있는 자식(wall)을 잡음
                    closestTarget = col.gameObject;
                }
            }
            return closestTarget;
        }

        public GameObject DetectObstacle()
        {
            RaycastHit hit;
            Vector3 origin = transform.position + Vector3.up * 1.0f;
            Vector3 direction = transform.forward;
            float castDistance = attackRange * 1.5f;

            if (Physics.SphereCast(origin, 0.5f, direction, out hit, castDistance, obstacleLayer))
            {
                if (hit.collider.GetComponentInParent<IDamageable>() != null)
                {
                    // hit.collider.gameObject를 반환함으로써 자식 오브젝트를 직접 타겟팅함
                    return hit.collider.gameObject;
                }
            }
            return null;
        }

        private void SetTargetPlayer(GameObject target)
        {
            if (target == null) return;
            _cachedTargetPlayer = target;

            var networkObject = target.GetComponentInParent<NetworkObject>();
            if (networkObject != null) _targetPlayerId.Value = networkObject.NetworkObjectId;
            else _targetPlayerId.Value = 0;
        }

        private void ClearTargetPlayer()
        {
            _targetPlayerId.Value = 0;
            _cachedTargetPlayer = null;
        }

        private GameObject GetTargetPlayer()
        {
            // 1순위: 물리적 참조 (장애물/서버 전용)
            if (_cachedTargetPlayer != null && _cachedTargetPlayer.activeInHierarchy) return _cachedTargetPlayer;

            // 2순위: 네트워크 ID 검색
            if (_targetPlayerId.Value != 0)
            {
                if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.TryGetValue(_targetPlayerId.Value, out NetworkObject networkObject))
                {
                    _cachedTargetPlayer = networkObject.gameObject;
                    return _cachedTargetPlayer;
                }
            }

            // 3순위: 코어 확인
            if (_currentState.Value == EnemyAIState.Attack && _coreTransform != null)
            {
                if (GetDistanceToCoreSurface() <= attackRange * 1.5f) return _coreTransform.gameObject;
            }

            return null;
        }

        #endregion

        #region Combat Logic

        private void AttackTarget(GameObject target)
        {
            // 1. 타겟의 자식, 본인, 부모 순으로 샅샅이 뒤져서 IDamageable을 찾습니다.
            IDamageable damageable = target.GetComponentInChildren<IDamageable>();
            if (damageable == null) damageable = target.GetComponent<IDamageable>();
            if (damageable == null) damageable = target.GetComponentInParent<IDamageable>();

            if (damageable != null)
            {
                // 2. 공격 쿨타임 체크
                if (Time.time - _lastAttackTime >= attackInterval)
                {
                    damageable.TakeDamage(attackDamage, NetworkObjectId);
                    _lastAttackTime = Time.time;
                    OnAttackPerformed?.Invoke(target);
                }
            }
            else
            {
                // 공격할 수 없는 대상이면 상태를 해제합니다.
                OnLostTarget();
            }
        }

        #endregion

        #region Utilities & Distance

        private float GetDistanceToTarget(GameObject target)
        {
            if (target == _coreTransform?.gameObject) return GetDistanceToCoreSurface();

            Collider col = target.GetComponent<Collider>();
            if (col != null)
            {
                return Vector3.Distance(transform.position, col.ClosestPoint(transform.position));
            }
            return Vector3.Distance(transform.position, target.transform.position);
        }

        private float GetDistanceToCoreSurface()
        {
            if (_coreTransform == null) return float.MaxValue;
            if (_coreCollider != null)
            {
                Vector3 closestPoint = _coreCollider.ClosestPoint(transform.position);
                return Vector3.Distance(transform.position, closestPoint);
            }
            return Vector3.Distance(transform.position, _coreTransform.position);
        }

        private void TransitionToState(EnemyAIState newState)
        {
            if (_currentState.Value == newState) return;
            OnExitState(_currentState.Value);
            _currentState.Value = newState;
            OnEnterState(newState);
        }

        private void OnEnterState(EnemyAIState state)
        {
            switch (state)
            {
                case EnemyAIState.Idle:
                case EnemyAIState.Attack:
                    _agent.isStopped = true;
                    _agent.ResetPath();
                    break;
                case EnemyAIState.MoveToCore:
                case EnemyAIState.ChasePlayer:
                case EnemyAIState.ReturnToOrigin:
                    _agent.isStopped = false;
                    _agent.speed = (state == EnemyAIState.ChasePlayer) ? moveSpeed * chaseSpeedMultiplier : moveSpeed;
                    if (state == EnemyAIState.ChasePlayer) _chaseStartPosition = transform.position;
                    if (state == EnemyAIState.ReturnToOrigin) _agent.SetDestination(_originPosition);
                    break;
                case EnemyAIState.Dead:
                    _agent.isStopped = true;
                    _agent.ResetPath();
                    _agent.enabled = false; // NavMeshAgent 비활성화
                    break;
            }
        }

        private void OnExitState(EnemyAIState state) { }

        private void HandleDeath(ulong killerId)
        {
            if (!IsServer) return;

            // 사망 상태로 전환
            TransitionToState(EnemyAIState.Dead);
            ClearTargetPlayer();
 
            if (showDebugInfo)
                {}
        }

        private void OnLostTarget()
        {
            ClearTargetPlayer();

            if (IsServer && _agent.isOnNavMesh)
            {
                // 1. 현재 가던 길을 즉시 멈춤
                _agent.ResetPath();
                _hasSetCoreDestination = false;

                // 2. NavMesh가 채워질 시간을 벌기 위한 코루틴 시작
                StartCoroutine(WaitAndRepathRoutine());
            }
        }

        private IEnumerator WaitAndRepathRoutine()
        {
            _isRecalculatingPath = true;

            // NavMesh 바닥이 채워지는 시간을 기다림 (0.15~0.2초 권장)
            yield return new WaitForSeconds(0.2f);

            _isRecalculatingPath = false;

            // 코어로 다시 이동 상태 전환
            TransitionToState(aiType == TeamType.Monster ? EnemyAIState.MoveToCore : EnemyAIState.Idle);
        }

        private void FindCore()
        {
            Core core = FindFirstObjectByType<Core>();
            if (core != null)
            {
                _coreTransform = core.transform;
                _coreCollider = core.GetComponent<Collider>() ?? core.GetComponentInChildren<Collider>();
            }
        }

        #endregion

        #region Public API

        public EnemyAIState GetCurrentState()
        {
            return _currentState.Value;
        }

        #endregion

        #region Gizmos (기존 코드 유지)
        private void OnDrawGizmos()
        {
            if (!showDebugInfo) return;
            Gizmos.color = Color.yellow; Gizmos.DrawWireSphere(transform.position, detectionRange);
            Gizmos.color = Color.red; Gizmos.DrawWireSphere(transform.position, attackRange);

            if (detectionAngle < 360f)
            {
                Vector3 forward = transform.forward * detectionRange;
                Vector3 left = Quaternion.Euler(0, -detectionAngle / 2f, 0) * forward;
                Vector3 right = Quaternion.Euler(0, detectionAngle / 2f, 0) * forward;
                Gizmos.color = Color.blue;
                Gizmos.DrawLine(transform.position, transform.position + left);
                Gizmos.DrawLine(transform.position, transform.position + right);
            }
        }
        #endregion
    }
}