#include "ItemNameIndex.hh"

#include <algorithm>

#include "StaticGameData.hh"

ItemNameIndex::ItemNameIndex(
    std::shared_ptr<const ItemParameterTable> item_parameter_table,
    std::shared_ptr<const ItemData::StackLimits> limits,
    const std::vector<std::string>& name_coll)
    : item_parameter_table(item_parameter_table),
      limits(limits) {

  for (uint32_t primary_identifier : item_parameter_table->compute_all_valid_primary_identifiers()) {
    // 00000000 is a valid primary identifier but not a valid weapon; skip it
    if (primary_identifier == 0x00000000) {
      continue;
    }

    const std::string* name = nullptr;
    bool is_es_weapon = false;
    try {
      ItemData item = ItemData::from_primary_identifier(*this->limits, primary_identifier);
      is_es_weapon = item.is_s_rank_weapon();
      name = &name_coll.at(item_parameter_table->get_item_id(item));
    } catch (const std::out_of_range&) {
    }

    if (name) {
      auto meta = std::make_shared<ItemMetadata>();
      meta->primary_identifier = primary_identifier;
      meta->name = *name;
      this->primary_identifier_index.emplace(meta->primary_identifier, meta);
      this->name_index.emplace(phosg::tolower(meta->name), meta);
      if (is_es_weapon && ((primary_identifier & 0x0000FFFF) == 0x00000000)) {
        this->es_name_index.emplace(phosg::tolower(meta->name), meta);
      }
    }
  }
}

static std::string s_rank_name_characters("\0ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_", 0x20);

// clang-format off
static const std::array<const char*, 0x29> name_for_weapon_special = {
    nullptr,
    "Draw",      // Type: 0001, amount: 0005
    "Drain",     // Type: 0001, amount: 0009
    "Fill",      // Type: 0001, amount: 000D
    "Gush",      // Type: 0001, amount: 0011
    "Heart",     // Type: 0002, amount: 0003
    "Mind",      // Type: 0002, amount: 0004
    "Soul",      // Type: 0002, amount: 0005
    "Geist",     // Type: 0002, amount: 0006
    "Master\'s", // Type: 0003, amount: 0008
    "Lord\'s",   // Type: 0003, amount: 000A
    "King\'s",   // Type: 0003, amount: 000C
    "Charge",    // Type: 0004, amount: 0064
    "Spirit",    // Type: 0005, amount: 0064
    "Berserk",   // Type: 0006, amount: 0064
    "Ice",       // Type: 0007, amount: 0020
    "Frost",     // Type: 0007, amount: 0030
    "Freeze",    // Type: 0007, amount: 0040
    "Blizzard",  // Type: 0007, amount: 0050
    "Bind",      // Type: 0008, amount: 0020
    "Hold",      // Type: 0008, amount: 0030
    "Seize",     // Type: 0008, amount: 0040
    "Arrest",    // Type: 0008, amount: 0050
    "Heat",      // Type: 0009, amount: 0001
    "Fire",      // Type: 0009, amount: 0002
    "Flame",     // Type: 0009, amount: 0003
    "Burning",   // Type: 0009, amount: 0004
    "Shock",     // Type: 000A, amount: 0001
    "Thunder",   // Type: 000A, amount: 0002
    "Storm",     // Type: 000A, amount: 0003
    "Tempest",   // Type: 000A, amount: 0004
    "Dim",       // Type: 000B, amount: 0030
    "Shadow",    // Type: 000B, amount: 0042
    "Dark",      // Type: 000B, amount: 004E
    "Hell",      // Type: 000B, amount: 005D
    "Panic",     // Type: 000C, amount: 001D
    "Riot",      // Type: 000C, amount: 002C
    "Havoc",     // Type: 000C, amount: 003C
    "Chaos",     // Type: 000C, amount: 004C
    "Devil\'s",  // Type: 000D, amount: 0032
    "Demon\'s",  // Type: 000D, amount: 0019
};
// clang-format on

const std::array<const char*, 0x11> name_for_s_rank_special = {
    nullptr,
    "Jellen",
    "Zalure",
    "HP-Revival",
    "TP-Revival",
    "Burning",
    "Tempest",
    "Blizzard",
    "Arrest",
    "Chaos",
    "Hell",
    "Spirit",
    "Berserk",
    "Demon\'s",
    "Gush",
    "Geist",
    "King\'s",
};

std::string ItemNameIndex::describe_item(const ItemData& item, uint8_t flags) const {
  bool include_color_escapes = flags & ItemNameIndex::Flag::INCLUDE_PSO_COLOR_ESCAPES;
  bool name_only = flags & ItemNameIndex::Flag::NAME_ONLY;

  if (item.data1[0] == 0x04) {
    return std::format("{}{} Meseta", include_color_escapes ? "$C7" : "", item.data2d);
  }

  std::vector<std::string> ret_tokens;

  // For weapons, specials appear before the weapon name
  bool is_unidentified = false;
  if ((item.data1[0] == 0x00) && (item.data1[4] != 0x00) && !item.is_s_rank_weapon()) {
    is_unidentified = item.data1[4] & 0x80;
    uint8_t special_id = item.data1[4] & 0x3F;
    if (!name_only) {
      if (item.data1[4] & 0x40) {
        ret_tokens.emplace_back("Wrapped");
      }
      if (is_unidentified) {
        ret_tokens.emplace_back("????");
      }
    }
    if (special_id) {
      try {
        ret_tokens.emplace_back(name_for_weapon_special.at(special_id));
      } catch (const std::out_of_range&) {
        ret_tokens.emplace_back(std::format("!SP:{:02X}", special_id));
      }
    }
  }
  if (!name_only && (item.data1[0] == 0x00) && (item.data1[2] != 0x00) && item.is_s_rank_weapon()) {
    try {
      ret_tokens.emplace_back(name_for_s_rank_special.at(item.data1[2]));
    } catch (const std::out_of_range&) {
      ret_tokens.emplace_back(std::format("!SSP:{:02X}", item.data1[2]));
    }
  }

  // Armors, shields, and units (0x01) can be wrapped, as can mags (0x02) and non-stackable tools (0x03). However, each
  // of these item classes has its flags in a different location.
  if (!name_only &&
      (((item.data1[0] == 0x01) && (item.data1[4] & 0x40)) ||
          ((item.data1[0] == 0x02) && (item.data2[2] & 0x40)) ||
          ((item.data1[0] == 0x03) && !item.is_stackable(*this->limits) && (item.data1[3] & 0x40)))) {
    ret_tokens.emplace_back("Wrapped");
  }

  // Add the item name
  uint32_t primary_identifier = item.primary_identifier();
  if ((primary_identifier & 0xFFFF0000) == 0x03020000) {
    std::string technique_name;
    try {
      technique_name = tech_id_to_name.at(item.data1[4]);
      technique_name[0] = toupper(technique_name[0]);
    } catch (const std::out_of_range&) {
      technique_name = std::format("!TD:{:02X}", item.data1[4]);
    }
    // Hide the level for Reverser and Ryuker, unless the level isn't 1
    if ((item.data1[2] == 0) && ((item.data1[4] == 0x0E) || (item.data1[4] == 0x11))) {
      ret_tokens.emplace_back(std::format("Disk:{}", technique_name));
    } else {
      ret_tokens.emplace_back(std::format("Disk:{} Lv.{}", technique_name, item.data1[2] + 1));
    }
  } else {
    try {
      auto meta = this->primary_identifier_index.at(primary_identifier);
      ret_tokens.emplace_back(meta->name);
    } catch (const std::out_of_range&) {
      ret_tokens.emplace_back(std::format("!ID:{:08X}", primary_identifier));
    }
  }

  if (item.data1[0] == 0x00) {
    // For weapons, add the grind and bonuses, or S-rank name if applicable
    if (!name_only && item.data1[3] > 0) {
      ret_tokens.emplace_back(std::format("+{}", item.data1[3]));
    }

    if (item.is_s_rank_weapon()) {
      // S-rank weapons have names instead of percent bonuses. The name is encoded as 9 5-bit characters in the bytes
      // where the bonuses usually go. The first character does not appear when the name is rendered; instead, it's
      // used to determine if the weapon type name should appear or not. Unlike the client, we check the first
      // character directly and don't bother decoding it.
      uint16_t be_data1w3 = phosg::bswap16(item.data1w[3]);
      uint16_t be_data1w4 = phosg::bswap16(item.data1w[4]);
      uint16_t be_data1w5 = phosg::bswap16(item.data1w[5]);
      bool hide_type_name = ((be_data1w3 & 0x7C00) == 0x0800);
      uint8_t char_indexes[8] = {
          static_cast<uint8_t>((be_data1w3 >> 5) & 0x1F),
          static_cast<uint8_t>(be_data1w3 & 0x1F),
          static_cast<uint8_t>((be_data1w4 >> 10) & 0x1F),
          static_cast<uint8_t>((be_data1w4 >> 5) & 0x1F),
          static_cast<uint8_t>(be_data1w4 & 0x1F),
          static_cast<uint8_t>((be_data1w5 >> 10) & 0x1F),
          static_cast<uint8_t>((be_data1w5 >> 5) & 0x1F),
          static_cast<uint8_t>(be_data1w5 & 0x1F),
      };

      std::string name;
      for (size_t x = 0; x < 8; x++) {
        char ch = s_rank_name_characters.at(char_indexes[x]);
        if (ch == 0) {
          break;
        }
        name += ch;
      }
      if (!name.empty()) {
        if (hide_type_name) {
          ret_tokens.emplace_back("\"" + name + "\"");
        } else {
          ret_tokens.emplace_back("(" + name + ")");
        }
      }

    } else if (!name_only) { // Not S-rank (extended name bits not set)
      size_t num_bonuses = 3;

      if (item.data1[10] & 0x80) {
        ret_tokens.emplace_back(std::format("K:{}", item.get_kill_count()));
        num_bonuses = 2;
      }

      parray<int8_t, 5> bonuses(0);
      for (size_t x = 0; x < num_bonuses; x++) {
        uint8_t which = item.data1[6 + 2 * x];
        uint8_t value = item.data1[7 + 2 * x];
        if (which == 0) {
          continue;
        }
        if (which > 5) {
          ret_tokens.emplace_back(std::format("!PC:{:02X}{:02X}", which, value));
        } else {
          bonuses[which - 1] = value;
        }
      }
      if (!bonuses.is_filled_with(0)) {
        bool should_include_hit = (bonuses[4] != 0);
        bool should_highlight_hit = include_color_escapes && (bonuses[4] > 0);
        const char* color_prefix = include_color_escapes ? "$C7" : "";
        if (should_include_hit) {
          ret_tokens.emplace_back(std::format("{}{}/{}/{}/{}/{}{}",
              color_prefix, bonuses[0], bonuses[1], bonuses[2], bonuses[3],
              (should_highlight_hit ? "$C6" : ""), bonuses[4]));
        } else {
          ret_tokens.emplace_back(std::format("{}{}/{}/{}/{}",
              color_prefix, bonuses[0], bonuses[1], bonuses[2], bonuses[3]));
        }
      }
    }

  } else if (item.data1[0] == 0x01) {
    // For armors, add the slots, unit modifiers, and/or DEF/EVP bonuses
    if (item.data1[1] == 0x03) { // Units
      int16_t modifier = item.data1w[3];
      if (modifier == 1 || modifier == 2) {
        ret_tokens.back().append("+");
      } else if (modifier >= 3) {
        ret_tokens.back().append("++");
      } else if (modifier == -1 || modifier == -2) {
        ret_tokens.back().append("-");
      } else if (modifier <= -3) {
        ret_tokens.back().append("--");
      } else if (modifier != 0) {
        ret_tokens.emplace_back(std::format("!MD:{:04X}", modifier));
      }

      if (!name_only && (item.data1[10] & 0x80)) {
        ret_tokens.emplace_back(std::format("K:{}", item.get_kill_count()));
      }

    } else if (!name_only) { // Armor/shields
      if (item.data1[5] > 0) {
        if (item.data1[5] == 1) {
          ret_tokens.emplace_back("(1 slot)");
        } else {
          ret_tokens.emplace_back(std::format("({} slots)", item.data1[5]));
        }
      }
      if (item.data1w[3] != 0) {
        ret_tokens.emplace_back(std::format("+{}DEF",
            static_cast<int16_t>(item.data1w[3])));
      }
      if (item.data1w[4] != 0) {
        ret_tokens.emplace_back(std::format("+{}EVP",
            static_cast<int16_t>(item.data1w[4])));
      }
    }

  } else if (!name_only && (item.data1[0] == 0x02)) {
    // For mags, add tons of info
    ret_tokens.emplace_back(std::format("LV{}", item.data1[2]));

    uint16_t def = item.data1w[2];
    uint16_t pow = item.data1w[3];
    uint16_t dex = item.data1w[4];
    uint16_t mind = item.data1w[5];
    auto format_stat = +[](uint16_t stat) -> std::string {
      uint16_t level = stat / 100;
      uint8_t partial = stat % 100;
      if (partial == 0) {
        return std::format("{}", level);
      } else if (partial % 10 == 0) {
        return std::format("{}.{}", level, static_cast<uint8_t>(partial / 10));
      } else {
        return std::format("{}.{:02}", level, partial);
      }
    };
    ret_tokens.emplace_back(format_stat(def) + "/" + format_stat(pow) + "/" + format_stat(dex) + "/" + format_stat(mind));
    ret_tokens.emplace_back(std::format("{}{}", item.data2[0], include_color_escapes ? "%%" : "%"));
    ret_tokens.emplace_back(std::format("{}IQ", item.data2[1]));

    uint8_t flags = item.data2[2];
    if (flags & 7) {
      static const std::vector<const char*> pb_shortnames = {"F", "E", "G", "P", "L", "M&Y", "MG", "GR"};

      const char* pb_names[3] = {nullptr, nullptr, nullptr};
      uint8_t left_pb = item.mag_photon_blast_for_slot(2);
      uint8_t center_pb = item.mag_photon_blast_for_slot(0);
      uint8_t right_pb = item.mag_photon_blast_for_slot(1);
      if (left_pb != 0xFF) {
        pb_names[0] = pb_shortnames[left_pb];
      }
      if (center_pb != 0xFF) {
        pb_names[1] = pb_shortnames[center_pb];
      }
      if (right_pb != 0xFF) {
        pb_names[2] = pb_shortnames[right_pb];
      }

      std::string token = "PB:";
      for (size_t x = 0; x < 3; x++) {
        if (pb_names[x] == nullptr) {
          continue;
        }
        if (token.size() > 3) {
          token += ',';
        }
        token += pb_names[x];
      }
      ret_tokens.emplace_back(std::move(token));
    }

    try {
      ret_tokens.emplace_back(std::format("({})", name_for_mag_color.at(item.data2[3])));
    } catch (const std::out_of_range&) {
      ret_tokens.emplace_back(std::format("(!CL:{:02X})", item.data2[3]));
    }

  } else if (item.data1[0] == 0x03) {
    // For tools, add the amount (if applicable)
    if (item.max_stack_size(*this->limits) > 1) {
      ret_tokens.emplace_back(std::format("x{}", item.data1[5]));
    }
  }

  std::string ret = phosg::join(ret_tokens, " ");
  if (include_color_escapes) {
    if (is_unidentified) {
      return "$C3" + ret;
    } else if (item.is_s_rank_weapon()) {
      return "$C4" + ret;
    } else if (this->item_parameter_table->is_item_rare(item)) {
      return "$C6" + ret;
    } else if (item.has_bonuses()) {
      return "$C2" + ret;
    } else {
      return "$C7" + ret;
    }
  } else {
    return ret;
  }
}

ItemData ItemNameIndex::parse_item_description(const std::string& desc) const {
  ItemData ret;
  try {
    ret = this->parse_item_description_phase(desc, false);
  } catch (const std::exception& e1) {
    try {
      ret = this->parse_item_description_phase(desc, true);
    } catch (const std::exception& e2) {
      try {
        ret = ItemData::from_data(phosg::parse_data_string(desc));
      } catch (const std::exception& ed) {
        if (strcmp(e1.what(), e2.what())) {
          throw std::runtime_error(std::format("cannot parse item description \"{}\" (as text 1: {}) (as text 2: {}) (as data: {})",
              desc, e1.what(), e2.what(), ed.what()));
        } else {
          throw std::runtime_error(std::format("cannot parse item description \"{}\" (as text: {}) (as data: {})",
              desc, e1.what(), ed.what()));
        }
      }
    }
  }
  ret.enforce_stack_size_limits(*this->limits);
  return ret;
}

ItemData ItemNameIndex::parse_item_description_phase(const std::string& description, bool skip_special) const {
  ItemData ret;
  ret.data1d.clear(0);
  ret.id = 0xFFFFFFFF;
  ret.data2d = 0;

  std::string desc = phosg::tolower(description);
  if (desc.ends_with(" meseta")) {
    ret.data1[0] = 0x04;
    ret.data2d = std::stol(desc, nullptr, 10);
    return ret;
  }

  if (desc.starts_with("es ")) {
    auto parse_name = [&](const std::string& token) -> void {
      if (token.size() > 8) {
        throw std::runtime_error("s-rank name too long");
      }

      uint8_t char_indexes[8] = {0, 0, 0, 0, 0, 0, 0, 0};
      for (size_t z = 0; z < token.size(); z++) {
        char ch = toupper(token[z]);
        size_t pos = s_rank_name_characters.find(ch);
        if (pos == std::string::npos) {
          throw std::runtime_error(std::format("s-rank name contains invalid character {:02X} ({})", ch, ch));
        }
        char_indexes[z] = pos;
      }

      ret.data1w[3] = phosg::bswap16(0x8000 | (char_indexes[1] & 0x1F) | ((char_indexes[0] & 0x1F) << 5));
      ret.data1w[4] = phosg::bswap16(0x8000 | (char_indexes[4] & 0x1F) | ((char_indexes[3] & 0x1F) << 5) | ((char_indexes[2] & 0x1F) << 10));
      ret.data1w[5] = phosg::bswap16(0x8000 | (char_indexes[7] & 0x1F) | ((char_indexes[6] & 0x1F) << 5) | ((char_indexes[5] & 0x1F) << 10));
    };
    auto parse_special = [&](const std::string& token) -> bool {
      for (size_t z = 0; z < name_for_s_rank_special.size(); z++) {
        if (name_for_s_rank_special[z] && (token == phosg::tolower(name_for_s_rank_special[z]))) {
          ret.data1[2] = z;
          return true;
        }
      }
      return false;
    };
    auto parse_grind = [&](const std::string& token) -> bool {
      if (token.starts_with('+')) {
        ret.data1[3] = stoul(token.substr(1), nullptr, 0);
        return true;
      }
      return false;
    };
    auto parse_type = [&](const std::string& token) -> void {
      const auto& meta = this->es_name_index.at(token);
      if (meta->primary_identifier & 0xFF00FFFF) {
        throw std::runtime_error("ES weapon has invalid bits in primary identifier");
      }
      ret.data1[1] = meta->primary_identifier >> 16;
    };

    // Syntax: ES [NAME] [SPECIAL] TYPE [+GRIND]
    auto tokens = phosg::split(desc, ' ');
    switch (tokens.size()) {
      case 0:
      case 1:
        throw std::runtime_error("ES weapon type is missing");

      case 2:
        // Must be ES TYPE
        parse_name(tokens[1]);
        break;

      case 3:
        // Any of the following:
        // ES TYPE +N
        // ES SPECIAL TYPE
        // ES NAME TYPE
        if (parse_grind(tokens[2])) {
          parse_type(tokens[1]);
        } else if (parse_special(tokens[1])) {
          parse_type(tokens[2]);
        } else {
          parse_name(tokens[1]);
          parse_type(tokens[2]);
        }
        break;
      case 4:
        // Any of the following:
        // ES SPECIAL TYPE +N
        // ES NAME TYPE +N
        // ES NAME SPECIAL TYPE
        if (parse_grind(tokens[3])) {
          if (!parse_special(tokens[1])) {
            parse_name(tokens[1]);
          }
          parse_type(tokens[2]);
        } else {
          parse_name(tokens[1]);
          if (!parse_special(tokens[2])) {
            throw std::runtime_error("invalid ES special");
          }
          parse_type(tokens[3]);
        }
        break;
      case 5:
        // Must be ES NAME SPECIAL TYPE +N
        parse_name(tokens[1]);
        if (!parse_special(tokens[2])) {
          throw std::runtime_error("invalid ES special");
        }
        parse_type(tokens[3]);
        if (!parse_grind(tokens[4])) {
          throw std::runtime_error("invalid grind");
        }
        break;
      default:
        throw std::runtime_error("too many ES weapon tokens");
    }

    return ret;
  }

  if (desc.starts_with("disk:")) {
    auto tokens = phosg::split(desc, ' ');
    tokens[0] = tokens[0].substr(5); // Trim off "disk:"
    if ((tokens[0] == "reverser") || (tokens[0] == "ryuker")) {
      uint8_t tech = technique_for_name(tokens[0]);
      ret.data1[0] = 0x03;
      ret.data1[1] = 0x02;
      ret.data1[2] = 0x00;
      ret.data1[4] = tech;
    } else {
      if (tokens.size() != 2) {
        throw std::runtime_error("invalid tech disk format");
      }
      if (!tokens[1].starts_with("lv.")) {
        throw std::runtime_error("invalid tech disk level");
      }
      uint8_t tech = technique_for_name(tokens[0]);
      uint8_t level = stoul(tokens[1].substr(3), nullptr, 10) - 1;
      ret.data1[0] = 0x03;
      ret.data1[1] = 0x02;
      ret.data1[2] = level;
      ret.data1[4] = tech;
    }
    return ret;
  }

  bool is_wrapped = desc.starts_with("wrapped ");
  if (is_wrapped) {
    desc = desc.substr(8);
  }
  bool is_unidentified = desc.starts_with("?");
  if (is_unidentified) {
    size_t z;
    for (z = 1; z < desc.size(); z++) {
      if (desc[z] != ' ' && desc[z] != '?') {
        break;
      }
    }
    desc = desc.substr(z);
  }

  uint8_t weapon_special = 0;
  if (!skip_special) {
    for (size_t z = 0; z < name_for_weapon_special.size(); z++) {
      if (!name_for_weapon_special[z]) {
        continue;
      }
      std::string prefix = phosg::tolower(name_for_weapon_special[z]);
      prefix += ' ';
      if (desc.starts_with(prefix)) {
        weapon_special = z;
        desc = desc.substr(prefix.size());
        break;
      }
    }
  }

  auto name_it = this->name_index.lower_bound(desc);
  // Look up to 3 places before the lower bound. We have to do this to catch cases like Sange vs. Sange & Yasha - if
  // the input is like "Sange 0/...", then we'll see Sange & Yasha first, which we should skip.
  size_t lookback = 0;
  while (lookback < 4) {
    if (name_it != this->name_index.end() && desc.starts_with(name_it->first)) {
      break;
    } else if (name_it == this->name_index.begin()) {
      throw std::runtime_error("no such item");
    } else {
      name_it--;
      lookback++;
    }
  }
  if (lookback >= 4) {
    throw std::runtime_error("item not found: " + desc);
  }

  desc = desc.substr(name_it->first.size());
  if (desc.starts_with(" ")) {
    desc = desc.substr(1);
  }

  // Tech disks should have already been handled above, so we don't need to special-case 0302xxxx identifiers here.
  uint32_t primary_identifier = name_it->second->primary_identifier;
  ret.data1[0] = (primary_identifier >> 24) & 0xFF;
  ret.data1[1] = (primary_identifier >> 16) & 0xFF;
  ret.data1[2] = (primary_identifier >> 8) & 0xFF;

  if (ret.data1[0] == 0x00) {
    // Weapons: add special, grind and percentages (or name, if S-rank) and kill count if unsealable
    ret.data1[4] = weapon_special | (is_wrapped ? 0x40 : 0x00) | (is_unidentified ? 0x80 : 0x00);

    bool kill_count_set = false;
    auto tokens = phosg::split(desc, ' ');
    for (auto& token : tokens) {
      if (token.empty()) {
        continue;
      }
      if (token.starts_with("+")) {
        token = token.substr(1);
        ret.data1[3] = stoul(token, nullptr, 10);

      } else if (ret.is_s_rank_weapon()) {
        throw std::runtime_error("ES weapon must be prefixed with \"ES\"");

      } else if (token.starts_with("k:")) {
        ret.set_kill_count(stoul(token.substr(2), nullptr, 0));
        kill_count_set = true;

      } else {
        auto p_tokens = phosg::split(token, '/');
        if (p_tokens.size() > 5) {
          throw std::runtime_error("invalid bonuses token");
        }
        uint8_t max_bonuses = this->item_parameter_table->is_unsealable_item(ret) ? 2 : 3;
        uint8_t bonus_index = 0;
        for (size_t z = 0; z < p_tokens.size(); z++) {
          int8_t bonus_value = stol(p_tokens[z], nullptr, 10);
          if (bonus_value == 0) {
            continue;
          }
          if (bonus_index >= max_bonuses) {
            throw std::runtime_error("weapon has too many bonuses");
          }
          ret.data1[6 + (2 * bonus_index)] = z + 1;
          ret.data1[7 + (2 * bonus_index)] = static_cast<uint8_t>(bonus_value);
          bonus_index++;
        }
      }
    }

    if (this->item_parameter_table->is_unsealable_item(ret) && !kill_count_set) {
      ret.set_kill_count(0);
    }

  } else if (ret.data1[0] == 0x01) {
    if (ret.data1[1] == 0x03) { // Unit
      static const std::unordered_map<std::string, uint16_t> modifiers({
          {"--", 0xFFFC},
          {"-", 0xFFFE},
          {"", 0x0000},
          {"+", 0x0002},
          {"++", 0x0004},
      });
      bool kill_count_set = false;
      for (const auto& token : phosg::split(desc, ' ')) {
        if (token == "--") {
          ret.data1w[3] = 0xFFFC;
        } else if (token == "-") {
          ret.data1w[3] = 0xFFFE;
        } else if (token == "+") {
          ret.data1w[3] = 0x0002;
        } else if (token == "++") {
          ret.data1w[3] = 0x0004;
        } else if (token.starts_with('+')) {
          ret.data1w[3] = stoul(token.substr(1), nullptr, 0);
        } else if (token.starts_with('-')) {
          ret.data1w[3] = static_cast<uint16_t>(stol(token, nullptr, 0));
        } else if (token.starts_with("k:")) {
          ret.set_kill_count(stoul(token.substr(2), nullptr, 0));
          kill_count_set = true;
        }
      }

      if (this->item_parameter_table->is_unsealable_item(ret) && !kill_count_set) {
        ret.set_kill_count(0);
      }

    } else { // Armor/shield
      for (const auto& token : phosg::split(desc, ' ')) {
        if (token.empty()) {
          continue;
        } else if (!token.starts_with("+")) {
          throw std::runtime_error("invalid armor/shield modifier");
        }
        if (token.ends_with("def")) {
          ret.data1w[3] = static_cast<uint16_t>(stol(token.substr(1, token.size() - 4), nullptr, 10));
        } else if (token.ends_with("evp")) {
          ret.data1w[4] = static_cast<uint16_t>(stol(token.substr(1, token.size() - 4), nullptr, 10));
        } else {
          ret.data1[5] = stoul(token.substr(1), nullptr, 10);
        }
      }
    }

    if (is_wrapped) {
      ret.data1[4] |= 0x40;
    }

  } else if (ret.data1[0] == 0x02) {
    for (const auto& token : phosg::split(desc, ' ')) {
      if (token.empty()) {
        continue;
      } else if (token.starts_with("pb:")) { // Photon blasts
        auto pb_tokens = phosg::split(token.substr(3), ',');
        if (pb_tokens.size() > 3) {
          throw std::runtime_error("too many photon blasts specified");
        }
        static const std::unordered_map<std::string, uint8_t> name_to_pb_num(
            {{"f", 0}, {"e", 1}, {"g", 2}, {"p", 3}, {"l", 4}, {"m", 5}, {"my", 5}, {"m&y", 5}});
        for (const auto& pb_token : pb_tokens) {
          ret.add_mag_photon_blast(name_to_pb_num.at(pb_token));
        }
      } else if (token.ends_with("%")) { // Synchro
        ret.data2[0] = stoul(token.substr(0, token.size() - 1), nullptr, 10);
      } else if (token.ends_with("iq")) { // IQ
        ret.data2[1] = stoul(token.substr(0, token.size() - 2), nullptr, 10);
      } else if (!token.empty() && isdigit(token[0])) { // Stats
        auto s_tokens = phosg::split(token, '/');
        if (s_tokens.size() != 4) {
          throw std::runtime_error("incorrect stat count");
        }
        for (size_t z = 0; z < 4; z++) {
          auto n_tokens = phosg::split(s_tokens[z], '.');
          if (n_tokens.size() == 0 || n_tokens.size() > 2) {
            throw std::logic_error("incorrect stats argument format");
          } else if ((n_tokens.size() == 1) || (n_tokens[1].size() == 0)) {
            ret.data1w[z + 2] = stoul(n_tokens[0], nullptr, 10) * 100;
          } else if (n_tokens[1].size() == 1) {
            ret.data1w[z + 2] = stoul(n_tokens[0], nullptr, 10) * 100 + stoul(n_tokens[1], nullptr, 10) * 10;
          } else if (n_tokens[1].size() == 2) {
            ret.data1w[z + 2] = stoul(n_tokens[0], nullptr, 10) * 100 + stoul(n_tokens[1], nullptr, 10);
          } else {
            throw std::runtime_error("incorrect stat format");
          }
        }
        ret.data1[2] = ret.compute_mag_level();
      } else { // Color
        ret.data2[3] = mag_color_for_name.at(token);
      }
    }

    if (is_wrapped) {
      ret.data2[2] |= 0x40;
    }
  } else if (ret.data1[0] == 0x03) {
    if (ret.max_stack_size(*this->limits) > 1) {
      if (desc.starts_with("x")) {
        ret.data1[5] = stoul(desc.substr(1), nullptr, 10);
      } else {
        ret.data1[5] = 1;
      }
    } else if (!desc.empty()) {
      throw std::runtime_error("item cannot be stacked");
    }

    if (is_wrapped) {
      if (ret.is_stackable(*this->limits)) {
        throw std::runtime_error("stackable items cannot be wrapped");
      } else {
        ret.data1[3] |= 0x40;
      }
    }
  } else {
    throw std::logic_error("invalid item class");
  }

  return ret;
}

void ItemNameIndex::print_table(FILE* stream) const {
  auto pmt = this->item_parameter_table;

  phosg::fwrite_fmt(stream, "WEAPONS\n");
  phosg::fwrite_fmt(stream, "  CODE   => ---ID--- TYPE SKIN POINTS FLAG ATPLO ATPHI ATPRQ MSTRQ ATARQ -MST- GND PH SP ATA SB(S1:AMT1,S2:AMT2) PJ 1X 1Y 2X 2Y CR --A1-- A4 A5 TB(TN:FL:AMOUNT, ...                     ) BF CL ST* USL ---DIVISOR--- NAME\n");
  for (size_t data1_1 = 0; data1_1 < pmt->num_weapon_classes(); data1_1++) {
    uint8_t weapon_class = pmt->get_weapon_kind(data1_1);
    float sale_divisor = pmt->get_sale_divisor(0x00, data1_1);
    std::string divisor_str = std::format("{:g}", sale_divisor);
    divisor_str.resize(13, ' ');

    size_t data1_2_limit = pmt->num_weapons_in_class(data1_1);
    for (size_t data1_2 = 0; data1_2 < data1_2_limit; data1_2++) {
      const auto& w = pmt->get_weapon(data1_1, data1_2);
      uint8_t stars = pmt->get_item_stars(w.id);
      bool is_unsealable = pmt->is_unsealable_item(0x00, data1_1, data1_2);

      ItemData item;
      item.data1[0] = 0x00;
      item.data1[1] = data1_1;
      item.data1[2] = data1_2;
      std::string name = this->describe_item(item);

      const auto& stat_boost = pmt->get_stat_boost(w.stat_boost_entry_index);

      std::string tech_boost_str;
      if (w.tech_boost_entry_index < pmt->num_tech_boosts()) {
        const auto& tech_boost = pmt->get_tech_boost(w.tech_boost_entry_index);
        tech_boost_str = std::format("({:02X}:{:02X}:{:g},{:02X}:{:02X}:{:g},{:02X}:{:02X}:{:g})",
            tech_boost.tech_num1, tech_boost.flags1, tech_boost.amount1, tech_boost.tech_num2, tech_boost.flags2,
            tech_boost.amount2, tech_boost.tech_num3, tech_boost.flags3, tech_boost.amount3);
      }
      tech_boost_str.resize(40, ' ');

      phosg::fwrite_fmt(stream,
          // CODE           =>     ID   TYPE   SKIN  PTS   FLAG ATP- ATP+ ATPR MSTR ATAR  MST  GND     PH     SP  ATA
          "  00{:02X}{:02X} => {:08X} {:04X} {:04X} {:6} {:04X} {:5} {:5} {:5} {:5} {:5} {:5} {:3} {:02X} {:02X} {:3} "
          //   SB(    S1:AMT1  ,    S2:AMT2  )     PJ     1X     1Y     2X     2Y     CR --------A1--------     A4
          "{:02X}({:02X}:{:04X},{:02X}:{:04X}) {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}{:02X}{:02X} {:02X} "
          //   A5     TB(    TN:    FL: AMT,    TN:    FL: AMT,    TN:    FL: AMT)     BF     CL   ST* US DV NAME\n"
          "{:02X} {:02X}{} {:02X} {:02X} {:2}* {} {} {}\n",
          data1_1,
          data1_2,
          w.id,
          w.type,
          w.skin,
          w.team_points,
          w.usability_flags,
          w.atp_min,
          w.atp_max,
          w.atp_required,
          w.mst_required,
          w.ata_required,
          w.mst,
          w.max_grind,
          w.photon,
          w.special,
          w.ata,
          w.stat_boost_entry_index,
          stat_boost.stat1,
          stat_boost.amount1,
          stat_boost.stat2,
          stat_boost.amount2,
          w.projectile,
          w.trail1_x,
          w.trail1_y,
          w.trail2_x,
          w.trail2_y,
          w.color,
          w.unknown_a1[0],
          w.unknown_a1[1],
          w.unknown_a1[2],
          w.unknown_a4,
          w.unknown_a5,
          w.tech_boost_entry_index,
          tech_boost_str,
          w.behavior_flags,
          weapon_class,
          stars,
          is_unsealable ? "YES" : " no",
          divisor_str,
          name);
    }
  }

  phosg::fwrite_fmt(stream, "ARMORS\n");
  phosg::fwrite_fmt(stream, "  CODE   => ---ID--- TYPE SKIN POINTS -DFP- -EVP- BP BE FLAG LVL EFR ETH EIC EDK ELT DFR EVR SB(S1:AMT1,S2:AMT2) TB(TN:FL:AMOUNT, ...                     ) FT A4 ST* ---DIVISOR--- NAME\n");
  for (size_t data1_1 = 1; data1_1 < 3; data1_1++) {
    float sale_divisor = pmt->get_sale_divisor(0x01, data1_1);
    std::string divisor_str = std::format("{:g}", sale_divisor);
    divisor_str.resize(13, ' ');

    size_t data1_2_limit = pmt->num_armors_or_shields_in_class(data1_1);
    for (size_t data1_2 = 0; data1_2 < data1_2_limit; data1_2++) {
      const auto& a = pmt->get_armor_or_shield(data1_1, data1_2);
      uint8_t stars = pmt->get_item_stars(a.id);

      ItemData item;
      item.data1[0] = 0x01;
      item.data1[1] = data1_1;
      item.data1[2] = data1_2;
      std::string name = this->describe_item(item);

      auto& stat_boost = pmt->get_stat_boost(a.stat_boost_entry_index);

      std::string tech_boost_str;
      if (a.tech_boost_entry_index < pmt->num_tech_boosts()) {
        const auto& tech_boost = pmt->get_tech_boost(a.tech_boost_entry_index);
        tech_boost_str = std::format("({:02X}:{:02X}:{:g},{:02X}:{:02X}:{:g},{:02X}:{:02X}:{:g})",
            tech_boost.tech_num1, tech_boost.flags1, tech_boost.amount1, tech_boost.tech_num2, tech_boost.flags2,
            tech_boost.amount2, tech_boost.tech_num3, tech_boost.flags3, tech_boost.amount3);
      }
      tech_boost_str.resize(40, ' ');

      phosg::fwrite_fmt(stream, "  01{:02X}{:02X} => {:08X} {:04X} {:04X} {:6} {:5} {:5} {:02X} {:02X} {:04X} {:3} {:3} {:3} {:3} {:3} {:3} {:3} {:3} {:02X}({:02X}:{:04X},{:02X}:{:04X}) {:02X}{} {:02X} {:02X} {:2}* {} {}\n",
          data1_1,
          data1_2,
          a.id,
          a.type,
          a.skin,
          a.team_points,
          a.dfp,
          a.evp,
          a.block_particle,
          a.block_effect,
          a.usability_flags,
          static_cast<uint8_t>(a.required_level + 1),
          a.efr,
          a.eth,
          a.eic,
          a.edk,
          a.elt,
          a.dfp_range,
          a.evp_range,
          a.stat_boost_entry_index,
          stat_boost.stat1,
          stat_boost.amount1,
          stat_boost.stat2,
          stat_boost.amount2,
          a.tech_boost_entry_index,
          tech_boost_str,
          a.flags_type,
          a.unknown_a4,
          stars,
          divisor_str,
          name);
    }
  }

  phosg::fwrite_fmt(stream, "UNITS\n");
  phosg::fwrite_fmt(stream, "  CODE   => ---ID--- TYPE SKIN POINTS STAT COUNT ST-MOD ST* ---DIVISOR--- NAME\n");
  {
    float sale_divisor = pmt->get_sale_divisor(0x01, 0x03);
    std::string divisor_str = std::format("{:g}", sale_divisor);
    divisor_str.resize(13, ' ');

    size_t data1_2_limit = pmt->num_units();
    for (size_t data1_2 = 0; data1_2 < data1_2_limit; data1_2++) {
      const auto& u = pmt->get_unit(data1_2);
      uint8_t stars = pmt->get_item_stars(u.id);

      ItemData item;
      item.data1[0] = 0x01;
      item.data1[1] = 0x03;
      item.data1[2] = data1_2;
      std::string name = this->describe_item(item);

      phosg::fwrite_fmt(stream, "  0103{:02X} => {:08X} {:04X} {:04X} {:6} {:04X} {:5} {:6} {:2}* {} {}\n",
          data1_2,
          u.id,
          u.type,
          u.skin,
          u.team_points,
          u.stat,
          u.stat_amount,
          u.modifier_amount,
          stars,
          divisor_str,
          name);
    }
  }

  phosg::fwrite_fmt(stream, "MAGS\n");
  phosg::fwrite_fmt(stream, "  CODE   => ---ID--- TYPE SKIN POINTS FTBL PB AC E1 E2 E3 E4 C1 C2 C3 C4 FLAG ---DIVISOR--- NAME\n");
  {
    size_t data1_1_limit = pmt->num_mags();
    for (size_t data1_1 = 0; data1_1 < data1_1_limit; data1_1++) {
      const auto& m = pmt->get_mag(data1_1);

      float sale_divisor = pmt->get_sale_divisor(0x02, data1_1);
      std::string divisor_str = std::format("{:g}", sale_divisor);
      divisor_str.resize(13, ' ');

      ItemData item;
      item.data1[0] = 0x02;
      item.data1[1] = data1_1;
      item.data1[2] = 0x00;
      std::string name = this->describe_item(item);

      phosg::fwrite_fmt(stream, "  02{:02X}00 => {:08X} {:04X} {:04X} {:6} {:04X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:04X} {} {}\n",
          data1_1,
          m.id,
          m.type,
          m.skin,
          m.team_points,
          m.feed_table,
          m.photon_blast,
          m.activation,
          m.on_pb_full,
          m.on_low_hp,
          m.on_death,
          m.on_boss,
          m.on_pb_full_flag,
          m.on_low_hp_flag,
          m.on_death_flag,
          m.on_boss_flag,
          m.usability_flags,
          divisor_str,
          name);
    }
  }

  phosg::fwrite_fmt(stream, "TOOLS\n");
  phosg::fwrite_fmt(stream, "  CODE   => ---ID--- TYPE SKIN POINTS COUNT TECH -COST- ITEMFLAG ---DIVISOR--- NAME\n");
  for (size_t data1_1 = 0; data1_1 < pmt->num_tool_classes(); data1_1++) {
    float sale_divisor = pmt->get_sale_divisor(0x03, data1_1);
    std::string divisor_str = std::format("{:g}", sale_divisor);
    divisor_str.resize(13, ' ');

    size_t data1_2_limit = pmt->num_tools_in_class(data1_1);
    for (size_t data1_2 = 0; data1_2 < data1_2_limit; data1_2++) {
      const auto& t = pmt->get_tool(data1_1, data1_2);

      ItemData item;
      item.data1[0] = 0x03;
      item.data1[1] = data1_1;
      item.data1[(data1_1 == 0x02) ? 4 : 2] = data1_2;
      item.set_tool_item_amount(*this->limits, 1);
      std::string name = this->describe_item(item);

      phosg::fwrite_fmt(stream, "  03{:02X}{:02X} => {:08X} {:04X} {:04X} {:6} {:5} {:04X} {:6} {:08X} {} {}\n",
          data1_1,
          data1_2,
          t.id,
          t.type,
          t.skin,
          t.team_points,
          t.amount,
          t.tech,
          t.cost,
          t.item_flags,
          divisor_str,
          name);
    }
  }

  phosg::fwrite_fmt(stream, "MAX TECH LEVELS\n");
  phosg::fwrite_fmt(stream, "  CLASS     =>  F GF RF  B GB RB  Z GZ RZ GR DB JL ZL SH RY RS AT RV MG\n");
  for (size_t char_class = 0; char_class < 12; char_class++) {
    phosg::fwrite_fmt(stream, "  {:9} =>", name_for_char_class(char_class));
    for (size_t tech_num = 0; tech_num < 0x13; tech_num++) {
      uint8_t max_level = pmt->get_max_tech_level(char_class, tech_num) + 1;
      if (max_level == 0x00) {
        phosg::fwrite_fmt(stream, "   ");
      } else {
        phosg::fwrite_fmt(stream, " {:2}", max_level);
      }
    }
    phosg::fwrite_fmt(stream, "\n");
  }

  phosg::fwrite_fmt(stream, "MAG FEED TABLES\n");
  for (size_t table_index = 0; table_index < 8; table_index++) {
    static const char* names[11] = {
        "Monomate", "Dimate", "Trimate", "Monofluid", "Difluid", "Trifluid", "Antidote", "Antiparalysis",
        "Sol Atomizer", "Moon Atomizer", "Star Atomizer"};
    phosg::fwrite_fmt(stream, "  TABLE {:02X}         => -DEF -POW -DEX MIND -IQ- SYNC\n", table_index);
    for (size_t which = 0; which < 11; which++) {
      const auto& res = pmt->get_mag_feed_result(table_index, which);
      phosg::fwrite_fmt(stream, "    {:14} => {:4} {:4} {:4} {:4} {:4} {:4}\n",
          names[which], res.def, res.pow, res.dex, res.mind, res.iq, res.synchro);
    }
  }

  phosg::fwrite_fmt(stream, "SPECIAL DEFINITIONS\n");
  phosg::fwrite_fmt(stream, "  SP => TYPE COUNT ST* NAME\n");
  for (size_t index = 0; index < pmt->num_specials(); index++) {
    const auto& sp = pmt->get_special(index);
    uint8_t stars = pmt->get_special_stars(index);
    const char* name = "";
    if (index) {
      try {
        name = name_for_weapon_special.at(index);
      } catch (const std::out_of_range&) {
      }
    }
    phosg::fwrite_fmt(stream, "  {:02X} => {:04X} {:5} {:2}* {}\n", index, sp.type, sp.amount, stars, name);
  }

  phosg::fwrite_fmt(stream, "ITEM COMBINATIONS\n");
  phosg::fwrite_fmt(stream, "  ---USE + -EQUIP => RESULT MLV GND LVL CLS\n");
  for (const auto& combo_list_it : pmt->item_combinations_index()) {
    for (const auto& combo : combo_list_it.second) {
      phosg::fwrite_fmt(stream, "  {:02X}{:02X}{:02X} + {:02X}{:02X}{:02X} => {:02X}{:02X}{:02X}",
          combo.used_item[0], combo.used_item[1], combo.used_item[2],
          combo.equipped_item[0], combo.equipped_item[1], combo.equipped_item[2],
          combo.result_item[0], combo.result_item[1], combo.result_item[2]);
      if (combo.mag_level != 0xFF) {
        phosg::fwrite_fmt(stream, " {:3}", combo.mag_level);
      } else {
        phosg::fwrite_fmt(stream, "    ");
      }
      if (combo.grind != 0xFF) {
        phosg::fwrite_fmt(stream, " {:3}", combo.grind);
      } else {
        phosg::fwrite_fmt(stream, "    ");
      }
      if (combo.level != 0xFF) {
        phosg::fwrite_fmt(stream, " {:3}", combo.level);
      } else {
        phosg::fwrite_fmt(stream, "    ");
      }
      if (combo.char_class != 0xFF) {
        phosg::fwrite_fmt(stream, " {:3}\n", combo.char_class);
      } else {
        phosg::fwrite_fmt(stream, "    \n");
      }
    }
  }

  phosg::fwrite_fmt(stream, "EVENT ITEMS\n");
  size_t num_events = pmt->num_events();
  for (size_t event_number = 0; event_number < num_events; event_number++) {
    phosg::fwrite_fmt(stream, "  EV {:3} => PRB\n", event_number);
    auto events_list = pmt->get_event_items(event_number);
    for (size_t z = 0; z < events_list.second; z++) {
      const auto& event_item = events_list.first[z];
      phosg::fwrite_fmt(stream, "  {:02X}{:02X}{:02X} => {:3}\n",
          event_item.item[0], event_item.item[1], event_item.item[2], event_item.probability);
    }
  }

  phosg::fwrite_fmt(stream, "PHOTON COLORS\n");
  phosg::fwrite_fmt(stream, "  ## => ---A1--- (A2) (A3)\n");
  for (size_t z = 0; z < pmt->num_photon_colors(); z++) {
    const auto& pc = pmt->get_photon_color(z);
    phosg::fwrite_fmt(stream, "  {:02X} => {:08X} ({:g}, {:g}, {:g}, {:g}) ({:g}, {:g}, {:g}, {:g})\n",
        z, pc.unknown_a1, pc.unknown_a2.x, pc.unknown_a2.y, pc.unknown_a2.z, pc.unknown_a2.t,
        pc.unknown_a3.x, pc.unknown_a3.y, pc.unknown_a3.z, pc.unknown_a3.t);
  }

  phosg::fwrite_fmt(stream, "WEAPON RANGES\n");
  phosg::fwrite_fmt(stream, "  ## => ---A3--- ---A4--- ---A5--- (A1) (A2)\n");
  for (size_t z = 0; z < pmt->num_weapon_ranges(); z++) {
    const auto& wr = pmt->get_weapon_range(z);
    phosg::fwrite_fmt(stream, "  {:02X} => {:08X} {:08X} {:08X} ({:g}) ({:g})\n",
        z, wr.unknown_a3, wr.unknown_a4, wr.unknown_a5, wr.unknown_a1, wr.unknown_a2);
  }

  phosg::fwrite_fmt(stream, "SALE DIVISORS\n");
  phosg::fwrite_fmt(stream, "  ARMOR = {:g}\n", pmt->get_sale_divisor(1, 1));
  phosg::fwrite_fmt(stream, "  SHIELD = {:g}\n", pmt->get_sale_divisor(1, 2));
  phosg::fwrite_fmt(stream, "  UNIT = {:g}\n", pmt->get_sale_divisor(1, 3));
  phosg::fwrite_fmt(stream, "  MAG = {:g}\n", pmt->get_sale_divisor(2, 0));

  auto write_data_string = [&](const std::string& data, size_t addr = 0) -> void {
    if (data.empty()) {
      phosg::fwrite_fmt(stream, "  (no data)\n");
    } else {
      auto data_str = phosg::format_data(data, addr);
      phosg::strip_trailing_whitespace(data_str);
      phosg::fwrite_fmt(stream, "  {}\n", phosg::str_replace_all(data_str, "\n", "\n  "));
    }
  };

  phosg::fwrite_fmt(stream, "STAR VALUES\n");
  write_data_string(pmt->get_star_value_table(), pmt->get_star_value_index_range().first);

  phosg::fwrite_fmt(stream, "UNKNOWN_A1\n");
  write_data_string(pmt->get_unknown_a1());

  phosg::fwrite_fmt(stream, "WEAPON EFFECTS\n");
  phosg::fwrite_fmt(stream, "  ## => -SOUND1- -VALUE1- -SOUND2- -VALUE2- ----------------A5---------------\n");
  for (size_t z = 0; z < pmt->num_weapon_effects(); z++) {
    const auto& we = pmt->get_weapon_effect(z);
    auto a5_str = phosg::format_data_string(we.unknown_a5.data(), we.unknown_a5.size());
    phosg::fwrite_fmt(stream, "  {:02X} => {:08X} {:08X} {:08X} {:08X} {}\n",
        z, we.sound_id1, we.eff_value1, we.sound_id2, we.eff_value2, a5_str);
  }

  phosg::fwrite_fmt(stream, "WEAPON STAT BOOST INDEX TABLE\n");
  write_data_string(pmt->get_weapon_stat_boost_index_table());

  phosg::fwrite_fmt(stream, "ARMOR STAT BOOST INDEX TABLE\n");
  write_data_string(pmt->get_armor_stat_boost_index_table());

  phosg::fwrite_fmt(stream, "SHIELD STAT BOOST INDEX TABLE\n");
  write_data_string(pmt->get_shield_stat_boost_index_table());

  phosg::fwrite_fmt(stream, "STAT BOOSTS\n");
  phosg::fwrite_fmt(stream, "  ## => BOOSTS\n");
  for (size_t z = 0; z < pmt->num_stat_boosts(); z++) {
    const auto& sb = pmt->get_stat_boost(z);
    static constexpr std::array<const char*, 0x10> stat_names{
        "ATP+", "ATA+", "EVP+", "DFP+", "MST+", "HP+", "LCK+", "ALL+",
        "ATP-", "ATA-", "EVP-", "DFP-", "MST-", "HP-", "LCK-", "ALL-"};
    std::string s;
    if (sb.stat1 > 0x10) {
      s = std::format("[{:02X}:{:04X}]", sb.stat1, sb.amount1);
    } else if (sb.stat1 > 0) {
      s = std::format("{}{}", stat_names[sb.stat1 - 1], sb.amount1);
    }
    if (sb.stat2) {
      if (!s.empty()) {
        s += ", ";
      }
      if (sb.stat2 > 0x10) {
        s += std::format("[{:02X}:{:04X}]", sb.stat2, sb.amount2);
      } else if (sb.stat2 > 0) {
        s += std::format("{}{}", stat_names[sb.stat2 - 1], sb.amount2);
      }
    }
    if (s.empty()) {
      s = "(none)";
    }
    phosg::fwrite_fmt(stream, "  {:02X} => {}\n", z, s);
  }

  phosg::fwrite_fmt(stream, "SHIELD EFFECTS\n");
  phosg::fwrite_fmt(stream, "  ## => -SOUND1- ---A1---\n");
  for (size_t z = 0; z < pmt->num_shield_effects(); z++) {
    const auto& se = pmt->get_shield_effect(z);
    phosg::fwrite_fmt(stream, "  {:02X} => {:08X} {:08X}\n", z, se.sound_id, se.unknown_a1);
  }

  phosg::fwrite_fmt(stream, "SOUND REMAPS\n");
  phosg::fwrite_fmt(stream, "  -SOUND1- => RT:[...] CC:[...]\n");
  for (const auto& remap : pmt->get_all_sound_remaps()) {
    std::string rt_str;
    for (uint32_t rt_sound_id : remap.by_rt_index) {
      if (!rt_str.empty()) {
        rt_str += ",";
      }
      rt_str += std::format("{:08X}", rt_sound_id);
    }
    std::string cc_str;
    for (uint32_t cc_sound_id : remap.by_char_class) {
      if (!cc_str.empty()) {
        cc_str += ",";
      }
      cc_str += std::format("{:08X}", cc_sound_id);
    }
    phosg::fwrite_fmt(stream, "  {:08X} => RT:[{}] CC:[{}]\n", remap.sound_id, rt_str, cc_str);
  }

  phosg::fwrite_fmt(stream, "TECH BOOSTS\n");
  phosg::fwrite_fmt(stream, "  ## => BOOSTS\n");
  for (size_t z = 0; z < pmt->num_tech_boosts(); z++) {
    const auto& tb = pmt->get_tech_boost(z);
    std::string s;
    if (tb.amount1) {
      s += std::format("{:02X}:{:02X}:{:g}", tb.tech_num1, tb.flags1, tb.amount1);
    }
    if (tb.amount2) {
      s += std::format("{:02X}:{:02X}:{:g}", tb.tech_num2, tb.flags2, tb.amount2);
    }
    if (tb.amount3) {
      s += std::format("{:02X}:{:02X}:{:g}", tb.tech_num3, tb.flags3, tb.amount3);
    }
    phosg::fwrite_fmt(stream, "  {:02X} => {}\n", z, s);
  }

  phosg::fwrite_fmt(stream, "UNSEALABLE ITEMS\n");
  phosg::fwrite_fmt(stream, "  -ITEM- NAME\n");
  std::vector<uint32_t> unsealable_items;
  for (uint32_t item_code : pmt->all_unsealable_items()) {
    unsealable_items.emplace_back(item_code);
  }
  std::sort(unsealable_items.begin(), unsealable_items.end());
  for (uint32_t item_code : unsealable_items) {
    ItemData item;
    item.data1[0] = item_code >> 16;
    item.data1[1] = item_code >> 8;
    item.data1[2] = item_code;
    phosg::fwrite_fmt(stream, "  {:06X} {}\n", item_code, this->describe_item(item));
  }

  phosg::fwrite_fmt(stream, "RANGED SPECIALS\n");
  phosg::fwrite_fmt(stream, "  ## => 11 12 WR A1\n");
  for (size_t z = 0; z < pmt->num_ranged_specials(); z++) {
    const auto& rs = pmt->get_ranged_special(z);
    phosg::fwrite_fmt(stream, "  {:02X} => {:02X} {:02X} {:02X} {:02X}\n",
        z, rs.data1_1, rs.data1_2, rs.weapon_range_index, rs.unknown_a1);
  }
}