public enum EWeaponType
{
    None,
    Sword,
    Bow,
    Staff,
    // add more as needed: Dagger, Axe, etc.
}

[Header("Weapon Requirement")]
[SerializeField] private EWeaponType m_requiredWeaponType = EWeaponType.None;

public EWeaponType requiredWeaponType => m_requiredWeaponType;

// true if no requirement OR equipment matches
public bool IsWeaponCompatible(Equipment equipment)
{
    if (m_requiredWeaponType == EWeaponType.None)
        return true;

    if (!equipment || !equipment.isWeapon)
        return false;

    return equipment.weaponType == m_requiredWeaponType;
}

public string GetWeaponRequirementMessage()
{
    if (m_requiredWeaponType == EWeaponType.None)
        return "You can't use this right now.";

    return $"You can't use this right now. Required weapon: {m_requiredWeaponType}";
}

[CreateAssetMenu(menuName = AssetMenuIndexer.Mythril2D_Items + nameof(Equipment))]
public class Equipment : Item
{
    [Header("Equipment")]
    [SerializeField] private EEquipmentType m_type;
    [SerializeField] private Stats m_bonusStats;
    [SerializeField] private SpriteLibraryAsset m_visualOverride;
    [SerializeField] private AbilitySheet[] m_bonusAbilities;

    [Header("Weapon Settings")]
    [SerializeField] private bool m_isWeapon = false;
    [SerializeField] private EWeaponType m_weaponType = EWeaponType.None;

    public EEquipmentType type => m_type;
    public Stats bonusStats => m_bonusStats;
    public SpriteLibraryAsset visualOverride => m_visualOverride;
    public AbilitySheet[] bonusAbilities => m_bonusAbilities;

    public bool isWeapon => m_isWeapon;
    public EWeaponType weaponType => m_weaponType;
}

/// <summary>
/// Shows the weapon requirement message while pausing the game.
/// </summary>
private async void ShowWeaponRequirementMessagePaused(AbilitySheet sheet)
{
    string msg = sheet.GetWeaponRequirementMessage();

    float previousTimeScale = Time.timeScale;
    Time.timeScale = 0f;

    try
    {
        await GameManager.DialogueSystem.Main.PlayNow(msg);
    }
    finally
    {
        Time.timeScale = previousTimeScale;
    }
}

public EAbilityFireCheckResult FireAbility(ITriggerableAbility ability)
{
    ActiveAbilityBase abilityBase = ability.GetAbilityBase();

    // ───── Weapon requirement check (main + off-hand) ─────
    if (abilityBase != null && abilityBase.baseAbilitySheet != null)
    {
        AbilitySheet sheet = abilityBase.baseAbilitySheet;

        // Get currently equipped weapons
        Equipment mainWeapon = GameManager.InventorySystem.GetEquipment(EEquipmentType.Weapon);
        Equipment offWeapon  = GameManager.InventorySystem.GetEquipment(EEquipmentType.OffHand);

        bool compatible =
            sheet.IsWeaponCompatible(mainWeapon) ||
            sheet.IsWeaponCompatible(offWeapon);

        if (!compatible)
        {
            ShowWeaponRequirementMessagePaused(sheet);
            return EAbilityFireCheckResult.Unknown;
        }
    }
    // ──────────────────────────────────────────────────────

    EAbilityFireCheckResult triggerAbilityCheckResult = ability.CanFire();

    if (triggerAbilityCheckResult == EAbilityFireCheckResult.Valid)
    {
        GameManager.NotificationSystem.audioPlaybackRequested.Invoke(abilityBase.abilitySheet.fireAudio);

        bool isAbilityStateAutomaticallyManaged =
            abilityBase.baseAbilitySheet.abilityStateManagementMode
                == ActiveAbilitySheet.EAbilityStateManagementMode.Automatic;

        if (abilityBase.abilitySheet.updateLookAtDirectionOnFire)
        {
            SetLookAtDirection(GetTargetDirection());
        }

        if (isAbilityStateAutomaticallyManaged)
        {
            abilityBase.gameObject.SetActive(true);
            ability.Fire(() => abilityBase.gameObject.SetActive(false));
        }
        else
        {
            ability.Fire(null);
        }
    }

    return triggerAbilityCheckResult;
}