using FNAF_Server.Map;
using GlobalClassLib;
using PacketLib;

namespace FNAF_Server.Enemies;

public class NekoEnemy : Enemy {
    private MovementOpportunity movementOpportunity;
    private NekoPathfinder pathfinder;
    
    public NekoEnemy(int difficulty) : base(difficulty) {
        pathfinder = new NekoPathfinder(this, 1);
        movementOpportunity = new MovementOpportunity(5000);
        SetDifficulty(difficulty);
        
    }
    
    public override string Name{ get; } = "Neko";
    public override int TypeId{ get; } = (int)EnemyType.NEKO;
    public override bool BlocksTile{ get; set; } = true;

    public bool Aggressive = false;
    
    public ServerPlayer? Target{ get; set; }
    
    
    public override void Spawn(MapTile location) {
        base.Spawn(location);
        // stopwatch.Start();
        movementOpportunity.Start();
        pathfinder.takenPath.Add(Location);
        Server.SendUpdateToAll([GameEvent.ENEMY_SPAWN(TypeId, Id, Difficulty, Location.Id)]);
    }

    public override void Reset() {
        pathfinder.takenPath.Clear();
        MapTile[] resetLocations = new[]{MapManager.Get(7), MapManager.Get(12), MapManager.Get(17)}.Where(t => EnemyManager.GetByLocation(t).Length == 0).ToArray();
        Location = resetLocations[new Random().Next(resetLocations.Length)];
        Aggressive = false;
        Server.SendUpdateToAll([GameEvent.ENEMY_RESET(Id, Location.Id)]);
    }

    public override void SetDifficulty(int difficulty) {
        Difficulty = difficulty;
        movementOpportunity.MovementChance =
            ((2 + Math.Pow(1.5f, Difficulty)) * Math.Sign(Difficulty)) / (2 + Math.Pow(1.5f, 10));
    }

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

        if (Location.Owner != null && Location.Lit){
            Aggressive = true;
            Server.SendUpdateToAll([GameEvent.NEKO_ANGERED(Location.Owner.state.pid, Id)]);
        }
        
        if (movementOpportunity.CheckAndRoll() || (Aggressive && GameLogic.NSecondUpdate)){
            if (Target == null){
                if (Server.P1.state.power > Server.P2.state.power){
                    Target = Server.P2;
                }
                else if (Server.P1.state.power < Server.P2.state.power){
                    Target = Server.P1;
                }
                else{
                    return;
                }
            }
            
            Pathfinder.Decision decision = pathfinder.DecideNext(MapManager.Get(Target.state.officeTileId));
            switch (decision.type){
                case Pathfinder.Decision.MoveType:
                    Location = decision.nextTile!;
                    Server.SendUpdateToAll([GameEvent.ENEMY_MOVEMENT(Id, Location.Id)]);
                    Console.WriteLine($"Enemy {TypeId} ({Name}) moving to {Location.PositionAsString})");
                    break;
                case Pathfinder.Decision.AttackType:
                    Attack(decision.attackTarget!);
                    break;
                case Pathfinder.Decision.ResetType:
                    Reset();
                    break;
                case Pathfinder.Decision.WaitType:
                    Aggressive = false;
                    break;
            }
        }
    }

    private class NekoPathfinder : RoamingPathfinder {
        private Random random = new();

        private int tolerance;
        public List<MapTile> takenPath = new();

        public NekoPathfinder(Enemy enemy, int tolerance) : base(enemy) {
            this.tolerance = tolerance;
            AdditionalTileFilter = t => ((NekoEnemy)Enemy).Aggressive || t.Owner == null || !t.Lit;
        }
        
        public override Decision DecideNext(MapTile goal) {
            Dictionary<MapTile, int> distances = Crawl(goal);
            
            List<MapTile> closerTiles = GetNeighbours(Enemy.Location, 
                c => !c.Blocked || c.Type == ConnectorType.DOOR_OFFICE, 
                t => 
                    distances.ContainsKey(t) &&
                    distances[t] <= distances[Enemy.Location] + tolerance);
            if (closerTiles.Contains(goal)){
                if (Enemy.Location.GetConnector(goal)!.Blocked){
                    return Decision.Reset();
                }

                return Decision.Attack(((NekoEnemy)Enemy).Target);
            }
            
            if (closerTiles.Count != 0 && closerTiles.All(t => takenPath.Contains(t))){
                takenPath.Clear();
                return DecideNext(goal);
            }
            closerTiles.RemoveAll(t => takenPath.Contains(t));
            
            closerTiles.ForEach(t => distances[t] += Enemy.Location.GetConnector(t)!.Value);
            double roll = random.NextDouble() * closerTiles.Sum(t => 1.0 / distances[t]);
            foreach (var tile in closerTiles){
                if (roll <= 1.0 / distances[tile]){
                    takenPath.Add(tile);
                    return Decision.Move(tile);
                }
                roll -= 1.0 / distances[tile];
            }

            return Decision.Wait();
        }
    }
}