using Godot;
using System;
using System.Collections.Generic;
using System.Linq;

public partial class EnemyController : TurnController
{
    
    public PackedScene _enemyScene = GD.Load<PackedScene>("res://Enemy.tscn");
    public List<Enemy> _enemies = new();
    public PlayerController _playerController;

    public void AddEnemies(int ENEMY_COUNT = 1)
    {
        for (int i = 0; i < ENEMY_COUNT; i++)
        {
            Enemy newEnemy = _enemyScene.Instantiate<Enemy>();
            newEnemy.Death += RemoveEnemy;

            newEnemy._speed = Globals._rng.Next(2,4+1);
            newEnemy.Modulate = new Color(newEnemy._speed == 2 ? "#FF0000" : newEnemy._speed == 3 ? "#00FF00" : "#0000FF");
            newEnemy._enemyController = this;
            List<Vector2I> unoccupied = [.. _playArea._map._bottomRow.Where(c => _enemies.All(e => e._address != c))];
            Vector2I randomCell = unoccupied[Globals._rng.Next(unoccupied.Count)];
            SetEnemy(newEnemy, randomCell);
            _enemies.Add(newEnemy);
            AddChild(newEnemy);
        }
    }
    public void AddEnemies(List<Vector2I> POSITIONS)
    {
        for (int i = 0; i < POSITIONS.Count; i++)
        {
            Enemy newEnemy = _enemyScene.Instantiate<Enemy>();
            newEnemy.Death += RemoveEnemy;

            newEnemy._speed = Globals._rng.Next(2,4+1);
            newEnemy._speed = 3;
            newEnemy.Modulate = new Color(newEnemy._speed == 2 ? "#FF0000" : newEnemy._speed == 3 ? "#00FF00" : "#0000FF");
            newEnemy._enemyController = this;
            
            SetEnemy(newEnemy, POSITIONS[i]);
            _enemies.Add(newEnemy);
            AddChild(newEnemy);
        }
        
    }

    public void Initiate()
    {
        List<Vector2I> positions = [.. _playArea.GetNode<TileMapLayer>("InitialPositions").GetUsedCells()];

        AddEnemies(positions);

        
        // for (int i = 0; i < _playArea._map._cells.Count; i++)
        // {
        //     if (_playArea._map._astar.IsPointSolid(_playArea._map._cells[i]))
        //     {
        //         GD.Print(_playArea._map._cells[i]);
        //     }
        // }
    }

    public void MoveEnemies()
    {
        Tween tween = CreateTween();
        tween.SetParallel();

        for (int i = 0; i < _enemies.Count; i++)
        {
            Enemy enemy = _enemies[i];
            Vector2I goal = new(enemy._address.X, Math.Max(enemy._address.Y - enemy._visibilityRange, _playArea._map._minY));

            while(_playArea._map.IsRowFull(goal.Y))
            {
                goal.Y++;
            }
            int loop = 0;
            while (_playArea._map.GetOccupant(goal) != null)
            {
                goal.X = Math.Clamp(enemy._address.X + ((int)MathF.Floor(loop / 2) + 1) * (loop % 2 == 0 ? 1 : -1), _playArea._map._minX, _playArea._map._maxX);
                loop++;
            }
            
            enemy._path = _playArea._map.GetPath(enemy._address, goal, false, i==0);
            enemy._speedRemaining = enemy._address.Y <= _playArea._map._minY ? 0 : enemy._speed;
        }
        _enemies = [.. _enemies.OrderByDescending(e => e._path.Count).ThenBy(e => e._address.Y).ThenBy(e => Math.Abs(e._address.X))];
        int maxSpeed = _enemies.Max(e => e._speedRemaining);

        List<Enemy> remainingEnemies = [.. _enemies];

        for (int i = 0; i < maxSpeed; i++)
        {
            for (int j = 0; j < remainingEnemies.Count; j++)
            {
                Enemy enemy = remainingEnemies[j];
                if (enemy._speedRemaining <= 0)
                {
                    remainingEnemies.Remove(enemy);
                    continue;
                }
                
                int pathIndex = enemy._speed - enemy._speedRemaining;
                Vector2I cell = enemy._path[pathIndex];
                Enemy obstacle = _playArea._map.GetOccupant(cell);
                if (obstacle != null)
                {
                    int obstacleRemainingMoves = obstacle._speedRemaining;
                    if (obstacleRemainingMoves <= 0)
                    {
                        Vector2I newGoal = new(enemy._address.X, Math.Max(enemy._address.Y - enemy._visibilityRange, _playArea._map._minY));

                        while(_playArea._map.IsRowFull(newGoal.Y))
                        {
                            newGoal.Y++;
                        }
                        int loop = 0;
                        while (_playArea._map.GetOccupant(newGoal) != null)
                        {
                            newGoal.X = Math.Clamp(enemy._address.X + ((int)MathF.Floor(loop / 2) + 1) * (loop % 2 == 0 ? 1 : -1), _playArea._map._minX, _playArea._map._maxX);
                            loop++;
                        }
                        List<Vector2I> newPath = _playArea._map.GetPath(enemy._address, newGoal);
                        
                        enemy._path = newPath;

                        newPath.InsertRange(0, [.. Enumerable.Repeat(newPath[0], pathIndex)]);

                        cell = enemy._path[pathIndex];
                        obstacle = _playArea._map.GetOccupant(cell);
                    }
                }

                if (obstacle == null)
                {
                    _playArea._map.SetCellEnemy(cell, enemy);
                    if (j == 0)
                    {
                        tween.Chain();
                    }
                    else
                    {
                        tween.Parallel();
                    }
                    tween.TweenProperty(enemy, "global_position", _playArea._map.GetCellPositionFromAddress(enemy._address), .2f);

                    if (enemy._address.Y <= _playArea._map._minY)
                    {
                        remainingEnemies.Remove(enemy);
                        continue;
                    }
                    enemy._speedRemaining--;
                }
            }
        }
        
        tween.TweenCallback(Callable.From(() => EmitSignal(SignalName.TurnDone)));
    }

    public void RemoveEnemy(Enemy ENEMY_TO_REMOVE)
    {
        _enemies.Remove(ENEMY_TO_REMOVE);
        _playArea._map.SetCellEnemy(ENEMY_TO_REMOVE._address, null);
        ENEMY_TO_REMOVE.QueueFree();
    }

    public override void StartTurn()
    {
        AddEnemies(1);
        
        MoveEnemies();
        
    }

    public void SetEnemy(Enemy ENEMY, Vector2I CELL)
    {
        _playArea._map.SetCellEnemy(CELL, ENEMY);
        ENEMY.GlobalPosition = _playArea._map.GetCellPositionFromAddress(CELL);
    }
}