using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using FNAF_Clone.Map;
using GlobalClassLib;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using MonoGameLibrary;
using MonoGameLibrary.Graphics;
using MonoGameLibrary.Input;

namespace FNAF_Clone.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";
    }
    
    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 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 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 InputListenerHook monitorSwitchHook;
    
    public static void InitUI() {
        GlobalPixelMultiplier = Core.graphicsDevice.Viewport.Height / 360;
        
        testAtlas = TextureAtlas.FromFile(Core.content, "images/testBlocks-definition.xml"); // TODO: move this to its own method
        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");
        PixelMonoFont = Core.content.Load<SpriteFont>("ponderosa");
        
        Screen.AddScreens([officeScreen, monitorScreen, overlayScreen, winScreen, loseScreen]);
        Screen.SetScreen(ScreenTypes.OFFICE);
        Screen.SetOverlayScreen(ScreenTypes.OVERLAY);
        
        officeScreen.AddElement("office_left", new UIElement([OfficeAtlas[3], OfficeAtlas[0]], Point.Zero));
        officeScreen.AddElement("office_centre", new UIElement([OfficeAtlas[4], OfficeAtlas[1]], new Point(200, 0)));
        officeScreen.AddElement("office_right", new UIElement([OfficeAtlas[5], OfficeAtlas[2]], 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[0], Point.Zero));
        monitorScreen.AddElement("view-frame", new UIElement(MonitorAtlas[1], new Point(62, 55)));
        monitorScreen.AddElement("map-frame", new UIElement(MonitorAtlas[2], new Point(334, 135)));
        monitorScreen.AddElement("map", new UIElement(MonitorAtlas[3], new Point(334, 135)));

        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 i1 = i;
                int j1 = j;
                Point point1 = new Point(336 + (32 * i), 144 + (32 * j));
                Point point2 = new Point(367 + (32 * i), 175 + (32 * j));
                monitorScreen.AddElement($"room{ClientMapManager.CoordsToId(i, 4 - j)}", new UIElement(point1, point2)
                    {Pressable = true, OnMousePress = (() => CommandManager.SendChangeCamera(ClientMapManager.Get((i1, 4 - j1)).Id))});
                //
                // 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[24], monitorScreen["room"+Client.Player.state.camera].Bounds.Item1));
        monitorScreen.AddElement("eye-opponent", new UIElement([MonitorAtlas[23], MonitorAtlas[22]], monitorScreen["room"+Client.Opponent.state.camera].Bounds.Item1));

        timerElement = new(new(0, 0), PixelMonoFont);
        overlayScreen.AddElement("timer", timerElement);
        timerElement.Start();
        
        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});
        
        UpdateCameras([Client.Player.state.camera]);
    }

    public static void SpawnDoors(TileConnectorProjection[] doors) {
        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[5], MonitorAtlas[6]], tile.Bounds.Item1));
            }
        }
        
        monitorScreen.AddElement("p1-office-door-left", new UIElement([MonitorAtlas[7], MonitorAtlas[8]], new Point(400, 272)));
        monitorScreen.AddElement("p1-office-door-centre", new UIElement([MonitorAtlas[9], MonitorAtlas[10]], new Point(400, 272)));
        monitorScreen.AddElement("p1-office-door-right", new UIElement([MonitorAtlas[11], MonitorAtlas[12]], new Point(400, 272)));
        monitorScreen.AddElement("p2-office-door-right", new UIElement([MonitorAtlas[13], MonitorAtlas[14]], new Point(400, 144)));
        monitorScreen.AddElement("p2-office-door-centre", new UIElement([MonitorAtlas[15], MonitorAtlas[16]], new Point(400, 144)));
        monitorScreen.AddElement("p2-office-door-left", new UIElement([MonitorAtlas[17], MonitorAtlas[18]], new Point(400, 144)));

    }

    public static void AddEnemySprite(int id, UIElement sprite, UIElement jumpscareSprite = null) {
        monitorScreen.AddElement($"enemy{id}", sprite);
        if (jumpscareSprite != null){
            officeScreen.AddElement($"enemy{id}-jumpscare", jumpscareSprite);
            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);
    }

    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);
        UpdateCameras([id]);
    }
    
    public static void UpdateCameras(int[] camIds) {
        if (camIds.Contains(Client.Player.state.camera)){
            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;
                element.Visible = true;
            }
        }
    }
    
    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();
        // 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.AllowInput(false);
    }

    public static void ShowDeathScreen() {
        Screen.SetScreen(ScreenTypes.LOSE);
        Screen.DisableOverlay();
        CommandManager.AllowInput(false);
    }
    
    
    // private static Point GetRoomUIPos((int x, int y) pos) {
    //     return new Point(336 + (32 * pos.x), 144 + (32 * pos.y));
    // }

}