using Godot;
using System;
using System.Linq;
using System.Threading.Tasks;
using Cirno.Scripts;
using Cirno.Scripts.Resources;
using Godot.Collections;

public partial class GameManager : Node2D
{
	private Hud _hud;

	private PlayerMovement _player;
	
	public GameState GameState { get; private set; }
	
	public PlayerMovement Player => _player;

	private Node2D _cameraTarget;

	public Vector2? PlayerPosition => _player?.GlobalPosition ?? null;

	[Export]
	public PackedScene PlayerTemplate { get; set; }
	
	[Export]
	public Marker2D PlayerSpawnMarker { get; set; }
	
	[Export] public PackedScene WeaponTemplate { get; private set; }

	[Export] public Array<LootItem> StartingEquipment { get; private set; }
	
	private InventoryManager _inventoryManager { get; set; }
	
	//private AlarmManager _alarmManager { get; set; }

	//public InventoryManager Inventory => _inventoryManager;
	
	//public AlarmManager AlarmManager => _alarmManager;

	private Node2D _bulletsContainer;
	public Node2D BulletsContainer => _bulletsContainer;

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

	// Called when the node enters the scene tree for the first time.
	public override void _Ready()
	{
		_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.");
		
		//_alarmManager = GetNode<AlarmManager>("AlarmManager");
		
		SpawnBulletsContainer();
		
		if (_inventoryManager != null && _hud != null)
		{
			_inventoryManager.ItemAdded += (item, currentAmount) => _hud.AddInventoryItem(item, currentAmount);
			_inventoryManager.ItemRemoved += (item, currentAmount) => _hud.RemoveInventoryItem(item, currentAmount);
		}
		
		GameState = GameState.Playing;

		_ = DelayPlayerSpawn();
	}

	// Called every frame. 'delta' is the elapsed time since the previous frame.
	public override void _Process(double delta)
	{
		if (Input.IsActionJustPressed("pause"))
		{
			TogglePause();
		}
	}

	private async Task DelayPlayerSpawn()
	{
		await Task.Delay(500);
		
		if (PlayerSpawnMarker != null)
		{
			SpawnPlayer();
			
			SpawnWeapons();
		}
		
		if (_player != null && _hud != null)
		{
			_player.HealthChanged += (newHealth, maxHealth) => _hud.UpdateHealth(newHealth, maxHealth);

			_player.InteractableAreaEntered += (interactable) => _hud.UpdateInteractable(interactable);
		}
	}

	public void SpawnPlayer()
	{
		if (_player != null) return;
		//_player = this.CreateChild<PlayerMovement>(PlayerTemplate, PlayerSpawnMarker.Position );
		_player = PlayerTemplate.Instantiate<PlayerMovement>();
			
		this.CallDeferred("add_child", _player);
		_player.Transform = this.GlobalTransform;
			
		_player.GlobalPosition = PlayerSpawnMarker.Position;

		if (_cameraTarget != null)
		{
			_cameraTarget.Reparent(_player, true);
			_cameraTarget.GlobalPosition = _player.Position;
		}
	}
	
	private void SpawnWeapons()
	{
		if (!StartingEquipment.Any())
		{
			GD.Print("No items to spawn on Player");
			return;
		}
		
		foreach (var startingItem in StartingEquipment)
		{
			switch (startingItem.Item)
			{
				case ItemTypes.Weapon:
					if (WeaponTemplate == null)
					{
						GD.Print("Could not spawn weapon because template is null");
						break;
					}
					var weapon = _player.CreateChild<Weapon>(WeaponTemplate);
					weapon.WeaponData = startingItem.WeaponData;

					_player.AddWeapon(weapon);
					
					if (_player.EquippedWeapon == null)
					{
						_player.EquipWeapon(weapon);
					}
					
					//_player.EquippedWeapon ??= weapon;
					break;
			}

			_inventoryManager.AddItem(startingItem);
		}
	}

	private void SpawnBulletsContainer()
	{
		_bulletsContainer = new Node2D();
		_bulletsContainer.Name = "BulletsContainer";
		
		AddChild(_bulletsContainer);
	}

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

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

public enum GameState
{
	Menu,
	Paused,
	Playing,
	Dialogue
}