using System;
using System.Collections.Generic;
using System.Linq;
using GlobalClassLib;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using MonoGameLibrary;
using MonoGameLibrary.Graphics;
using MonoGameLibrary.Input;
using ONDClient.Map;

namespace ONDClient.GUI;

public class UIManager {
    
    public static class ScreenTypes {
        public const string OFFICE = "office";
        public const string CAMERAS = "monitor";
        public const string OVERLAY = "overlay";
        public const string WIN = "win";
        public const string LOSE = "lose";
        public const string MENU = "menu";
        public const string LOADING = "loading";
    }
    
    private static Screen officeScreen = new(ScreenTypes.OFFICE);
    private static Screen monitorScreen = new(ScreenTypes.CAMERAS);
    private static Screen overlayScreen = new(ScreenTypes.OVERLAY);
    private static Screen winScreen = new(ScreenTypes.WIN);
    private static Screen loseScreen = new(ScreenTypes.LOSE);
    private static Screen menuScreen = new(ScreenTypes.MENU);
    private static Screen loadingScreen = new(ScreenTypes.LOADING);
    
    private static TextureAtlas testAtlas;
    public static TextureAtlas OfficeAtlas{ get; private set; }
    public static TextureAtlas MonitorAtlas{ get; private set; }
    public static TextureAtlas EnemyAtlas{ get; private set; }
    public static TextureAtlas RoomAtlas{ get; private set; }
    public static SpriteFont PixelMonoFont{ get; private set; }
    
    public static int GlobalPixelMultiplier{ get; private set; }
    
    // private Dictionary<(int, int), UIElement> doorElements = new();
    private static Dictionary<int, UIElement> enemyElements = new();
    private static TimerUIElement timerElement;
    private static UIElement cameraView;
    private static Dictionary<int, UIElement> lightIndicators = new();

    private static InputListenerHook monitorSwitchHook;

    private static bool fullBright = false; // Debug

    public static void LoadAssets() {
        testAtlas = TextureAtlas.FromFile(Core.content, "images/testBlocks-definition.xml");
        OfficeAtlas = TextureAtlas.FromFile(Core.content, "images/office-definition.xml");
        MonitorAtlas = TextureAtlas.FromFile(Core.content, "images/monitor-definition.xml");
        EnemyAtlas = TextureAtlas.FromFile(Core.content, "images/enemies-definition.xml");
        RoomAtlas = TextureAtlas.FromFile(Core.content, "images/rooms-definition.xml");
        PixelMonoFont = Core.content.Load<SpriteFont>("ponderosa");
    }
    
    public static void InitUI() {
        GlobalPixelMultiplier = Core.graphicsDevice.Viewport.Height / 360;
        
        Screen.AddScreens([officeScreen, monitorScreen, overlayScreen, winScreen, loseScreen, menuScreen, loadingScreen]);
        // Screen.SetScreen(ScreenTypes.OFFICE);
        // Screen.SetOverlayScreen(ScreenTypes.OVERLAY);
        
        officeScreen.AddElement("office_left", new UIElement([OfficeAtlas["left-open"], OfficeAtlas["left-closed"]], Point.Zero));
        officeScreen.AddElement("office_centre", new UIElement([OfficeAtlas["centre-open"], OfficeAtlas["centre-closed"]], new Point(200, 0)));
        officeScreen.AddElement("office_right", new UIElement([OfficeAtlas["right-open"], OfficeAtlas["right-closed"]], new Point(440, 0)));
        
        // officeScreen.AddElement("test", 
        //     new UIElement(testAtlas[0], Point.Zero)
        //         {Pressable = true, OnMousePress = () => Console.WriteLine("Pressed!")}
        // );
        
        monitorScreen.AddElement("screen", new UIElement(MonitorAtlas["screen"], Point.Zero));
        monitorScreen.AddElement("view-frame", new UIElement(MonitorAtlas["view-frame"], new Point(62, 55)));
        monitorScreen.AddElement("map-frame", new UIElement(MonitorAtlas["map-frame"], new Point(334, 135)));
        monitorScreen.AddElement("map", new UIElement(MonitorAtlas["map"], new Point(334, 135)));

        List<TextureRegion> rooms = new();
        for (int i = 0; i < ClientMapManager.MAP_SIDE_LENGTH * ClientMapManager.MAP_SIDE_LENGTH; i++){
            rooms.Add(RoomAtlas["room" + i]);
        }
        cameraView = new UIElement(rooms.ToArray(), new(64, 64));
        monitorScreen.AddElement("camera-view", cameraView);
        
        monitorScreen.AddElement("p1-office-door-left", new UIElement([MonitorAtlas["door-office-p1-left-open"], MonitorAtlas["door-office-p1-left-closed"]], new Point(400, 272)));
        monitorScreen.AddElement("p1-office-door-centre", new UIElement([MonitorAtlas["door-office-p1-centre-open"], MonitorAtlas["door-office-p1-centre-closed"]], new Point(400, 272)));
        monitorScreen.AddElement("p1-office-door-right", new UIElement([MonitorAtlas["door-office-p1-right-open"], MonitorAtlas["door-office-p1-right-closed"]], new Point(400, 272)));
        monitorScreen.AddElement("p2-office-door-right", new UIElement([MonitorAtlas["door-office-p2-right-open"], MonitorAtlas["door-office-p2-right-closed"]], new Point(400, 144)));
        monitorScreen.AddElement("p2-office-door-centre", new UIElement([MonitorAtlas["door-office-p2-centre-open"], MonitorAtlas["door-office-p2-centre-closed"]], new Point(400, 144)));
        monitorScreen.AddElement("p2-office-door-left", new UIElement([MonitorAtlas["door-office-p2-left-open"], MonitorAtlas["door-office-p2-left-closed"]], new Point(400, 144)));

        
        // main menu
        timerElement = new(new(0, 0), PixelMonoFont);
        overlayScreen.AddElement("timer", timerElement);
        officeScreen.AddElement("power-p1-office", new PowerIndicator(new(timerElement.Bounds.Item1.X, timerElement.Bounds.Item2.Y + 5), PixelMonoFont, Client.Player, "POWER: "));

        
        TextUIElement powerLabel = (TextUIElement)
            monitorScreen.AddElement("power-label", new TextUIElement(new(510, 150), PixelMonoFont){Text = "POWER:"});
        TextUIElement powerP1 = (TextUIElement)
            monitorScreen.AddElement("power-p2", new PowerIndicator(new(powerLabel.Bounds.Item1.X + 10, powerLabel.Bounds.Item2.Y + 10), PixelMonoFont, Client.Opponent, ""){Color = new Color(220, 10, 10, 255)});
        monitorScreen.AddElement("power-p1", new PowerIndicator( new (powerP1.Bounds.Item1.X, powerP1.Bounds.Item2.Y + 5), PixelMonoFont, Client.Player, ""){Color = new Color(15, 190, 247, 255)});
        
        winScreen.AddElement("win-text", new TextUIElement(new(320, 180), PixelMonoFont, TextUIElement.Alignment.CENTER){Text = "YOU WIN", Color = Color.Green});
        loseScreen.AddElement("lose-text", new TextUIElement(new(320, 180), PixelMonoFont, TextUIElement.Alignment.CENTER){Text = "YOU LOSE", Color = Color.Red});
        
        MenuInputField usernameField = (MenuInputField)menuScreen.AddElement("username-field", new MenuInputField(PixelMonoFont, new(20, 20), "USERNAME: "));
        MenuInputField field = (MenuInputField)menuScreen.AddElement("server-ip-field", new MenuInputField(PixelMonoFont, new(usernameField.Bounds.Item1.X, usernameField.Bounds.Item2.Y + 20), "SERVER IP: ", "127.0.0.1"));
        UIElement connectButton = menuScreen.AddElement("server-ip-submit", new TextUIElement(new Point(field.Bounds.Item1.X, field.Bounds.Item2.Y), PixelMonoFont)
        {
            Text = "CONNECT", 
            Pressable = true, 
            OnMousePress = () => {
                // string[] input = serverIpTextBox.Text.Split(":");
                // if(input.Length != 2 || !int.TryParse(input[0], out var port)) return;
                // Client.Connect(input[0], port);
                Client.Player.username = usernameField.Text;
                Client.Connect(field.Text, 9012);
                Screen.SetScreen(ScreenTypes.LOADING);
            }
        });
        menuScreen.AddElement("host-button",
            new TextUIElement(new(connectButton.Bounds.Item1.X, connectButton.Bounds.Item2.Y + 30), PixelMonoFont) {Text = "HOST", Pressable = true, 
                OnMousePress = () => {
                    Client.StartServer();
                    Client.Player.username = usernameField.Text;
                    Client.Connect("127.0.0.1", 9012);
                    Screen.SetScreen(ScreenTypes.LOADING);

                }});
        
        loadingScreen.AddElement("loading-text", new LoadingUIElement(new(320, 180), PixelMonoFont, field.Text));
        
    }

    public static void DisplayMainMenu() {
        ResetUI();
        Screen.SetScreen(ScreenTypes.MENU);
        CommandManager.AllowGameControls(false);
        // if(Client.Player.username != null)
        //     ((MenuInputField)menuScreen["username-field"]).Text = Client.Player.username;
    }
    
    public static void SpawnMapElements(TileConnectorProjection[] doors) {
        
        
        for (int i = 0; i < 5; i++){ // NOTE: this loop does y in reverse, y labels are inverted to match server
            for (int j = 0; j < 5; j++){
                int id = ClientMapManager.CoordsToId(i, 4 - j);
                if (Client.Player.state.officeTileId == id || Client.Opponent.state.officeTileId == id) continue; // TODO: remove the other check for office
                Point point1 = new Point(336 + (32 * i), 144 + (32 * j));
                Point point2 = new Point(367 + (32 * i), 175 + (32 * j));
                monitorScreen.AddElement(
                    $"room{id}", new UIElement(point1, point2)
                        {Pressable = true, OnMousePress = (() => CommandManager.SendChangeCamera(id))}, 
                    true);
                lightIndicators.Add(id,
                    monitorScreen.AddElement(
                        $"light{id}", new UIElement(MonitorAtlas["map-light-indicator"], point1)
                            {Visible = false}, 
                        true));
                
                //
                // if (doorPositions.ContainsKey((i, j))){
                //     monitorScreen.AddElement("door"+doorPositions[(i, j)], new UIElement([monitorAtlas[5], monitorAtlas[6]], point1));
                // }
            }
        }
        
        monitorScreen.AddElement("eye-player", new UIElement(MonitorAtlas["eye-small-player"], monitorScreen["room"+Client.Player.state.camera].Bounds.Item1), true);
        monitorScreen.AddElement("eye-opponent", new UIElement([MonitorAtlas["eye-small-opponent-closed"], MonitorAtlas["eye-small-opponent-open"]], monitorScreen["room"+Client.Opponent.state.camera].Bounds.Item1), true);

        foreach (var door in doors){
            if(door.Type != ConnectorType.DOOR_REMOTE) continue;
            
            (int x, int y) dpos = (Math.Abs(door.Tiles.tile1.GridPosition.x - door.Tiles.tile2.GridPosition.x), Math.Abs(door.Tiles.tile1.GridPosition.y - door.Tiles.tile2.GridPosition.y));
            
            if (dpos.y == 1){
                int targetId = door.Tiles.tile1.GridPosition.y > door.Tiles.tile2.GridPosition.y ? door.Tiles.tile1.Id : door.Tiles.tile2.Id;
                UIElement tile = monitorScreen["room"+targetId];
                
                monitorScreen.AddElement("door"+Math.Max(door.Tiles.tile1.Id, door.Tiles.tile2.Id)+"-"+Math.Min(door.Tiles.tile1.Id, door.Tiles.tile2.Id), new UIElement([MonitorAtlas["door-remote-open"], MonitorAtlas["door-remote-closed"]], tile.Bounds.Item1), true);
            }
        }
    }
    
    public static void DisplayGameUI() {
        Screen.SetScreen(ScreenTypes.OFFICE);
        Screen.SetOverlayScreen(ScreenTypes.OVERLAY);
        
        CommandManager.AllowGameControls(true);
        UpdateCameras([Client.Player.state.camera]); // in case there is an enemy on the default camera
        cameraView.SetTexture(Client.Player.state.camera);
    }
    public static void StartTimer() {
        timerElement.Start();
    }

    public static void AddEnemySprite(int id, UIElement sprite, UIElement jumpscareSprite = null) {
        monitorScreen.AddElement($"enemy{id}", sprite, true);
        if (jumpscareSprite != null){
            officeScreen.AddElement($"enemy{id}-jumpscare", jumpscareSprite, true);
            jumpscareSprite.Active = false;
            jumpscareSprite.Visible = false;
        }
        enemyElements.Add(id, sprite);
        sprite.Visible = false;
    }
    
    
    public static void ChangeDoorState(Direction dir, bool state) {
        int stateInt = state ? 1 : 0;
        
        switch ((int)dir){
            case 0: 
                officeScreen["office_left"].SetTexture(stateInt);
                monitorScreen["p1-office-door-left"].SetTexture(stateInt);
                break;
            case 1:
                officeScreen["office_centre"].SetTexture(stateInt);
                monitorScreen["p1-office-door-centre"].SetTexture(stateInt);
                break;
            case 2:
                officeScreen["office_right"].SetTexture(stateInt);
                monitorScreen["p1-office-door-right"].SetTexture(stateInt);
                break;
        } 
    }
    
    public static void ChangeDoorStateOpponent(Direction dir, bool state) { // TODO: overload to avoid excessive casting
        int stateInt = state ? 1 : 0;
        
        switch ((int)dir){
            case 0:
                monitorScreen["p2-office-door-left"].SetTexture(stateInt);
                break;
            case 1:
                monitorScreen["p2-office-door-centre"].SetTexture(stateInt);
                break;
            case 2:
                monitorScreen["p2-office-door-right"].SetTexture(stateInt);
                break;
        }
    }

    public static void ChangeRemoteDoorState((int, int) id, bool state) {
        monitorScreen["door"+Math.Max(id.Item1, id.Item2)+"-"+Math.Min(id.Item1, id.Item2)].SetTexture(state ? 1 : 0);
    }

    public static void ChangeMonitorState(bool state) {
        Screen.SetScreen(state ? ScreenTypes.CAMERAS : ScreenTypes.OFFICE);
        UpdateCameras([Client.Player.state.camera]);
    }

    public static void ChangeMonitorStateOpponent(bool state) {
        monitorScreen["eye-opponent"].SetTexture(state ? 1 : 0);
    }

    public static void ChangeCamera(int id) {
        monitorScreen["eye-player"].SetPosition(monitorScreen["room"+id].Bounds.Item1);
        cameraView.SetTexture(id);
        UpdateCameras([id]);
    }
    
    public static void UpdateCameras(int[] camIds) {
        foreach (var id in camIds){
            MapTileProjection tile = ClientMapManager.Get(id);
            if(tile.Owner == null || tile.Id == Client.Player.state.officeTileId || tile.Id == Client.Opponent.state.officeTileId) continue;
            lightIndicators[id].Visible = tile.Lit;
        }
        
        if (camIds.Contains(Client.Player.state.camera)){
            bool lit = ClientMapManager.Get(Client.Player.state.camera).Lit || fullBright;
            cameraView.Visible = lit;
            enemyElements.Values.Where(e => e.Visible).ToList().ForEach(e => e.Visible = false);
            ClientEnemy[] enemies = ClientEnemyManager.GetByLocation(ClientMapManager.Get(Client.Player.state.camera));
            foreach (var enemy in enemies){
                enemyElements.TryGetValue(enemy.Id, out var element);
                if (element == null) continue;
                EnemyUIElement enemyElement = (EnemyUIElement)element;
                enemyElement.Visible = true;
                enemyElement.SetTexture(lit);
            }

            if (!lit && Client.Player.state.monitorUp && enemies.Any(e => e.TypeId == (int)EnemyType.NEKO)){
                SoundManager.StartNekoPurr();
            }
            else{
                SoundManager.StopNekoPurr();
            }
        }
    }
    
    public static void ChangeCameraOpponent(int id) {
        monitorScreen["eye-opponent"].SetPosition(monitorScreen["room"+id].Bounds.Item1);
        
    }

    public static void Jumpscare(ClientEnemy enemy) {
        Screen.SetScreen(ScreenTypes.OFFICE);
        enemy.JumpscareSprite.Play();
        timerElement.Stop();
        CommandManager.AllowGameControls(false);
        // UIElement jumpscareElement = enemy.Sprite.Clone();
        // jumpscareElement.ScaleMultiplier = 2;
        // jumpscareElement.SetPosition(new Point(0, 0));
        // officeScreen.AddElement("jumpscare", jumpscareElement);
    }

    public static void ShowVictoryScreen() {
        Screen.SetScreen(ScreenTypes.WIN);
        Screen.DisableOverlay();
        CommandManager.AllowGameControls(false);
        SoundManager.StopAmbience();
        InputManager.AddListener(Keys.Space, DisplayMainMenu, InputTiming.PRESS, new InputListenerHook(true, true));
    }

    public static void ShowDeathScreen() {
        Screen.SetScreen(ScreenTypes.LOSE);
        Screen.DisableOverlay();
        CommandManager.AllowGameControls(false);
        SoundManager.StopAmbience();
        
        InputManager.AddListener(Keys.Space, DisplayMainMenu, InputTiming.PRESS, new InputListenerHook(true, true));
    }

    public static void ResetUI() {
        foreach (Screen screen in Screen.Screens.Values){
            screen.RemoveTemporary();
        }
        lightIndicators.Clear();
        enemyElements.Clear();
        
        timerElement.Stop();
    }
    
    // private static Point GetRoomUIPos((int x, int y) pos) {
    //     return new Point(336 + (32 * pos.x), 144 + (32 * pos.y));
    // }

}