using ONDServer.Map;
using PacketLib;

namespace ONDServer.Net;

public static class CommandProcessor {
    private static readonly Dictionary<int, Action<ServerPlayer, PlayerCommand>> commandHandlers = new(){
        [0] = (p, c) => SwitchCamera(p, c.Args[0]),
        [1] = (p, c) => SetMonitorState(p, c.Args[0] == 1),
        [2] = (p, c) => SetDoorStateOffice(p, c.Args[0], c.Args[1] == 1),
        [3] = (p, c) => SetDoorStateRemote(p.State.Pid, (c.Args[0], c.Args[1]), c.Args[2] == 1),
        [4] = (p, c) => SetLightState(p, c.Args[0], c.Args[1] == 1)
    };

    public static void Evaluate(PlayerCommand[] commands, int pid) {
        ServerPlayer currentPlayer = Server.Players[pid];
        
        foreach (var playerCommand in commands){
            commandHandlers[playerCommand.Id](currentPlayer, playerCommand);
            // switch (playerCommand.ID){
            //     case 0:
            //         Console.WriteLine($"C: Player {pid} switched to camera {playerCommand.Args[0]}");
            //         currentPlayer.state.camera = playerCommand.Args[0];
            //         Server.SendUpdateToAll([GameEvent.SWITCH_CAM(pid, playerCommand.Args[0])]);
            //         break;
            //     case 1:
            //         bool monitorState = playerCommand.Args[0] == 1;
            //         currentPlayer.state.monitorUp = monitorState;
            //         Console.WriteLine($"C: Player {pid} toggled camera {(monitorState ? "on" : "off")}");
            //         Server.SendUpdateToAll([GameEvent.TOGGLE_MONITOR(pid, monitorState)]);
            //         break;
            //     case 2:
            //         bool doorState = playerCommand.Args[1] == 1;
            //         currentPlayer.state.doorStates[playerCommand.Args[0]] = doorState;
            //         TileConnector? officeDoor = MapManager.Get(currentPlayer.state.officeTileId).GetConnector(currentPlayer.state.neighbouringTiles[playerCommand.Args[0]]);
            //         officeDoor.Blocked = doorState;
            //         
            //         if (doorState){
            //             GameLogic.PowerConsumers[officeDoor] = (GameLogic.OfficeDoorUsage, pid);
            //         }
            //         else{
            //             GameLogic.PowerConsumers.Remove(officeDoor);
            //         }
            //         
            //         Console.WriteLine($"C: Player {pid} {(doorState ? "closed" : "opened")} door {playerCommand.Args[0]}");
            //         Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_OFFICE(pid,playerCommand.Args[0] ,doorState)]);
            //         break;
            //     case 3:
            //         TileConnector? door = MapManager.Get(playerCommand.Args[0]).GetConnector(playerCommand.Args[1]);
            //         if(door == null) return;
            //         
            //         door.Blocked = playerCommand.Args[2] == 1;
            //         if (door.Blocked){
            //             GameLogic.PowerConsumers[door] = (GameLogic.RemoteDoorUsage, pid);
            //         }
            //         else{
            //             GameLogic.PowerConsumers.Remove(door);
            //         }
            //         
            //         Console.WriteLine($"C: Player {pid} {(door.Blocked ? "closed" : "opened")} door {(playerCommand.Args[0], playerCommand.Args[1])}");
            //         Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_REMOTE(pid, (playerCommand.Args[0], playerCommand.Args[1]), door.Blocked)]);
            //         break;
            //     case 4:
            //         bool lit = playerCommand.Args[1] == 1;
            //         MapTile lightTile = MapManager.Get(playerCommand.Args[0]);
            //         lightTile.Lit = lit;
            //         if (lit){
            //             GameLogic.PowerConsumers[lightTile] = (GameLogic.LightUsage, pid);
            //         }
            //         else{
            //             GameLogic.PowerConsumers.Remove(lightTile);
            //         }
            //         
            //         Server.SendUpdateToAll([GameEvent.TOGGLE_LIGHT(pid, playerCommand.Args[0], lit)]);
            //         break;
            // }
        }
    }
    
    private static void SwitchCamera(ServerPlayer currentPlayer, int cameraId) {
        if (MapManager.TryGet(cameraId) == null || Server.Players.Values.Any(p => p.State.OfficeTileId == cameraId)) return;
        Console.WriteLine($"C: Player {currentPlayer.State.Pid} switched to camera {cameraId}");
        currentPlayer.State.Camera = cameraId;
        Server.SendUpdateToAll([GameEvent.SWITCH_CAM(currentPlayer.State.Pid, cameraId)]);
    }
    private static void SetMonitorState(ServerPlayer currentPlayer, bool monitorState) {
        currentPlayer.State.MonitorUp = monitorState;
        Console.WriteLine($"C: Player {currentPlayer.State.Pid} toggled camera {(monitorState ? "on" : "off")}");
        Server.SendUpdateToAll([GameEvent.TOGGLE_MONITOR(currentPlayer.State.Pid, monitorState)]);
    }

    private static void SetDoorStateOffice(ServerPlayer currentPlayer, int doorId, bool doorState) {
        if (doorId < 0 || currentPlayer.State.DoorStates.Length <= doorId) return;
        currentPlayer.State.DoorStates[doorId] = doorState;
        TileConnector? officeDoor = MapManager.Get(currentPlayer.State.OfficeTileId).GetConnector(currentPlayer.State.NeighbouringTiles[doorId]);
        if (officeDoor == null) return;
        officeDoor.Blocked = doorState;
                    
        if (doorState){
            GameLogic.PowerConsumers[officeDoor] = (GameLogic.OfficeDoorUsage, currentPlayer.State.Pid);
        }
        else{
            GameLogic.PowerConsumers.Remove(officeDoor);
        }
                    
        Console.WriteLine($"C: Player {currentPlayer.State.Pid} {(doorState ? "closed" : "opened")} door {doorId}");
        Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_OFFICE(currentPlayer.State.Pid, doorId ,doorState)]);
    }

    private static void SetDoorStateRemote(int pid, (int tile1, int tile2) doorId, bool state) {
        TileConnector? door = MapManager.Get(doorId.tile1).GetConnector(doorId.tile2);
        if(door == null) return;
                    
        door.Blocked = state;
        if (door.Blocked){
            GameLogic.PowerConsumers[door] = (GameLogic.RemoteDoorUsage, pid);
        }
        else{
            GameLogic.PowerConsumers.Remove(door);
        }
                    
        Console.WriteLine($"C: Player {pid} {(door.Blocked ? "closed" : "opened")} door {doorId}");
        Server.SendUpdateToAll([GameEvent.TOGGLE_DOOR_REMOTE(pid, doorId, door.Blocked)]);
    }

    public static void SetLightState(ServerPlayer currentPlayer, int tileId, bool state) {
        MapTile lightTile = MapManager.Get(tileId);
        lightTile.Lit = state;
        if (state){
            GameLogic.PowerConsumers[lightTile] = (GameLogic.LightUsage, currentPlayer.State.Pid);
        }
        else{
            GameLogic.PowerConsumers.Remove(lightTile);
        }
                    
        Server.SendUpdateToAll([GameEvent.TOGGLE_LIGHT(currentPlayer.State.Pid, tileId, state)]);
    }
    
}