#include "ItemCreator.hh"

#include <algorithm>
#include <array>

#include "EnemyType.hh"
#include "Loggers.hh"

// Note: There are clearly better ways of doing this, but this implementation closely follows what the original code in
// the client does.
template <typename ItemT, size_t MaxCount>
struct ProbabilityTable {
  ItemT items[MaxCount];
  size_t count;

  ProbabilityTable() : count(0) {}

  ProbabilityTable(const std::vector<ShopRandomSetBase::IntPairT<ItemT>>& table) : ProbabilityTable() {
    for (const auto& entry : table) {
      for (size_t y = 0; y < entry.weight; y++) {
        this->push(entry.value);
      }
    }
  }

  template <size_t Count>
  ProbabilityTable(const std::array<ShopRandomSetBase::IntPairT<ItemT>, Count>& table) : ProbabilityTable() {
    for (const auto& entry : table) {
      for (size_t y = 0; y < entry.weight; y++) {
        this->push(entry.value);
      }
    }
  }

  void push(ItemT item) {
    if (this->count == MaxCount) {
      throw std::runtime_error("push to full probability table");
    }
    this->items[this->count++] = item;
  }

  ItemT pop() {
    if (this->count == 0) {
      throw std::runtime_error("pop from empty probability table");
    }
    return this->items[--this->count];
  }

  void shuffle(std::shared_ptr<RandomGenerator> rand_crypt) {
    for (size_t z = 1; z < this->count; z++) {
      size_t other_z = rand_crypt->next() % (z + 1);
      ItemT t = this->items[z];
      this->items[z] = this->items[other_z];
      this->items[other_z] = t;
    }
  }

  ItemT sample(std::shared_ptr<RandomGenerator> rand_crypt) const {
    if (this->count == 0) {
      throw std::runtime_error("sample from empty probability table");
    } else if (this->count == 1) {
      return this->items[0];
    } else {
      return this->items[rand_crypt->next() % this->count];
    }
  }
};

ItemCreator::ItemCreator(
    std::shared_ptr<const CommonItemSet> common_item_set,
    std::shared_ptr<const RareItemSet> rare_item_set,
    std::shared_ptr<const ArmorShopRandomSet> armor_random_set,
    std::shared_ptr<const ToolShopRandomSet> tool_random_set,
    std::shared_ptr<const WeaponShopRandomSet> weapon_random_set,
    std::shared_ptr<const TekkerAdjustmentSet> tekker_adjustment_set,
    std::shared_ptr<const ItemParameterTable> item_parameter_table,
    std::shared_ptr<const ItemData::StackLimits> stack_limits,
    GameMode mode,
    Difficulty difficulty,
    uint8_t section_id,
    std::shared_ptr<RandomGenerator> rand_crypt,
    std::shared_ptr<const BattleRules> restrictions)
    : log(std::format("[ItemCreator:{}/{}/{}/{}] ", phosg::name_for_enum(stack_limits->version), abbreviation_for_mode(mode), abbreviation_for_difficulty(difficulty), section_id), lobby_log.min_level),
      logic_version(stack_limits->version),
      is_legacy_replay(false),
      stack_limits(stack_limits),
      mode(mode),
      difficulty(difficulty),
      section_id(section_id),
      rare_item_set(rare_item_set),
      armor_random_set(armor_random_set),
      tool_random_set(tool_random_set),
      weapon_random_set(weapon_random_set),
      tekker_adjustment_set(tekker_adjustment_set),
      item_parameter_table(item_parameter_table),
      common_item_set(common_item_set),
      restrictions(restrictions),
      rand_crypt(rand_crypt) {
  this->generate_unit_stars_tables();
}

void ItemCreator::set_section_id(uint8_t new_section_id) {
  if (this->section_id != new_section_id) {
    this->section_id = new_section_id;
    this->log.prefix = std::format("[ItemCreator:{}/{}/{}/{}] ",
        phosg::name_for_enum(stack_limits->version),
        abbreviation_for_mode(mode),
        abbreviation_for_difficulty(difficulty),
        this->section_id);
  }
}

bool ItemCreator::are_rare_drops_allowed() const {
  // Note: The client has an additional check here, which appears to be a subtle anti-cheating measure. There is a flag
  // on the client, initially zero, which is set to 1 when certain unexpected item-related things happen (for example,
  // a player possessing a mag with a level above 200, or a stack of consumables with an amount above the stack size
  // limit). When the flag is set, this function returns false, which prevents all rare item drops. newserv
  // intentionally does not implement this flag.
  return (this->mode != GameMode::CHALLENGE);
}

uint8_t ItemCreator::table_index_for_area(uint8_t area) const {
  if (this->restrictions && (this->restrictions->box_drop_area != 0)) {
    return this->restrictions->box_drop_area - 1;
  }
  static constexpr std::array<uint8_t, 0x2F> data = {
      // Episode 1
      0xFF, // 00 => Pioneer 2 (no drops)
      0x00, // 01 => Forest 1
      0x01, // 02 => Forest 2
      0x02, // 03 => Cave 1
      0x03, // 04 => Cave 2
      0x04, // 05 => Cave 3
      0x05, // 06 => Mine 1
      0x06, // 07 => Mine 2
      0x07, // 08 => Ruins 1
      0x08, // 09 => Ruins 2
      0x09, // 0A => Ruins 3
      0x02, // 0B => Dragon -> Cave 1
      0x05, // 0C => De Rol Le -> Mine 1
      0x07, // 0D => Vol Opt -> Ruins 1
      0x09, // 0E => Dark Falz -> Ruins 3
      0xFF, // 0F => Lobby (no drops)
      0x09, // 10 => Palace -> Ruins 3
      0x09, // 11 => Spaceship -> Ruins 3
      // Episode 2
      0xFF, // 12 => Lab (no drops)
      0x00, // 13 => VR Temple Alpha
      0x01, // 14 => VR Temple Beta
      0x02, // 15 => VR Spaceship Alpha
      0x03, // 16 => VR Spaceship Beta
      0x07, // 17 => Central Control Area -> Seaside
      0x04, // 18 => Jungle North
      0x05, // 19 => Jungle South
      0x06, // 1A => Mountain
      0x07, // 1B => Seaside
      0x08, // 1C => Seabed Upper
      0x09, // 1D => Seabed Lower
      0x08, // 1E => Gal Gryphon -> Seabed Upper
      0x09, // 1F => Olga Flow -> Seabed Lower
      0x02, // 20 => Barba Ray -> VR Spaceship Alpha
      0x04, // 21 => Gol Dragon -> Jungle North
      0x07, // 22 => Seaside Night -> Seaside
      0x09, // 23 => Tower -> Seabed Lower
      // Episode 4
      0x01, // 24 => Crater East
      0x02, // 25 => Crater West
      0x03, // 26 => Crater South
      0x04, // 27 => Crater North
      0x05, // 28 => Crater Interior
      0x06, // 29 => Subterranean Desert 1
      0x07, // 2A => Subterranean Desert 2
      0x08, // 2B => Subterranean Desert 3
      0x09, // 2C => Saint-Milion
      0xFF, // 2D => Pioneer 2 (no drops)
      0xFF, // 2E => Test area (no drops)
  };
  if (area >= data.size() || data[area] == 0xFF) {
    throw std::runtime_error("invalid area number");
  }
  return data[area];
}

ItemCreator::DropResult ItemCreator::on_box_item_drop(uint8_t area, bool force_rare) {
  try {
    uint8_t table_index = this->table_index_for_area(area);
    this->log.info_f("Box drop checks for area {:02X} (table index {:02X})", area, table_index);

    DropResult res;
    res.item = this->check_rare_specs_and_create_rare_box_item(area, force_rare);
    if (!res.item.empty()) {
      res.is_from_rare_table = true;
    } else {
      uint8_t item_class = this->get_rand_from_weighted_tables_2d_vertical(
          this->pt(area)->box_item_class_prob_table, table_index);
      this->log.info_f("Item class is {:02X}", item_class);
      switch (item_class) {
        case 0: // Weapon
          res.item.data1[0] = 0;
          break;
        case 1: // Armor
          res.item.data1[0] = 1;
          res.item.data1[1] = 1;
          break;
        case 2: // Shield
          res.item.data1[0] = 1;
          res.item.data1[1] = 2;
          break;
        case 3: // Unit
          res.item.data1[0] = 1;
          res.item.data1[1] = 3;
          break;
        case 4: // Tool
          res.item.data1[0] = 3;
          break;
        case 5: // Meseta
          res.item.data1[0] = 4;
          break;
        case 6: // Nothing
          break;
        default:
          throw std::logic_error("this should be impossible");
      }
      if (item_class < 6) {
        this->generate_common_item_variances(res.item, area);
      }
    }
    return res;

  } catch (const std::exception& e) {
    this->log.error_f("Exception in item creation: {}", e.what());
    return DropResult();
  }
}

ItemCreator::DropResult ItemCreator::on_monster_item_drop(EnemyType enemy_type, uint8_t area, bool force_rare) {
  try {
    // Note: The original implementation has a bounds check for enemy_type here, because it uses rt_index instead
    // if (enemy_type >= NUM_RT_INDEXES_V4) {
    //   this->log.warning_f("Invalid enemy type: {:X}", enemy_type);
    //   return DropResult();
    // }
    this->log.info_f("Enemy type: {}", phosg::name_for_enum(enemy_type));

    auto pt = this->pt(area);
    uint8_t type_drop_prob = 0;
    try {
      type_drop_prob = pt->enemy_type_drop_probs.at(enemy_type);
    } catch (const std::out_of_range&) {
      this->log.info_f("No drop probability is set for this enemy type");
      return DropResult();
    }
    if (!force_rare) {
      uint8_t drop_sample = this->rand_int(100);
      if (drop_sample >= type_drop_prob) {
        this->log.info_f("Drop not chosen ({} >= {})", drop_sample, type_drop_prob);
        return DropResult();
      } else {
        this->log.info_f("Drop chosen ({} < {})", drop_sample, type_drop_prob);
      }
    }

    DropResult res;
    res.item = this->check_rare_spec_and_create_rare_enemy_item(enemy_type, area, force_rare);
    if (!res.item.empty()) {
      res.is_from_rare_table = true;
    } else {
      uint8_t item_class_determinant = this->should_allow_meseta_drops() ? this->rand_int(3) : (this->rand_int(2) + 1);
      uint8_t item_class;
      switch (item_class_determinant) {
        case 0:
          item_class = 5;
          break;
        case 1:
          item_class = 4;
          break;
        case 2:
          try {
            item_class = pt->enemy_type_item_classes.at(enemy_type);
          } catch (const std::out_of_range&) {
            this->log.info_f("Item class is not set for this enemy type");
            item_class = 0xFF;
          }
          break;
        default:
          throw std::logic_error("invalid item class determinant");
      }

      this->log.info_f(
          "Rare drop not chosen; item class determinant is {}; item class is {}", item_class_determinant, item_class);

      switch (item_class) {
        case 0: // Weapon
          res.item.data1[0] = 0x00;
          break;
        case 1: // Armor
          res.item.data1w[0] = 0x0101;
          break;
        case 2: // Shield
          res.item.data1w[0] = 0x0201;
          break;
        case 3: // Unit
          res.item.data1w[0] = 0x0301;
          break;
        case 4: // Tool
          res.item.data1[0] = 0x03;
          break;
        case 5: // Meseta
          res.item.data1[0] = 0x04;
          try {
            res.item.data2d = this->choose_meseta_amount(pt->enemy_type_meseta_ranges.at(enemy_type)) & 0xFFFF;
          } catch (const std::out_of_range&) {
            this->log.info_f("Meseta range is not set for this enemy type");
            return DropResult();
          }
          break;
        default:
          return res;
      }

      if (res.item.data1[0] != 0x04) {
        this->generate_common_item_variances(res.item, area);
      }
    }

    return res;

  } catch (const std::exception& e) {
    this->log.error_f("Exception in item creation: {}", e.what());
    return DropResult();
  }
}

ItemData ItemCreator::check_rare_specs_and_create_rare_item(
    const std::vector<RareItemSet::ExpandedDrop>& specs, uint8_t area, bool force_rare) {
  if (specs.empty()) {
    return ItemData();
  }

  // This logic differs from the original client logic. This logic "stacks" all rare rates into a single probability
  // space, whereas the original client logic chooses a new random number for each rare spec that it checks. The
  // stacking logic makes the order of specs irrelevant, whereas the original client logic means that later specs are
  // actually more rare than they should be. In the original client, this only matters for boxes, because enemies could
  // not have multiple specs. Also, the original code uses 0xFFFFFFFF as the maximum here; we use 0x100000000 instead,
  // which makes all rare items SLIGHTLY more rare.
  int64_t det = force_rare ? 0 : this->rand_int(0x100000000);
  if (this->is_legacy_replay) {
    // For some old tests, we waste a few replay values because they used the old (non-stacked) logic. New tests should
    // not use this codepath.
    for (size_t z = 1; z < specs.size(); z++) {
      this->rand_int(0x100000000);
    }
  }
  this->log.info_f("{} specs to check with det={:08X}", specs.size(), det);
  for (const auto& spec : specs) {
    if (this->log.should_log(phosg::LogLevel::L_INFO)) {
      this->log.info_f("Checking spec {:08X} => {} with det={:08X}", spec.probability, spec.data.hex(), det);
    }
    det -= spec.probability;
    if (det < 0) {
      return this->create_rare_item(spec.data, area);
    }
  }
  return ItemData();
}

ItemData ItemCreator::check_rare_specs_and_create_rare_box_item(uint8_t area, bool force_rare) {
  if (!this->are_rare_drops_allowed()) {
    return ItemData();
  }

  uint8_t table_index = this->table_index_for_area(area);
  Episode episode = episode_for_area(area);
  auto specs = this->rare_item_set->get_box_specs(this->mode, episode, this->difficulty, this->section_id, table_index);
  return this->check_rare_specs_and_create_rare_item(specs, area, force_rare);
}

uint32_t ItemCreator::rand_int(uint64_t max) {
  return this->rand_crypt->next() % max;
}

float ItemCreator::rand_float_0_1_from_crypt() {
  // This lacks some precision, but matches the original implementation.
  return (static_cast<double>(this->rand_crypt->next() >> 16) / 65536.0);
}

uint32_t ItemCreator::choose_meseta_amount(const CommonItemSet::Table::Range<uint16_t>& range) {
  // Note: The original code returns 0xFF here if either limit is equal to 0xFF (despite them being 16-bit integers!)
  uint16_t ret;
  if (range.min == range.max) {
    ret = range.min;
  } else if (range.max < range.min) {
    ret = this->rand_int((range.min - range.max) + 1) + range.max;
  } else {
    ret = this->rand_int((range.max - range.min) + 1) + range.min;
  }

  this->log.info_f("Chose {} Meseta from range [{}, {}]", ret, range.min, range.max);
  return ret;
}

bool ItemCreator::should_allow_meseta_drops() const {
  return (this->mode != GameMode::CHALLENGE);
}

ItemData ItemCreator::check_rare_spec_and_create_rare_enemy_item(EnemyType enemy_type, uint8_t area, bool force_rare) {
  // Note: The original implementation has a bounds check for enemy_type here, since it uses rt_index instead.
  // if ((enemy_type <= 0) || (enemy_type >= NUM_RT_INDEXES_V4)) return ItemData{};
  if (!this->are_rare_drops_allowed()) {
    return ItemData{};
  }

  // Note: In the original implementation, enemies can only have one possible rare drop. In our implementation, they
  // can have multiple rare drops if JSONRareItemSet is used (the other RareItemSet implementations never return
  // multiple drops for an enemy type).
  Episode episode = episode_for_area(area);
  auto specs = this->rare_item_set->get_enemy_specs(
      this->mode, episode, this->difficulty, this->section_id, enemy_type);
  return this->check_rare_specs_and_create_rare_item(specs, area, force_rare);
}

ItemData ItemCreator::create_rare_item(const ItemData& drop_item, uint8_t area) {
  ItemData item = drop_item;
  if (item.can_be_encoded_in_rel_rare_table()) {
    switch (item.data1[0]) {
      case 0:
        if (this->pt(area)->has_rare_bonus_value_prob_table) {
          this->generate_rare_weapon_bonuses(item, episode_for_area(area), this->rand_int(10));
        } else {
          this->generate_common_weapon_bonuses(item, area);
        }
        this->set_item_unidentified_flag_if_not_challenge(item);
        break;
      case 1:
        this->generate_common_armor_slots_and_bonuses(item, episode_for_area(area));
        break;
      case 2:
        this->generate_common_mag_variances(item);
        break;
      case 3:
        this->clear_tool_item_if_invalid(item);
        this->set_tool_item_amount_to_1(item);
        break;
      case 4:
        break;
      default:
        throw std::logic_error("invalid item class");
    }
    this->set_item_kill_count_if_unsealable(item);
  }

  this->clear_item_if_restricted(item);
  return item;
}

void ItemCreator::generate_rare_weapon_bonuses(ItemData& item, Episode episode, uint32_t table_index) {
  if (item.data1[0] != 0) {
    return;
  }

  auto pt = this->pt(episode);
  if (!pt->has_rare_bonus_value_prob_table) {
    throw std::logic_error("generate_rare_weapon_bonuses called for common item table without rare bonus value probability table");
  }

  for (size_t z = 0; z < 6; z += 2) {
    uint8_t bonus_type = this->get_rand_from_weighted_tables_2d_vertical(pt->bonus_type_prob_table, table_index);
    int16_t bonus_value = this->get_rand_from_weighted_tables_2d_vertical(pt->bonus_value_prob_table, 5);
    item.data1[z + 6] = bonus_type;
    item.data1[z + 7] = bonus_value * 5 - 10;
    // Note: The original code has a special case here, which divides item.data1[z + 7] by 5 and multiplies it by 5
    // again if bonus_type is 5 (Hit). Why this is done is unclear, because item.data1[z + 7] must already be a
    // multiple of 5.
  }

  this->deduplicate_weapon_bonuses(item);
}

void ItemCreator::generate_common_weapon_bonuses(ItemData& item, uint8_t area) {
  if (item.data1[0] != 0) {
    return;
  }

  auto pt = this->pt(area);
  uint8_t table_index = this->table_index_for_area(area);
  for (size_t row = 0; row < 3; row++) {
    uint8_t spec = pt->nonrare_bonus_prob_spec.at(row).at(table_index);
    if (spec == 0xFF) {
      this->log.info_f("Bonus {} is forbidden", row);
    } else {
      item.data1[(row * 2) + 6] = this->get_rand_from_weighted_tables_2d_vertical(pt->bonus_type_prob_table, table_index);
      int16_t amount = this->get_rand_from_weighted_tables_2d_vertical(pt->bonus_value_prob_table, spec);
      item.data1[(row * 2) + 7] = amount * 5 - 10;
      this->log.info_f("Bonus {} generated as {:02X} {:02X} from table index {:02X} and spec {:02X}", row, item.data1[(row * 2) + 6], item.data1[(row * 2) + 7], table_index, spec);
    }
    // Note: The original code has a special case here, which divides item.data1[z + 7] by 5 and multiplies it by 5
    // again if bonus_type is 5 (Hit). Why this is done is unclear, because item.data1[z + 7] must already be a
    // multiple of 5.
  }

  this->deduplicate_weapon_bonuses(item);
}

void ItemCreator::deduplicate_weapon_bonuses(ItemData& item) const {
  for (size_t x = 0; x < 6; x += 2) {
    for (size_t y = 0; y < x; y += 2) {
      if (item.data1[y + 6] == 0x00) {
        item.data1[x + 6] = 0x00;
      } else if (item.data1[x + 6] == item.data1[y + 6]) {
        item.data1[x + 6] = 0x00;
      }
    }
    if (item.data1[x + 6] == 0x00) {
      item.data1[x + 7] = 0x00;
    }
  }
}

void ItemCreator::set_item_kill_count_if_unsealable(ItemData& item) const {
  if (this->item_parameter_table->is_unsealable_item(item)) {
    this->log.info_f("Item is unsealable; setting kill count to zero");
    item.set_kill_count(0);
  }
}

void ItemCreator::set_item_unidentified_flag_if_not_challenge(ItemData& item) const {
  if (this->mode == GameMode::CHALLENGE) {
    return;
  }
  if (item.data1[0] != 0x00) {
    return;
  }
  // On V1, V3, and V4, all rare weapons and weapons with specials are untekked when created; on V2, only rares that
  // are not in the standard item classes are untekked when created.
  bool is_rare = this->item_parameter_table->is_item_rare(item);
  bool use_v2_logic = is_v2(this->logic_version) && (this->logic_version != Version::GC_NTE);
  if (use_v2_logic ? (is_rare ? (item.data1[1] > 0x0C) : (item.data1[4] != 0)) : (is_rare || (item.data1[4] != 0))) {
    item.data1[4] |= 0x80;
  }
}

void ItemCreator::set_tool_item_amount_to_1(ItemData& item) const {
  if (item.data1[0] == 0x03) {
    item.set_tool_item_amount(*this->stack_limits, 1);
  }
}

void ItemCreator::clear_tool_item_if_invalid(ItemData& item) {
  if ((item.data1[1] == 0x02) && ((item.data1[2] > 0x1D) || (item.data1[4] > 0x12))) {
    item.clear();
  }
}

void ItemCreator::clear_item_if_restricted(ItemData& item) const {
  if (this->item_parameter_table->is_item_rare(item) && !this->are_rare_drops_allowed()) {
    this->log.info_f("Restricted: item is rare, but rares not allowed");
    item.clear();
    return;
  }

  if (this->mode == GameMode::CHALLENGE) {
    // Forbid HP/TP-restoring units and meseta in challenge mode. PSO GC doesn't check for 0x61 or 0x62 here since
    // those items (HP/Resurrection and TP/Resurrection) only exist on BB.
    if (item.data1[0] == 1) {
      if ((item.data1[1] == 3) && (((item.data1[2] >= 0x33) && (item.data1[2] <= 0x38)) || (item.data1[2] == 0x61) || (item.data1[2] == 0x62))) {
        this->log.info_f("Restricted: restore units not allowed in Challenge mode");
        item.clear();
        return;
      }
    } else if (item.data1[0] == 4) {
      this->log.info_f("Restricted: meseta not allowed in Challenge mode");
      item.clear();
      return;
    }
  }

  if (this->restrictions) {
    switch (item.data1[0]) {
      case 0:
      case 1:
        switch (this->restrictions->weapon_and_armor_mode) {
          case BattleRules::WeaponAndArmorMode::ALLOW:
          case BattleRules::WeaponAndArmorMode::CLEAR_AND_ALLOW:
            break;
          case BattleRules::WeaponAndArmorMode::FORBID_RARES:
            if (this->item_parameter_table->is_item_rare(item)) {
              this->log.info_f("Restricted: rare weapons and armors not allowed");
              item.clear();
            }
            break;
          case BattleRules::WeaponAndArmorMode::FORBID_ALL:
            this->log.info_f("Restricted: weapons and armors not allowed");
            item.clear();
            break;
          default:
            throw std::logic_error("invalid weapon and armor mode");
        }
        break;
      case 2:
        if (this->restrictions->mag_mode == BattleRules::MagMode::FORBID_ALL) {
          this->log.info_f("Restricted: mags not allowed");
          item.clear();
        }
        break;
      case 3:
        if (this->restrictions->tool_mode == BattleRules::ToolMode::FORBID_ALL) {
          this->log.info_f("Restricted: tools not allowed");
          item.clear();
        } else if (item.data1[1] == 2) {
          switch (this->restrictions->tech_disk_mode) {
            case BattleRules::TechDiskMode::ALLOW:
              break;
            case BattleRules::TechDiskMode::FORBID_ALL:
              this->log.info_f("Restricted: tech disks not allowed");
              item.clear();
              break;
            case BattleRules::TechDiskMode::LIMIT_LEVEL:
              this->log.info_f("Restricted: tech disk level limited to {}",
                  static_cast<uint8_t>(this->restrictions->max_tech_level + 1));
              if (this->restrictions->max_tech_level == 0) {
                item.data1[2] = 0;
              } else {
                item.data1[2] %= this->restrictions->max_tech_level;
              }
              break;
            default:
              throw std::logic_error("invalid tech disk mode");
          }
        } else if ((item.data1[1] == 9) && this->restrictions->forbid_scape_dolls) {
          this->log.info_f("Restricted: scape dolls not allowed");
          item.clear();
        }
        break;
      case 4:
        if (this->restrictions->meseta_mode == BattleRules::MesetaMode::FORBID_ALL) {
          this->log.info_f("Restricted: meseta not allowed");
          item.clear();
        }
        break;
      default:
        throw std::logic_error("invalid item");
    }
  }
}

void ItemCreator::generate_common_item_variances(ItemData& item, uint8_t area) {
  switch (item.data1[0]) {
    case 0:
      this->generate_common_weapon_variances(item, area);
      break;
    case 1:
      if (item.data1[1] == 3) {
        float f1 = 1.0 + this->pt(area)->unit_max_stars_table.at(this->table_index_for_area(area));
        float f2 = this->rand_float_0_1_from_crypt();
        uint8_t stars = static_cast<uint32_t>(f1 * f2) & 0xFF;
        this->log.info_f("Unit stars: {:g} * {:g} = {}", f1, f2, stars);
        this->generate_common_unit_variances(stars, item);
        if (item.data1[2] == 0xFF) {
          this->log.info_f("Unit subtype not valid; clearing item");
          item.clear();
        }
      } else {
        this->generate_common_armor_or_shield_type_and_variances(item, area);
      }
      break;
    case 2:
      this->generate_common_mag_variances(item);
      break;
    case 3:
      this->generate_common_tool_variances(item, area);
      break;
    case 4: {
      const auto& range = this->pt(area)->box_meseta_ranges.at(this->table_index_for_area(area));
      item.data2d = this->choose_meseta_amount(range) & 0xFFFF;
      break;
    }
    default:
      // Note: The original code does the following here:
      //   item.clear();
      //   item.data1[0] = 0x05;
      throw std::logic_error("invalid item class");
  }

  this->clear_item_if_restricted(item);
  this->set_item_kill_count_if_unsealable(item);
}

void ItemCreator::generate_common_armor_or_shield_type_and_variances(ItemData& item, uint8_t area) {
  this->generate_common_armor_slots_and_bonuses(item, episode_for_area(area));

  auto pt = this->pt(area);
  uint8_t table_index = this->table_index_for_area(area);

  uint8_t type = this->get_rand_from_weighted_tables_1d(pt->armor_shield_type_index_prob_table);
  item.data1[2] = table_index + type + pt->armor_or_shield_type_bias;
  if (item.data1[2] < 3) {
    item.data1[2] = 0;
  } else {
    item.data1[2] -= 3;
  }
  this->log.info_f("Armor/shield type: max({:02X} + {:02X} + {:02X} - 3, 0) = {:02X}",
      table_index, type, pt->armor_or_shield_type_bias, item.data1[2]);
}

void ItemCreator::generate_common_armor_slots_and_bonuses(ItemData& item, Episode episode) {
  if ((item.data1[0] != 0x01) || (item.data1[1] < 1) || (item.data1[1] > 2)) {
    return;
  }

  if (item.data1[1] == 1) {
    this->generate_common_armor_slot_count(item, episode);
  }

  const auto& def = this->item_parameter_table->get_armor_or_shield(item.data1[1], item.data1[2]);
  item.set_armor_or_shield_defense_bonus(def.dfp_range * this->rand_float_0_1_from_crypt());
  item.set_common_armor_evasion_bonus(def.evp_range * this->rand_float_0_1_from_crypt());
}

void ItemCreator::generate_common_armor_slot_count(ItemData& item, Episode episode) {
  item.data1[5] = this->get_rand_from_weighted_tables_1d(this->pt(episode)->armor_slot_count_prob_table);
}

void ItemCreator::generate_common_tool_variances(ItemData& item, uint8_t area) {
  item.clear();

  auto pt = this->pt(area);
  uint8_t table_index = this->table_index_for_area(area);

  uint8_t tool_class = this->get_rand_from_weighted_tables_2d_vertical(pt->tool_class_prob_table, table_index);
  if ((!is_v1_or_v2(this->logic_version) || (this->logic_version == Version::GC_NTE)) && (tool_class == 0x1A)) {
    tool_class = 0x73;
  }
  this->log.info_f("Generating tool with class {:02X}", tool_class);

  // Note: This block was originally a separate function called generate_common_tool_type
  {
    // It appears that when Sega deleted Hit Material in v3, they never deleted it from the ItemPT entries, so
    // sometimes ItemCreator tries to generate it. The original implementation just generates no item when that
    // happens, so we do the same here.
    try {
      auto data = this->item_parameter_table->find_tool_by_id(tool_class);
      item.data1[0] = 0x03;
      item.data1[1] = data.first;
      item.data1[2] = data.second;
    } catch (const std::out_of_range&) {
      this->log.info_f("Tool class is missing; skipping item generation");
      return;
    }
  }

  if (item.data1[1] == 0x02) { // Tech disk
    item.data1[4] = this->get_rand_from_weighted_tables_2d_vertical(pt->technique_index_prob_table, table_index);
    item.data1[2] = this->generate_tech_disk_level(item.data1[4], area);
    this->clear_tool_item_if_invalid(item);
  }
  this->set_tool_item_amount_to_1(item);
}

uint8_t ItemCreator::generate_tech_disk_level(uint32_t tech_num, uint8_t area) {
  const auto& range = this->pt(area)->technique_level_ranges.at(tech_num).at(this->table_index_for_area(area));
  if (((range.min == 0xFF) || (range.max == 0xFF)) || (range.max < range.min)) {
    return 0xFF;
  } else if (range.min != range.max) {
    return this->rand_int((range.max - range.min) + 1) + range.min;
  }
  return range.min;
}

void ItemCreator::generate_common_mag_variances(ItemData& item) {
  if (item.data1[0] == 0x02) {
    item.data1[1] = 0x00;
    item.assign_mag_stats(ItemMagStats());

    // The original code (on PSO GC) assigns the mag color as 0x0E. We assign a random color instead.
    if (is_pre_v1(this->logic_version)) {
      item.data2[3] = 0x00;
    } else if (is_v1_or_v2(this->logic_version)) {
      item.data2[3] = this->rand_crypt->next() % 0x0E;
    } else {
      item.data2[3] = this->rand_crypt->next() % 0x12;
    }
  }
}

void ItemCreator::generate_common_weapon_variances(ItemData& item, uint8_t area) {
  item.clear();
  item.data1[0] = 0x00;

  auto pt = this->pt(area);
  uint8_t table_index = this->table_index_for_area(area);

  parray<uint8_t, 0x0D> weapon_type_prob_table;
  weapon_type_prob_table[0] = 0;
  memmove(weapon_type_prob_table.data() + 1, pt->base_weapon_type_prob_table.data(), 0x0C);

  for (size_t z = 1; z < 13; z++) {
    // Technically this should be `if (... < 0)`, but whatever
    if ((table_index + pt->subtype_base_table.at(z - 1)) & 0x80) {
      weapon_type_prob_table[z] = 0;
    }
  }

  this->log.info_f("Subtype table: {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}",
      weapon_type_prob_table[0], weapon_type_prob_table[1], weapon_type_prob_table[2], weapon_type_prob_table[3],
      weapon_type_prob_table[4], weapon_type_prob_table[5], weapon_type_prob_table[6], weapon_type_prob_table[7],
      weapon_type_prob_table[8], weapon_type_prob_table[9], weapon_type_prob_table[10], weapon_type_prob_table[11],
      weapon_type_prob_table[12]);

  item.data1[1] = this->get_rand_from_weighted_tables_1d(weapon_type_prob_table);
  if (item.data1[1] == 0) {
    this->log.info_f("00 chosen from subtype table; skipping item");
    item.clear();
  } else {
    int8_t subtype_base = pt->subtype_base_table.at(item.data1[1] - 1);
    uint8_t area_length = pt->subtype_area_length_table.at(item.data1[1] - 1);
    this->log.info_f("Subtype table yielded {:02X}; subtype base is {} with area length {}", item.data1[1], subtype_base, area_length);
    if (subtype_base < 0) {
      item.data1[2] = (table_index + subtype_base) / area_length;
      this->log.info_f("Resulting subtype: ({:02X} + {:02X}) / {:02X} = {:02X}", table_index, subtype_base, area_length, item.data1[2]);
      this->generate_common_weapon_grind(item, area, (table_index + subtype_base) - (item.data1[2] * area_length));
    } else {
      item.data1[2] = subtype_base + (table_index / area_length);
      this->log.info_f("Resulting subtype: {:02X} + ({:02X} / {:02X}) = {:02X}", subtype_base, table_index, area_length, item.data1[2]);
      this->generate_common_weapon_grind(item, area, table_index - (table_index / area_length) * area_length);
    }
    this->generate_common_weapon_bonuses(item, area);
    this->generate_common_weapon_special(item, area);
    this->set_item_unidentified_flag_if_not_challenge(item);
  }
}

void ItemCreator::generate_common_weapon_grind(ItemData& item, uint8_t area, uint8_t offset_within_subtype_range) {
  if (item.data1[0] == 0) {
    uint8_t offset = std::clamp<uint8_t>(offset_within_subtype_range, 0, 3);
    item.data1[3] = this->get_rand_from_weighted_tables_2d_vertical(this->pt(area)->grind_prob_table, offset);
    this->log.info_f("Generated grind {:02X} from offset within subtype range {:02X}", item.data1[3], offset_within_subtype_range);
  }
}

void ItemCreator::generate_common_weapon_special(ItemData& item, uint8_t area) {
  auto pt = this->pt(area);
  uint8_t table_index = this->table_index_for_area(area);
  if (item.data1[0] != 0) {
    return;
  }
  if (this->item_parameter_table->is_item_rare(item)) {
    this->log.info_f("Item is rare; skipping special generation");
    return;
  }
  uint8_t special_mult = pt->special_mult.at(table_index);
  if (special_mult == 0) {
    this->log.info_f("Special multiplier is zero for table index {:02X}; skipping special generation", table_index);
    return;
  }
  uint8_t det = this->rand_int(100);
  uint8_t prob = pt->special_percent.at(table_index);
  if (det >= prob) {
    this->log.info_f("Special not chosen ({:02X} > {:02X})", det, prob);
    return;
  }
  item.data1[4] = this->choose_weapon_special(special_mult * this->rand_float_0_1_from_crypt());
}

uint8_t ItemCreator::choose_weapon_special(uint8_t det) {
  if (det >= 4) {
    this->log.info_f("Special not chosen (det {:02X} >= 4)", det);
    return 0;
  }

  static const uint8_t maxes[4] = {8, 10, 11, 11};
  uint8_t det2 = this->rand_int(maxes[det]);
  this->log.info_f("Choosing special with det {:02X} and det2 {:02X}", det, det2);
  size_t index = 0;
  for (size_t z = 1; z < this->item_parameter_table->num_specials(); z++) {
    if (det + 1 == this->item_parameter_table->get_special_stars(z)) {
      if (index == det2) {
        this->log.info_f("Chose special {:02X}", z);
        return z;
      } else {
        index++;
      }
    }
  }
  this->log.info_f("No special was eligible");
  return 0;
}

void ItemCreator::generate_unit_stars_tables() {
  // Note: This part of the function was originally in a different function, since it had another callsite. Unlike the
  // original code, we generate these tables only once at construction time, so we've inlined the function here.

  size_t star_base_index;
  uint8_t num_units;
  switch (this->logic_version) {
    case Version::PC_PATCH:
    case Version::BB_PATCH:
    case Version::GC_EP3_NTE:
    case Version::GC_EP3:
      throw std::logic_error("ItemCreator cannot be created for Episode 3 games");
    case Version::DC_NTE:
      star_base_index = 0x124;
      num_units = 0x43;
      break;
    case Version::DC_11_2000:
    case Version::DC_V1:
      star_base_index = 0x128;
      num_units = 0x44;
      break;
    case Version::DC_V2:
    case Version::PC_NTE:
    case Version::PC_V2:
      star_base_index = 0x1D1;
      num_units = 0x44;
      break;
    case Version::GC_NTE:
      star_base_index = 0x251;
      num_units = 0x47;
      break;
    case Version::GC_V3:
    case Version::XB_V3:
      star_base_index = 0x2AF;
      num_units = 0x48;
      break;
    case Version::BB_V4:
      star_base_index = 0x37D;
      num_units = 0x64;
      break;
    default:
      throw std::logic_error("invalid game version");
  }

  for (auto& vec : this->unit_results_by_star_count) {
    vec.clear();
  }

  for (uint8_t z = 0; z < num_units; z++) {
    uint8_t stars = this->item_parameter_table->get_item_stars(z + star_base_index);
    if (z < 0x10) {
      // Units 00-0F can have modifiers; others can't
      this->unit_results_by_star_count.at(stars - 1).emplace_back(UnitResult{z, -2});
      this->unit_results_by_star_count.at(stars - 1).emplace_back(UnitResult{z, -1});
      this->unit_results_by_star_count.at(stars + 1).emplace_back(UnitResult{z, 1});
      this->unit_results_by_star_count.at(stars + 1).emplace_back(UnitResult{z, 2});
    }
    this->unit_results_by_star_count.at(stars).emplace_back(UnitResult{z, 0});
  }
}

void ItemCreator::generate_common_unit_variances(uint8_t stars, ItemData& item) {
  if (stars >= 0x0D) {
    return;
  }
  item.clear();

  const auto& results = this->unit_results_by_star_count.at(stars);
  if (results.empty()) {
    this->log.info_f("There are no available units with {} stars", stars);
    return;
  }

  const auto& result = (results.size() == 1) ? results[0] : results[this->rand_int(results.size())];
  item.data1[0] = 0x01;
  item.data1[1] = 0x03;
  item.data1[2] = result.unit;
  if (result.modifier) {
    const auto& def = this->item_parameter_table->get_unit(result.unit);
    item.set_unit_bonus(def.modifier_amount * result.modifier);
  }
  this->log.info_f("Generated unit {:02X} with modifier {}, from {} choices with {} stars",
      result.unit, result.modifier, results.size(), stars);
}

// Returns a weighted random result, indicating the chosen position in the weighted table. For example, an input table
// of 40 40 40 40 would be equally likely to return 0, 1, 2, or 3. An input table of 40 40 80 would return 2 50% of the
// time, and 0 or 1 each 25% of the time.
template <typename IntT>
IntT ItemCreator::get_rand_from_weighted_tables(const IntT* tables, size_t offset, size_t num_values, size_t stride) {
  uint64_t rand_max = 0;
  for (size_t x = 0; x != num_values; x++) {
    rand_max += tables[x * stride + offset];
  }
  if (rand_max == 0) {
    throw std::runtime_error("weighted table is empty");
  }

  uint32_t x = this->rand_int(rand_max);
  for (size_t z = 0; z < num_values; z++) {
    IntT table_value = tables[z * stride + offset];
    if (x < table_value) {
      return z;
    }
    x -= table_value;
  }
  throw std::logic_error("selector was not less than rand_max");
}

template <typename IntT, size_t X>
IntT ItemCreator::get_rand_from_weighted_tables_1d(const parray<IntT, X>& tables) {
  return ItemCreator::get_rand_from_weighted_tables<IntT>(tables.data(), 0, X, 1);
}

template <typename IntT, size_t X, size_t Y>
IntT ItemCreator::get_rand_from_weighted_tables_2d_vertical(const parray<parray<IntT, X>, Y>& tables, size_t offset) {
  return ItemCreator::get_rand_from_weighted_tables<IntT>(tables[0].data(), offset, Y, X);
}

std::vector<ItemData> ItemCreator::generate_armor_shop_contents(Episode episode, size_t player_level) {
  std::vector<ItemData> shop;
  this->generate_armor_shop_armors(shop, episode, player_level);
  this->generate_armor_shop_shields(shop, player_level);
  this->generate_armor_shop_units(shop, player_level);
  return shop;
}

size_t ItemCreator::get_table_index_for_armor_shop(
    size_t player_level) {
  if (player_level < 11) {
    return 0;
  } else if (player_level < 26) {
    return 1;
  } else if (player_level < 43) {
    return 2;
  } else if (player_level < 61) {
    return 3;
  } else {
    return 4;
  }
}

bool ItemCreator::shop_does_not_contain_duplicate_armor(
    const std::vector<ItemData>& shop, const ItemData& item) {
  for (const auto& shop_item : shop) {
    if ((shop_item.data1[0] == item.data1[0]) &&
        (shop_item.data1[1] == item.data1[1]) &&
        (shop_item.data1[2] == item.data1[2]) &&
        (shop_item.data1[5] == item.data1[5])) {
      return false;
    }
  }
  return true;
}

bool ItemCreator::shop_does_not_contain_duplicate_tech_disk(
    const std::vector<ItemData>& shop, const ItemData& item) {
  for (const auto& shop_item : shop) {
    if ((shop_item.data1[0] == item.data1[0]) &&
        (shop_item.data1[1] == item.data1[1]) &&
        (shop_item.data1[2] == item.data1[2]) &&
        (shop_item.data1[4] == item.data1[4])) {
      return false;
    }
  }
  return true;
}

bool ItemCreator::shop_does_not_contain_duplicate_or_too_many_similar_weapons(
    const std::vector<ItemData>& shop, const ItemData& item) {
  size_t similar_items = 0;
  for (const auto& shop_item : shop) {
    // Disallow exact matches
    if (shop_item == item) {
      return false;
    }

    if ((shop_item.data1[0] == item.data1[0]) && (shop_item.data1[1] == item.data1[1])) {
      similar_items++;
      if (similar_items >= 2) {
        return false;
      }
    }
  }
  return true;
}

bool ItemCreator::shop_does_not_contain_duplicate_item_by_data1_0_1_2(
    const std::vector<ItemData>& shop, const ItemData& item) {
  for (const auto& shop_item : shop) {
    if ((shop_item.data1[0] == item.data1[0]) &&
        (shop_item.data1[1] == item.data1[1]) &&
        (shop_item.data1[2] == item.data1[2])) {
      return false;
    }
  }
  return true;
}

void ItemCreator::generate_armor_shop_armors(std::vector<ItemData>& shop, Episode episode, size_t player_level) {
  size_t num_items;
  if (player_level < 11) {
    num_items = 4;
  } else if (player_level < 26) {
    num_items = 6;
  } else {
    // Note: The original code has another case here that can result in 8 items,  but that overflows BB's shop item
    // list command, so we omit it here.
    num_items = 7;
  }
  size_t table_index = this->get_table_index_for_armor_shop(player_level);

  ProbabilityTable<uint8_t, 100> pt{this->armor_random_set->armor_table.at(table_index)};
  pt.shuffle(this->rand_crypt);

  for (size_t items_generated = 0; items_generated < num_items;) {
    ItemData item;
    item.data1[0] = 1;
    item.data1[1] = 1;
    item.data1[2] = pt.pop();

    if ((this->difficulty == Difficulty::ULTIMATE) && (player_level > 99)) {
      if (player_level > 150) {
        item.data1[2] += 3;
      } else if (player_level >= 100) {
        item.data1[2] += 2;
      }
    }

    this->generate_common_armor_slot_count(item, episode);
    if (this->shop_does_not_contain_duplicate_armor(shop, item)) {
      shop.emplace_back(std::move(item));
      items_generated++;
    }
  }
}

void ItemCreator::generate_armor_shop_shields(std::vector<ItemData>& shop, size_t player_level) {
  size_t num_items;
  if (player_level < 11) {
    num_items = 4;
  } else if (player_level < 26) {
    num_items = 5;
  } else if (player_level < 42) {
    num_items = 6;
  } else {
    num_items = 7;
  }
  size_t table_index = this->get_table_index_for_armor_shop(player_level);

  ProbabilityTable<uint8_t, 100> pt{this->armor_random_set->shield_table.at(table_index)};
  pt.shuffle(this->rand_crypt);

  for (size_t items_generated = 0; items_generated < num_items;) {
    ItemData item;
    item.data1[0] = 1;
    item.data1[1] = 2;
    item.data1[2] = pt.pop();

    if ((this->difficulty == Difficulty::ULTIMATE) && (player_level > 99)) {
      if (player_level > 150) {
        item.data1[2] += 3;
      } else if (player_level >= 100) {
        item.data1[2] += 2;
      }
    }

    if (this->shop_does_not_contain_duplicate_item_by_data1_0_1_2(shop, item)) {
      shop.emplace_back(std::move(item));
      items_generated++;
    }
  }
}

void ItemCreator::generate_armor_shop_units(std::vector<ItemData>& shop, size_t player_level) {
  size_t num_items;
  if (player_level < 11) {
    return; // num_items = 0
  } else if (player_level < 26) {
    num_items = 3;
  } else if (player_level < 43) {
    num_items = 5;
  } else {
    num_items = 6;
  }
  size_t table_index = this->get_table_index_for_armor_shop(player_level);

  ProbabilityTable<uint8_t, 100> pt{this->armor_random_set->unit_table.at(table_index)};
  pt.shuffle(this->rand_crypt);

  for (size_t items_generated = 0; items_generated < num_items;) {
    ItemData item;
    item.data1[0] = 1;
    item.data1[1] = 3;
    item.data1[2] = pt.pop();
    if (this->shop_does_not_contain_duplicate_item_by_data1_0_1_2(shop, item)) {
      shop.emplace_back(std::move(item));
      items_generated++;
    }
  }
}

std::vector<ItemData> ItemCreator::generate_tool_shop_contents(size_t player_level) {
  std::vector<ItemData> shop;
  this->generate_common_tool_shop_recovery_items(shop, player_level);
  this->generate_rare_tool_shop_recovery_items(shop, player_level);
  this->generate_tool_shop_tech_disks(shop, player_level);
  sort(shop.begin(), shop.end(), ItemData::compare_for_sort);
  return shop;
}

size_t ItemCreator::get_table_index_for_tool_shop(size_t player_level) {
  if (player_level < 11) {
    return 0;
  } else if (player_level < 26) {
    return 1;
  } else if (player_level < 43) {
    return 2;
  } else if (player_level < 61) {
    return 3;
  } else {
    return 4;
  }
}

void ItemCreator::generate_common_tool_shop_recovery_items(std::vector<ItemData>& shop, size_t player_level) {
  size_t table_index;
  if (player_level < 11) {
    table_index = 0;
  } else if (player_level < 26) {
    table_index = 1;
  } else if (player_level < 45) {
    table_index = 2;
  } else if (player_level < 61) {
    table_index = 3;
  } else if (player_level < 100) {
    table_index = 4;
  } else {
    table_index = 5;
  }

  for (const auto& entry : this->tool_random_set->common_recovery_table.at(table_index)) {
    if (entry == 0x0F) {
      continue;
    }

    auto& item = shop.emplace_back();
    item.data1[0] = 3;
    item.data1[1] = ToolShopRandomSet::item_defs[entry].first;
    item.data1[2] = ToolShopRandomSet::item_defs[entry].second;
  }
}

void ItemCreator::generate_rare_tool_shop_recovery_items(std::vector<ItemData>& shop, size_t player_level) {
  if (player_level < 11) {
    return;
  }
  static constexpr size_t num_items = 2;

  size_t table_index = this->get_table_index_for_tool_shop(player_level);
  ProbabilityTable<uint8_t, 100> pt{this->tool_random_set->rare_recovery_table.at(table_index)};
  pt.shuffle(this->rand_crypt);

  size_t effective_num_items = num_items;
  size_t items_generated = 0;
  while (items_generated < effective_num_items) {
    uint8_t type = pt.pop();
    if (type == 0x0F) {
      if (effective_num_items == num_items) {
        effective_num_items--;
      }
    } else {
      ItemData item;
      item.data1[0] = 3;
      item.data1[1] = ToolShopRandomSet::item_defs[type].first;
      item.data1[2] = ToolShopRandomSet::item_defs[type].second;
      if (this->shop_does_not_contain_duplicate_item_by_data1_0_1_2(shop, item)) {
        shop.emplace_back(std::move(item));
        items_generated++;
      }
    }
  }
}

void ItemCreator::generate_tool_shop_tech_disks(std::vector<ItemData>& shop, size_t player_level) {
  size_t num_items;
  if (player_level < 11) {
    num_items = 4;
  } else if (player_level < 43) {
    num_items = 5;
  } else {
    num_items = 7;
  }

  size_t table_index = this->get_table_index_for_tool_shop(player_level);
  ProbabilityTable<uint8_t, 100> pt{this->tool_random_set->tech_disk_table.at(table_index)};
  pt.shuffle(this->rand_crypt);

  size_t items_generated = 0;
  while (items_generated < num_items) {
    uint8_t tech_num_index = pt.pop();
    ItemData item;
    item.data1[0] = 3;
    item.data1[1] = 2;
    item.data1[4] = ToolShopRandomSet::tech_num_map.at(tech_num_index);
    this->choose_tech_disk_level_for_tool_shop(item, player_level, tech_num_index);
    if (this->shop_does_not_contain_duplicate_tech_disk(shop, item)) {
      shop.emplace_back(std::move(item));
      items_generated++;
    }
  }
}

void ItemCreator::choose_tech_disk_level_for_tool_shop(ItemData& item, size_t player_level, uint8_t tech_num_index) {
  size_t table_index = this->get_table_index_for_tool_shop(player_level);
  auto table = this->tool_random_set->tech_disk_level_table.at(table_index);
  if (tech_num_index >= table.size()) {
    throw std::runtime_error("technique number out of range");
  }
  const auto& e = table[tech_num_index];

  switch (e.mode) {
    case ToolShopRandomSet::TechDiskLevelEntry::Mode::LEVEL_1:
      item.data1[2] = 0;
      break;
    case ToolShopRandomSet::TechDiskLevelEntry::Mode::PLAYER_LEVEL_DIVISOR:
      item.data1[2] = std::clamp<ssize_t>(
          (std::min<size_t>(player_level, 99) / e.player_level_divisor_or_min_level) - 1, 0, 14);
      break;
    case ToolShopRandomSet::TechDiskLevelEntry::Mode::RANDOM_IN_RANGE: {
      // Note: This logic does not give a uniform distribution - if the minimum level is not zero (level 1), then the
      // minimum level is more likely than all the other levels. This behavior matches the client's logic, though it's
      // unclear if this nonuniformity was intentional.
      int16_t min_level = std::max<int16_t>(e.player_level_divisor_or_min_level - 1, 0);
      item.data1[2] = std::clamp<int16_t>(this->rand_int(e.max_level), min_level, 14);
      break;
    }
    default:
      throw std::logic_error("invalid tech disk level mode");
  }
}

std::vector<ItemData> ItemCreator::generate_weapon_shop_contents(size_t player_level) {
  size_t num_items;
  if (player_level < 11) {
    num_items = 10;
  } else if (player_level < 43) {
    num_items = 12;
  } else {
    num_items = 16;
  }

  size_t table_index;
  if (this->difficulty == Difficulty::ULTIMATE) {
    if (player_level < 11) {
      table_index = 0;
    } else if (player_level < 26) {
      table_index = 1;
    } else if (player_level < 43) {
      table_index = 2;
    } else if (player_level < 61) {
      table_index = 3;
    } else if (player_level < 100) {
      table_index = 4;
    } else if (player_level < 151) {
      table_index = 5;
    } else {
      table_index = 6;
    }
  } else {
    if (player_level < 11) {
      table_index = 0;
    } else if (player_level < 26) {
      table_index = 1;
    } else if (player_level < 43) {
      table_index = 2;
    } else if (player_level < 61) {
      table_index = 3;
    } else {
      table_index = 4;
    }
  }

  ProbabilityTable<uint8_t, 100> pt{this->weapon_random_set->weapon_type_weight_tables.at(table_index).at(section_id)};
  pt.shuffle(this->rand_crypt);

  std::vector<ItemData> shop;
  while (shop.size() < num_items) {
    ItemData item;

    const std::pair<uint8_t, uint8_t>* def;
    uint8_t which = pt.pop();
    if (which == 0x39) {
      def = &WeaponShopRandomSet::type_defs_39.at(this->section_id);
    } else if (which == 0x3A) {
      def = &WeaponShopRandomSet::type_defs_3A.at(this->section_id);
    } else {
      def = &WeaponShopRandomSet::type_defs.at(which);
    }
    item.data1[0] = 0;
    item.data1[1] = def->first;
    item.data1[2] = def->second;

    this->generate_weapon_shop_item_grind(item, player_level);
    this->generate_weapon_shop_item_special(item, player_level);
    this->generate_weapon_shop_item_bonus1(item, player_level);
    this->generate_weapon_shop_item_bonus2(item, player_level);
    item.data1[10] = 0;
    item.data1[11] = 0;

    if (this->shop_does_not_contain_duplicate_or_too_many_similar_weapons(shop, item)) {
      shop.emplace_back(std::move(item));
    }
  }

  sort(shop.begin(), shop.end(), ItemData::compare_for_sort);
  return shop;
}

void ItemCreator::generate_weapon_shop_item_grind(ItemData& item, size_t player_level) {
  size_t table_index;
  if (player_level < 4) {
    table_index = 0;
  } else if (player_level < 11) {
    table_index = 1;
  } else if (player_level < 26) {
    table_index = 2;
  } else if (player_level < 41) {
    table_index = 3;
  } else if (player_level < 56) {
    table_index = 4;
  } else {
    table_index = 5;
  }

  uint8_t favored_weapon = TekkerAdjustmentSet::favored_weapon_type_for_section_id(this->section_id);
  bool is_favored = (favored_weapon != 0xFF) && (item.data1[1] == favored_weapon);
  const auto& range = is_favored
      ? this->weapon_random_set->favored_grind_range_table.at(table_index)
      : this->weapon_random_set->default_grind_range_table.at(table_index);

  const auto& weapon_def = this->item_parameter_table->get_weapon(item.data1[1], item.data1[2]);
  item.data1[3] = std::clamp<uint8_t>(this->rand_int(range.max + 1), range.min, weapon_def.max_grind);
}

void ItemCreator::generate_weapon_shop_item_special(ItemData& item, size_t player_level) {

  size_t table_index;
  if (player_level < 11) {
    table_index = 0;
  } else if (player_level < 18) {
    table_index = 1;
  } else if (player_level < 26) {
    table_index = 2;
  } else if (player_level < 36) {
    table_index = 3;
  } else if (player_level < 46) {
    table_index = 4;
  } else if (player_level < 61) {
    table_index = 5;
  } else if (player_level < 76) {
    table_index = 6;
  } else {
    table_index = 7;
  }

  ProbabilityTable<uint32_t, 100> pt{this->weapon_random_set->special_mode_table.at(table_index)};
  pt.shuffle(this->rand_crypt);

  // Note: The original code shuffles pt and then pops a single value from it. For simplicity, we just sample a single
  // value instead.
  switch (pt.sample(this->rand_crypt)) {
    case 0:
      item.data1[4] = 0;
      break;
    case 1:
      item.data1[4] = this->choose_weapon_special(0);
      break;
    case 2:
      item.data1[4] = this->choose_weapon_special(1);
      break;
    default:
      throw std::runtime_error("invalid special mode");
  }
}

void ItemCreator::generate_weapon_shop_item_bonus1(ItemData& item, size_t player_level) {
  size_t table_index;
  if (player_level < 4) {
    table_index = 0;
  } else if (player_level < 11) {
    table_index = 1;
  } else if (player_level < 18) {
    table_index = 2;
  } else if (player_level < 26) {
    table_index = 3;
  } else if (player_level < 36) {
    table_index = 4;
  } else if (player_level < 46) {
    table_index = 5;
  } else if (player_level < 61) {
    table_index = 6;
  } else if (player_level < 76) {
    table_index = 7;
  } else {
    table_index = 8;
  }

  ProbabilityTable<uint32_t, 100> pt{this->weapon_random_set->bonus_type_table1.at(table_index)};
  pt.shuffle(this->rand_crypt);

  // Note: The original code shuffles pt and then pops a single value from it. For simplicity, we just sample a single
  // value instead.
  item.data1[6] = pt.sample(this->rand_crypt);
  if (item.data1[6] == 0) {
    item.data1[7] = 0;
  } else {
    const auto& range = this->weapon_random_set->bonus_range_table1.at(table_index);
    item.data1[7] = WeaponShopRandomSet::bonus_values.at(std::max<size_t>(this->rand_int(range.max + 1), range.min));
  }
}

void ItemCreator::generate_weapon_shop_item_bonus2(ItemData& item, size_t player_level) {
  size_t table_index;
  if (player_level < 6) {
    table_index = 0;
  } else if (player_level < 11) {
    table_index = 1;
  } else if (player_level < 18) {
    table_index = 2;
  } else if (player_level < 26) {
    table_index = 3;
  } else if (player_level < 36) {
    table_index = 4;
  } else if (player_level < 46) {
    table_index = 5;
  } else if (player_level < 61) {
    table_index = 6;
  } else if (player_level < 76) {
    table_index = 7;
  } else {
    table_index = 8;
  }

  ProbabilityTable<uint32_t, 100> pt{this->weapon_random_set->bonus_type_table2.at(table_index)};
  pt.shuffle(this->rand_crypt);

  do {
    item.data1[8] = pt.pop();
  } while ((item.data1[8] != 0) && (item.data1[8] == item.data1[6]));

  if (item.data1[8] == 0) {
    item.data1[9] = 0;
  } else {
    const auto& range = this->weapon_random_set->bonus_range_table2.at(table_index);
    item.data1[9] = WeaponShopRandomSet::bonus_values.at(std::max<size_t>(this->rand_int(range.max + 1), range.min));
  }
}

ItemCreator::DropResult ItemCreator::on_specialized_box_item_drop(
    uint8_t area, float param3, uint32_t param4, uint32_t param5, uint32_t param6) {
  DropResult res;
  res.item = this->base_item_for_specialized_box(param4, param5, param6);
  if (param3 == 0.0f) {
    uint16_t type = res.item.data1w[0];
    res.item.clear();
    res.item.data1w[0] = type;
    this->generate_common_item_variances(res.item, area);
  }
  return res;
}

ItemData ItemCreator::base_item_for_specialized_box(uint32_t param4, uint32_t param5, uint32_t param6) const {
  ItemData item;
  item.data1[0] = (param4 >> 0x18) & 0x0F;
  item.data1[1] = (param4 >> 0x10) + ((item.data1[0] == 0x00) || (item.data1[0] == 0x01));
  item.data1[2] = param4 >> 8;

  switch (item.data1[0]) {
    case 0x00:
      item.data1[3] = (param5 >> 0x18) & 0xFF;
      item.data1[4] = param4 & 0xFF;
      item.data1[6] = (param5 >> 8) & 0xFF;
      item.data1[7] = param5 & 0xFF;
      item.data1[8] = (param6 >> 0x18) & 0xFF;
      item.data1[9] = (param6 >> 0x10) & 0xFF;
      item.data1[10] = (param6 >> 8) & 0xFF;
      item.data1[11] = param6 & 0xFF;
      break;
    case 0x01:
      item.data1[3] = (param5 >> 0x18) & 0xFF;
      item.data1[4] = (param5 >> 0x10) & 0xFF;
      item.data1[5] = param4 & 0xFF;
      break;
    case 0x02:
      item.assign_mag_stats(ItemMagStats());
      break;
    case 0x03:
      if (item.data1[1] == 0x02) {
        item.data1[4] = param4 & 0xFF;
      }
      item.set_tool_item_amount(*this->stack_limits, 1);
      break;
    case 0x04:
      item.data2d = ((param5 >> 0x10) & 0xFFFF) * 10;
      break;
    default:
      throw std::runtime_error("invalid item class");
  }

  return item;
}

ssize_t ItemCreator::apply_tekker_deltas(ItemData& item, uint8_t section_id) {
  if (item.data1[0] != 0) {
    throw std::runtime_error("tekker deltas can only be applied to weapons");
  }

  bool favored = (item.data1[1] == TekkerAdjustmentSet::favored_weapon_type_for_section_id(section_id));
  ssize_t luck = 0;

  this->log.info_f("Applying tekker deltas for {} weapon", favored ? "favored" : "non-favored");

  auto sample_prob_table = [this](const TekkerAdjustmentSet::Table& table) -> int8_t {
    size_t sample = this->rand_crypt->next() % table.total;
    for (const auto& [k, v] : table.probs) {
      if (sample < v) {
        return k;
      }
      sample -= v;
    }
    throw std::logic_error("Table total is incorrect");
  };

  // Adjust the weapon's special
  {
    int8_t delta = sample_prob_table(favored
            ? this->tekker_adjustment_set->favored_special_delta_table[section_id]
            : this->tekker_adjustment_set->default_special_delta_table[section_id]);
    this->log.info_f("(Special) Delta {} chosen", delta);
    for (; delta != 0; delta += (delta < 0) - (0 < delta)) {
      try {
        // Note: The original code checks specifically for -1 and +1 here and only increments or decrements the special
        // by 1, and the data files only include delta_indexes 4, 5, and 6 (which correspond to -1, 0, and 1). But we
        // want to support other levels of delta indexes, so we simply add delta instead. When using the original
        // JudgeItem.rel file, the behavior should be the same, but this logic feels more correct.
        uint8_t new_special = item.data1[4] + delta;
        if (this->item_parameter_table->get_special(item.data1[4]).type ==
            this->item_parameter_table->get_special(new_special).type) {
          item.data1[4] = new_special;
          this->log.info_f("(Special) Delta {} applied", delta);
          break;
        } else {
          this->log.info_f("(Special) Delta {} canceled because it would change special category", delta);
        }
      } catch (const std::out_of_range&) {
        // Invalid special number passed to get_special; treat it as if delta == 0
      }
    }
    luck += this->tekker_adjustment_set->special_luck_table.at(delta);
    this->log.info_f("(Special) Luck is now {}", luck);
  }

  // Adjust the weapon's grind if it's not rare
  if (!this->item_parameter_table->is_item_rare(item)) {
    const auto& weapon_def = this->item_parameter_table->get_weapon(item.data1[1], item.data1[2]);
    int8_t delta = sample_prob_table(favored
            ? this->tekker_adjustment_set->favored_grind_delta_table[section_id]
            : this->tekker_adjustment_set->default_grind_delta_table[section_id]);
    this->log.info_f("(Grind) Delta {} chosen", delta);
    int16_t new_grind = static_cast<int16_t>(item.data1[3]) + static_cast<int16_t>(delta);
    item.data1[3] = std::clamp<int16_t>(new_grind, 0, weapon_def.max_grind);
    luck += this->tekker_adjustment_set->grind_luck_table.at(delta);
    this->log.info_f("(Grind) Luck is now {}", luck);
  } else {
    this->log.info_f("(Grind) Item is rare; skipping grind adjustment");
  }

  // Adjust the weapon's bonuses
  {
    int8_t delta = sample_prob_table(favored
            ? this->tekker_adjustment_set->favored_bonus_delta_table[section_id]
            : this->tekker_adjustment_set->default_bonus_delta_table[section_id]);
    this->log.info_f("(Bonuses) Delta {} chosen", delta);
    // Note: The original code doesn't check if there's actually a bonus in each slot before incrementing the values.
    // Presumably there's a check later that will clear any invalid bonuses, but we don't have such a check, so we need
    // to check here if each bonus is actually present.
    for (size_t z = 6; z <= 10; z += 2) {
      if (item.data1[z] >= 1 && item.data1[z] <= 5) {
        item.data1[z + 1] = std::min<int8_t>(item.data1[z + 1] + delta, 100);
      }
    }
    luck += this->tekker_adjustment_set->bonus_luck_table.at(delta);
    this->log.info_f("(Bonuses) Luck is now {}", luck);
  }

  return luck;
}