using System.Linq;
using Cirno.Scripts.Components.FSM._3DPlayer;
using Cirno.Scripts.Enums;
using Cirno.Scripts.Misc;
using Cirno.Scripts.Resources;
using Godot;
using Godot.Collections;

namespace Cirno.Scripts;

public partial class GameController : Node
{
    public static GameController Instance { get; private set; }

    private Hud _hud;
    private IsoPlayerFSMProxy _player;
    public IsoPlayerStateMachine Player => _player.PlayerFSM;
    
    [Export] private Marker3D _cameraTarget;
    public Vector3? PlayerPosition => _player?.GlobalPosition ?? null;
    public Vector3? PlayerVelocity => _player?.Velocity ?? null;
    public GameState GameState { get; private set; }

    [Signal]
    public delegate void GameStateChangeEventHandler(GameState state);

    [Signal]
    public delegate void ManagerReadyEventHandler();

    [Export] public StringName PauseActionName { get; private set; } = "pause";

    [Export] public MapResource MapResource { get; private set; }
    
    [Export] public PackedScene PlayerTemplate { get; set; }

    [Export] public Dictionary<int, NodePath> SpawnMarkers { get; private set; } = new();
    
    [Export]
    public int EggStartIndex = 0;
    
    [Export] public Node3D PlayerParentNode { get; set; }
    private InventoryManager _inventoryManager { get; set; }
    
    private Vector3 _lastCheckPointPosition;

    public Vector3 LastCheckPointPosition
    {
        get => _lastCheckPointPosition;
        set => _lastCheckPointPosition = value;
    }

    public override void _Ready()
    {
        Instance = this;
        RenderingServer.SetDefaultClearColor(Colors.Black);
        if (GlobalState.Instance.SessionSettings.GameMode is GameMode.Roguelite)
        {
            if (GlobalState.Instance.SessionSettings.LevelNumber < 0)
            {
                // TODO: Change based on which level we're going to
                GlobalState.Instance.SessionSettings.LevelNumber = 0;
            }
        }
        else
        {
            //GlobalState.Session.LevelNumber = MapResource.LevelId;
        }


        GlobalState.Instance.ChangeCursor(false);

        if (GlobalState.Instance.SessionSettings.AllowSaving)
        {
            GlobalState.Instance.SaveGame();
        }

        //_audioManager = new AudioManager();
        // this.AddChild(_audioManager);

        _hud = GetNodeOrNull<Hud>("HUD");
        if (_hud == null) GD.Print("No HUD in scene.");

        //_cameraTarget = GetNodeOrNull<Node2D>("CameraTarget");
        //if (_cameraTarget == null) GD.Print("No camera target in scene.");

        _inventoryManager = GetNodeOrNull<InventoryManager>("InventoryManager");
        if (_inventoryManager == null) GD.Print("No inventory manager in scene.");
        
        //SpawnBulletsContainer();

        if (_hud != null)
        {
            this.GameStateChange += _hud.OnGameStateChanged;
        }

        if (_inventoryManager != null && _hud != null)
        {
            _inventoryManager.WeaponUpdate += key => _hud.EquipWeapon(key);
        }

        //PlayerRespawned += OnPlayerRespawned;

        GameState = GameState.Playing;


        CallDeferred(MethodName.DelayPlayerSpawn);

        CallDeferred(MethodName.OnFinished);
    }

    private void OnFinished()
    {
        EmitSignalManagerReady();
    }

    public override void _Process(double delta)
    {
        if (GameState is GameState.Paused && Input.IsActionJustPressed(PauseActionName))
        {
            Unpause();
        }
    }

    public void Pause()
    {
        if (GameState == GameState.Playing)
        {
            ChangeState(GameState.Paused);
        }
    }

    public void Unpause()
    {
        if (GameState == GameState.Paused)
        {
            CallDeferred(MethodName.ChangeState, (int)GameState.Playing);
            //ChangeState(GameState.Playing);
        }
    }

    public GameState ToggleControlMode()
    {
        if (GameState is GameState.Playing)
        {
            ChangeState(GameState.Controlling);
        }
        else if (GameState is GameState.Controlling)
        {
            ChangeState(GameState.Playing);
        }

        return GameState;
    }

    public void ChangeState(GameState state)
    {
        if (state == GameState) return;
        GameState = state;
        EmitSignal(SignalName.GameStateChange, (int)state);
        GD.Print($"Game state changed to {state}");

        switch (state)
        {
            case GameState.Paused:
            case GameState.Dialogue:
            case GameState.Shop:
            case GameState.Inventory:
                GlobalState.Instance.ChangeCursor(true);

                GetTree().SetPause(true);
                //Input.MouseMode = Input.MouseModeEnum.Visible;
                break;
            case GameState.Playing:
            case GameState.Controlling:
                //Input.MouseMode = Input.MouseModeEnum.Confined;
                GlobalState.Instance.ChangeCursor(false);
                DelayedUnpause();
                //CallDeferred(MethodName.DelayedUnpause);
                //GetTree().SetPause(false);
                break;
            case GameState.Menu:
                GlobalState.Instance.ChangeCursor(true);
                //Input.MouseMode = Input.MouseModeEnum.Visible;
                DelayedUnpause();
                //CallDeferred(MethodName.DelayedUnpause);
                //GetTree().SetPause(false);
                break;
        }
    }

    private void DelayedUnpause()
    {
        GetTree().SetPause(false);
    }
    
    private void DelayPlayerSpawn()
    {
        if (SpawnMarkers.Any())
        {
            SpawnPlayer();
        }
        else
        {
            GD.Print("No player spawn marker in scene.");
            return;
        }

        if (_player != null && _hud != null)
        {
            // _player.HealthChanged += (newHealth, maxHealth) => _hud.UpdateHealth(newHealth, maxHealth);
            //
            // _player.ShieldChanged += (newShield, maxShield) => _hud.UpdateShield(newShield, maxShield);
            //
            // _player.InteractableAreaEntered += (interactable) => _hud.UpdateInteractable(interactable);
            //
            // _player.Death += () =>
            // {
            //     // Show Game Over
            //     _hud.ShowGameOver();
            // };
        }
        else
        {
            GD.Print("No player and hud in scene");
            return;
        }

        // Wait before the player is fully initialized before spawning weapons on it
        CallDeferred(MethodName.SpawnWeapons);
    }
    
    private void SpawnWeapons()
    {
        foreach (var startingItem in MapResource.StartData.StartingEquipment)
        {
            _inventoryManager.AddItem(startingItem);
        }

        foreach (var item in MapResource.StartData.RemoveEquipment)
        {
            _inventoryManager.RemoveItem(item);
        }
    }
    
    public void SpawnPlayer()
    {
        if (_player != null) return;

        //_player = this.CreateChild<PlayerMovement>(PlayerTemplate, PlayerSpawnMarker.Position );
        _player = PlayerTemplate.Instantiate<IsoPlayerFSMProxy>();
        
        if (PlayerParentNode is not null)
        {
            PlayerParentNode.AddChild(_player);
            _player.Owner = PlayerParentNode;
            _player.Transform = PlayerParentNode.GlobalTransform;
        }
        else
        {
            this.AddChild(_player);
            _player.Owner = this;
        }
        
        _player.GlobalPosition = GetStartPosition();

        LastCheckPointPosition = _player.GlobalPosition;

        //_player.GlobalPosition = PlayerSpawnMarker.Position;

        CameraTargetPlayer();

        //
        // if (_cameraTarget != null)
        // {
        // 	_cameraTarget.Reparent(_player, true);
        // 	_cameraTarget.GlobalPosition = _player.Position;
        // }
    }
    
    public void CameraTargetPlayer()
    {
        if (_player is null) return;
        CameraTargetObject(_player);
    }

    public void CameraTargetObject(Node3D target, Vector3? offset = null)
    {
        if (_cameraTarget is null) return;
        _cameraTarget.Reparent(target, true);
        _cameraTarget.GlobalPosition = target.GlobalPosition;

        if (offset.HasValue)
        {
            _cameraTarget.Position += offset.Value;
        }

    }
    
    private Vector3 GetStartPosition()
    {
        if (MapResource != null)
        {
            if (SpawnMarkers.TryGetValue(EggStartIndex, out var spawnMarker))
            {
                var marker = GetNode<Node3D>(spawnMarker);

                return marker.Position; // Why position and not globalposition? I have no idea
            }
        }

        var m = GetNode<Node3D>(SpawnMarkers.First().Value);
        return m.GlobalPosition;
    }
}