/// The flag bit for armor items.
private enum int armorFlag    = 0b1;
/// The flag bit for weapon items.
private enum int weaponFlag   = 0b10;
/// The flag bit for heavy items.
private enum int heavyFlag    = 0b100;

enum Wear : ubyte {
    none,
    head,
    shoulder,
    leftArm,
    rightArm,
    torso,
    legs,
    feet,
    innerTorso,
    innerLegs,
    belt,
    leftFinger,
    rightFinger,
    robe,
    cape
}

enum Weapon : ubyte {
    none,
    blade,
    blunt,
    axe,
    polearm,
    thrown,
    sling,
    bow,
    crossbow
}

// The boundary of the enum flags.
private enum int flagBoundary = heavyFlag / 2;

enum ItemType : ubyte {
    // The value which is just the heavy flag and nothing else indicates
    // a quest item.
    questItem     = heavyFlag,
    // Light armor items.
    lightHead     = armorFlag | (Wear.head                    << flagBoundary),
    lightShoulder = armorFlag | (Wear.shoulder                << flagBoundary),
    lightLeftArm  = armorFlag | (Wear.leftArm                 << flagBoundary),
    lightRightArm = armorFlag | (Wear.rightArm                << flagBoundary),
    lightTorso    = armorFlag | (Wear.torso                   << flagBoundary),
    lightLegs     = armorFlag | (Wear.legs                    << flagBoundary),
    lightFeet     = armorFlag | (Wear.feet                    << flagBoundary),
    // Heavy armor items.
    heavyHead     = armorFlag | heavyFlag | (Wear.head        << flagBoundary),
    heavyShoulder = armorFlag | heavyFlag | (Wear.shoulder    << flagBoundary),
    heavyLeftArm  = armorFlag | heavyFlag | (Wear.leftArm     << flagBoundary),
    heavyRightArm = armorFlag | heavyFlag | (Wear.rightArm    << flagBoundary),
    heavyTorso    = armorFlag | heavyFlag | (Wear.torso       << flagBoundary),
    heavyLegs     = armorFlag | heavyFlag | (Wear.legs        << flagBoundary),
    heavyFeet     = armorFlag | heavyFlag | (Wear.feet        << flagBoundary),
    // Dress items.
    innerTorso    = armorFlag | (Wear.innerTorso              << flagBoundary),
    innerLegs     = armorFlag | (Wear.innerLegs               << flagBoundary),
    belt          = armorFlag | (Wear.belt                    << flagBoundary),
    leftFinger    = armorFlag | (Wear.leftFinger              << flagBoundary),
    rightFinger   = armorFlag | (Wear.rightFinger             << flagBoundary),
    robe          = armorFlag | (Wear.robe                    << flagBoundary),
    cape          = armorFlag | (Wear.cape                    << flagBoundary),
    // One handed weapons
    oneHandBlade  = weaponFlag | (Weapon.blade                << flagBoundary),
    oneHandBlunt  = weaponFlag | (Weapon.blunt                << flagBoundary),
    oneHandAxe    = weaponFlag | (Weapon.axe                  << flagBoundary),
    // Two handed weapons.
    twoHandBlade  = weaponFlag | heavyFlag | (Weapon.blade    << flagBoundary),
    twoHandBlunt  = weaponFlag | heavyFlag | (Weapon.blunt    << flagBoundary),
    twoHandAxe    = weaponFlag | heavyFlag | (Weapon.axe      << flagBoundary),
    polearm       = weaponFlag | heavyFlag | (Weapon.polearm  << flagBoundary),
    // One hand ranged weapons.
    thrown        = weaponFlag | (Weapon.thrown               << flagBoundary),
    slign         = weaponFlag | (Weapon.sling                << flagBoundary),
    // Two hand ranged weapons.
    bow           = weaponFlag | heavyFlag | (Weapon.bow      << flagBoundary),
    crossbow      = weaponFlag | heavyFlag | (Weapon.crossbow << flagBoundary),
}

/**
 * Determine if an item is armor.
 *
 * Params:
 * itemType = An item type.
 *
 * Returns: true if the item is armor.
 */
@safe pure nothrow
bool isArmor(ItemType itemType) {
    return (itemType & armorFlag) > 0;
}

/**
 * Determine if an item is a dress item.
 *
 * Params:
 * itemType = An item type.
 *
 * Returns: true if the item is a dress item.
 */
@safe pure nothrow
bool isDressItem(ItemType itemType) {
    // Everything >= this number is in the dress item region.
    enum ubyte dressRegion = (Wear.innerTorso << heavyFlag / 2);

    return (itemType & armorFlag) > 0 && itemType >= dressRegion;
}

/**
 * Determine if an item is a weapon.
 *
 * Params:
 * itemType = An item type.
 *
 * Returns: true if the item is a weapon.
 */
@safe pure nothrow
bool isWeapon(ItemType itemType) {
    return (itemType & weaponFlag) != 0;
}

/**
 * Determine if an item is usuable.
 *
 * Params:
 * itemType = An item type.
 *
 * Returns: true if the item is usuable.
 */
@safe pure nothrow
bool isUsable(ItemType itemType) {
    enum allFlags = heavyFlag & weaponFlag & armorFlag;

    // Usable items have none of the flags.
    return (itemType & allFlags) == 0;
}

/**
 * Determine if an item is heavy.
 *
 * Params:
 * itemType = An item type.
 *
 * Returns: true if the item is heavy.
 */
@safe pure nothrow
bool isHeavy(ItemType itemType) {
    return (itemType & heavyFlag) != 0;
}

/**
 * Determine if an item is a quest item.
 *
 * Params:
 * itemType = An item type.
 *
 * Returns: true if the item is a quest item.
 */
@safe pure nothrow
bool isQuestItem(ItemType itemType) {
    return itemType == ItemType.questItem;
}

/**
 * Determine the wear slot for an item.
 *
 * Params:
 * itemType = An item type.
 *
 * Returns: The wear slot, which may be none.
 */
@safe pure nothrow
Wear equipmentSlot(ItemType itemType) {
    // All possible bits that might be set in the wearable enum.
    enum ubyte wearBits = 2 ^^ (bsr(Wear.max) + 1) - 1;

    if (itemType.isArmor) {
        return cast(Wear) ((itemType >> flagBoundary) & wearBits);
    }

    return Wear.none;
}

@safe pure nothrow
Weapon weaponType(ItemType itemType) {
    enum ubyte weaponBits = 2 ^^ (bsr(Weapon.max) + 1) - 1;

    if (itemType.isWeapon) {
        return cast(Weapon) ((itemType >> flagBoundary) & weaponBits);
    }

    return Weapon.none;
}