using Godot;
using System;
using System.Diagnostics;
using Cirno.Scripts;
using Cirno.Scripts.Components;
using Cirno.Scripts.Controllers;
using Cirno.Scripts.Resources;
using Cirno.Scripts.Utils;

public partial class Weapon : Node2D
{
	
	[Export]
	public WeaponResource WeaponData { get; set; }

	[Export]
	public PackedScene BulletScene { get; set; }
	
	[Export]
	public Marker2D Muzzle { get; set; }
	
	[Export]
	public Marker2D Pivot { get; set; }
	
	[Export]
	public Sprite2D Sprite { get; private set; }

	[Export] public StringName PowerKey { get; set; } = "POWER";
	
	[Signal]
	public delegate void ShootingEventHandler();

	[Signal]
	public delegate void ReloadingEventHandler();
	
	[Signal] public delegate void EmptyEventHandler();
	
	public int Ammo { get; set; } = 0;

	private int _loadedAmmo;
	public int LoadedAmmo
	{
		get => _loadedAmmo;
		private set
		{
			_loadedAmmo = value; 
			_inventoryManager?.NotifyLoadedAmmoChange(WeaponData?.ItemKey, _loadedAmmo);
		}
	}
	
	public Vector2 ShootDirection { get; set; } = Vector2.Zero;
	
	private Timer _cooldownTimer;

	private Marker2D _muzzle;

	private Node2D _bulletsContainer;
	
	private GameManager _gameManager;

	private InventoryManager _inventoryManager;

	private readonly StringName _shieldAmmoType = "SHIELD";
	private bool UsesBattery => WeaponData.AmmoKey == _shieldAmmoType;
	
	// Called when the node enters the scene tree for the first time.
	public override void _Ready()
	{
		_muzzle = GetNode<Marker2D>("./Muzzle");
		_cooldownTimer = GetNode<Timer>("./ShootTimer");

		_gameManager = this.GetGameManager();
		_inventoryManager = this.GetInventoryManager();
		
		// Start full
		if (WeaponData != null)
		{
			LoadedAmmo = WeaponData.BulletCapacity;
		}
	}

	public void Reload()
	{
		EmitSignalReloading();
		
		_cooldownTimer.Start(WeaponData.ReloadTime);
		
		if (WeaponData.InfiniteAmmo || string.IsNullOrWhiteSpace(WeaponData.AmmoKey))
		{
			LoadedAmmo = WeaponData.BulletCapacity;
		}
		else
		{
			var ammoToLoad = _inventoryManager.RemoveItem(WeaponData.AmmoKey, WeaponData.BulletCapacity - LoadedAmmo);
			
			if (ammoToLoad > 0)
			{
				LoadedAmmo = ammoToLoad;
			}
			else
			{
				EmitSignalEmpty();
				//GD.Print("Out of ammo");
			}
		}
	}

	public void Shoot(BulletOwner? ownerOverride = null)
	{
		// Waiting on reload or Rate of Fire cooldown?
		if (!_cooldownTimer.IsStopped())
		{
			return;
		}

		// Check for battery if it's used
		if (UsesBattery)
		{
			if (GameManager.Instance.Player.Shield.CurrentResource >= WeaponData.AmmoPerShot)
			{
				GameManager.Instance.Player.Shield.CurrentResource -= WeaponData.AmmoPerShot;
			}
			else
			{
				EmitSignalEmpty();
				return;
			}
		}
		
		// Out of ammo?
		if (LoadedAmmo < WeaponData.AmmoPerShot)
		{
			if (WeaponData.AutoReload)
			{
				Reload();
			}
			EmitSignalEmpty();
			return;
		}
		
		EmitSignalShooting();
		
		// TODO: Shoot at muzzle position, need to provide a way to turn it, on a radius?

		float halfSpread = WeaponData.SpreadAngle / 2f;
		float spreadStep = WeaponData.BulletsPerShot > 1 ? WeaponData.SpreadAngle / (WeaponData.BulletsPerShot - 1) : 0;
		
		for (int i = 0; i < WeaponData.BulletsPerShot; i++)
		{
			// Calculate angle offset for this bullet
			float spreadOffset = -halfSpread + (spreadStep * i);

			// Add random spread
			if (WeaponData.RandomSpread > 0)
			{
				// Gaussian with mean = 0, stddev = WeaponData.RandomSpread
				spreadOffset += RandomStuff.GaussianClamped(
					mean: 0f,
					stdDev: WeaponData.RandomSpread, // tuning knob
					min: -halfSpread,
					max: halfSpread
				);
			}
			
			// Rotate the ShootDirection by the spread angle
			Vector2 spreadDirection = ShootDirection.Rotated(Mathf.DegToRad(spreadOffset));

			var bullet = PoolingManager.Instance.SpawnBullet(WeaponData.BulletData);
			bullet.GlobalPosition = _muzzle.GlobalPosition;
			
			//var bullet = this.CreateChildOf<Bullet>(_gameManager.BulletsContainer, WeaponData.BulletData.BulletScene, _muzzle.GlobalPosition);

			if (bullet == null)
			{
				GD.PrintErr("Bullet is null, not shooting");
				return;
			};

			var bulletData = WeaponData.MakeBullet(_muzzle.GlobalPosition);
			if (ownerOverride.HasValue)
			{
				bulletData.Owner = ownerOverride.Value;
			}

			if (bulletData.Owner is BulletOwner.Player || ownerOverride is BulletOwner.Player)
			{
				// Apply the P multiplier
				bulletData.Damage *=
					GetBulletStrengthMultiplier(bulletData.Damage, bulletData.OriginalBulletResource.MaxDamage, 20);
			}
			
			bullet.Initialize(bulletData, _gameManager);
		
			//bullet.SetDirection(ShootDirection);
			bullet.SetDirection(spreadDirection);
			bullet.Speed = WeaponData.BulletData.BulletSpeed;
		}

		if (!UsesBattery)
		{
			LoadedAmmo -= WeaponData.AmmoPerShot;
		}
		
		//_inventoryManager.NotifyLoadedAmmoChange(WeaponData.ItemKey, LoadedAmmo);
		// if (!string.IsNullOrWhiteSpace(WeaponData?.AmmoKey))
		// {
		// 	// Notify hud to decrease weapon
		// 	
		// }
		
		_cooldownTimer.Start(WeaponData?.RateOfFire ?? 0);
	}

	private float GetBulletStrengthMultiplier(float baseDamage, float maxDamage, float maxPower)
	{
		var p = InventoryManager.Instance.GetItemCount(PowerKey);

		float minMultiplier = 1.0f;
		float maxMultiplier = maxDamage / baseDamage;

		float normalizedPower = Mathf.Clamp((float)p / maxPower, 0f, 1f);
		return Mathf.Lerp(minMultiplier, maxMultiplier, normalizedPower);
	}

	public void RotateWeapon(Vector2 facingDirection, Vector2 leftPosition, Vector2 rightPosition)
	{
		bool facingLeft = facingDirection.X < 0;

		if (facingLeft)
		{
			Sprite.Position = leftPosition - Pivot.Position;
			Sprite.FlipH = true;
		}
		else
		{
			Sprite.Position = rightPosition - Pivot.Position;
			Sprite.FlipH = false;
		}
		
		// var angle = Mathf.Atan2(StorageModule.FacingDirection.X, StorageModule.FacingDirection.Y);
  //       
		// // Weapon is drawn pointing right, but we want it to point "up" along aim vector.
		// // So we apply a 90° offset (π/2), but...
		// // If facing left, we also add 180° (π) to "un-mirror" it visually.
		// float rotationOffset = (Mathf.Pi / 2f);
		//
		// if (facingLeft)
		// {
		// 	EquippedWeapon.Sprite.Rotation = -(angle + rotationOffset);// + rotationOffset + Mathf.Pi;
		// 	EquippedWeapon.Sprite.Position = WeaponLeftOffset;
		// 	EquippedWeapon.Sprite.FlipH = true; // disable FlipH to avoid messing with rotation
		// 	EquippedWeapon.Sprite.FlipV = false;
		// }
		// else
		// {
		// 	EquippedWeapon.Sprite.Rotation = angle;// + rotationOffset;
		// 	EquippedWeapon.Sprite.Position = WeaponRightOffset;
		// 	EquippedWeapon.Sprite.FlipH = false;
		// 	EquippedWeapon.Sprite.FlipV = true;
		// }
	}
}
