using System;
using AsteroidGame.Entities.Enemies.Scripts;
using UnityEngine;

namespace AsteroidGame.Entities
{
    public class Turret : StructureBase
    {
        [Header("WeaponParameters")] [SerializeField]
        private float _weaponRange = 40f;

        [SerializeField] private int _damage = 1;
        [SerializeField] private float _fireRate = 1;
        [SerializeField] private float _projectileSpeed = 5;
        [SerializeField] private TargetStrategy _targetStrategy = TargetStrategy.LowestHealth;

        [Header("Stats")]
        [SerializeField] private float _kills = 0f;
        [SerializeField] private float _damageDealt = 0f;

        [Header("RigConnections")]
        [SerializeField] private Transform _turretHead;
        [SerializeField] private Transform _barrel;

        [Header("Target")]
        [SerializeField] private SEnemyBaseRuntimeSet _activeEnemies;
        [SerializeField] private EnemyBase _targetEnemy;

        [SerializeField] private enum TargetStrategy
        {
            ClosestEnemy,
            LowestHealth
        };

        #region Publics

        public float MaxDistance { get; set; }

        public int Damage
        {
            get => _damage;
            set => _damage = value;
        }

        public int FireRate { get; set; }

        #endregion

        private void Start()
        {
            // enemyHandler = FindObjectOfType<EnemyHandler>();
            // scoreHandler = FindObjectOfType<ScoreHandler>();
            UpdateWeaponParameters(_fireRate, _projectileSpeed);
        }

        private void Update()
        {
            FindEnemyTarget();
        }

        private void UpdateWeaponParameters(float fireRate, float projectileSpeed)
        {
            // var main = _projectile.main;
            // main.startSpeed = _projectileSpeed;
            //
            // var emission = _projectile.emission;
            // emission.rateOverTime = _fireRate;
        }

        // Update is called once per frame

        private void FindEnemyTarget()
        {
            float currentBestValue = Mathf.Infinity;
            var targetFound = false;

            foreach (EnemyBase enemy in _activeEnemies._list)
            {
                float distanceToTarget = Vector3.Magnitude(enemy.GetCenterPosition() - GetCenterPosition());

                bool withinRange = distanceToTarget < _weaponRange;
                if (withinRange)
                {
                    switch (_targetStrategy)
                    {
                        case TargetStrategy.ClosestEnemy:
                        {
                            bool isClosest = distanceToTarget < currentBestValue;
                            if (isClosest)
                            {
                                targetFound = true;
                                currentBestValue = distanceToTarget;
                                _targetEnemy = enemy;
                            }

                            break;
                        }
                        case TargetStrategy.LowestHealth:
                        {
                            float enemyHealth = enemy.GetHealth();

                            bool isLowestHealth = enemyHealth < currentBestValue;
                            if (isLowestHealth)
                            {
                                targetFound = true;
                                currentBestValue = enemyHealth;
                                _targetEnemy = enemy;
                            }

                            break;
                        }
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
            }

            if (targetFound)
            {
                _turretHead.transform.LookAt(_targetEnemy.GetCenterPosition());
                // ShootProjectile(true);
            }
        }
    }
}