#include "ItemParameterTable.hh"

using namespace std;

ItemParameterTable::ItemParameterTable(shared_ptr<const string> data, Version version)
    : version(version),
      data(data),
      r(*data),
      offsets_dc_protos(nullptr),
      offsets_v1_v2(nullptr),
      offsets_gc_nte(nullptr),
      offsets_v3_le(nullptr),
      offsets_v3_be(nullptr),
      offsets_v4(nullptr) {
  size_t offset_table_offset = is_big_endian(version)
      ? this->r.pget_u32b(this->data->size() - 0x10)
      : this->r.pget_u32l(this->data->size() - 0x10);

  switch (this->version) {
    case Version::DC_NTE: {
      this->offsets_dc_protos = &this->r.pget<TableOffsetsDCProtos>(offset_table_offset);
      this->num_weapon_classes = 0x27;
      this->num_tool_classes = 0x0D;
      this->item_stars_first_id = 0x22;
      this->item_stars_last_id = 0x168;
      this->special_stars_begin_index = 0xAA;
      this->num_specials = 0x28;
      // TODO: Check if first_rare_mag_index is the same on this version
      break;
    }
    case Version::DC_V1_11_2000_PROTOTYPE: {
      this->offsets_dc_protos = &this->r.pget<TableOffsetsDCProtos>(offset_table_offset);
      this->num_weapon_classes = 0x27;
      this->num_tool_classes = 0x0E;
      this->item_stars_first_id = 0x26;
      this->item_stars_last_id = 0x16C;
      this->special_stars_begin_index = 0xAE;
      this->num_specials = 0x28;
      // TODO: Check if first_rare_mag_index is the same on this version
      break;
    }
    case Version::DC_V1: {
      this->offsets_v1_v2 = &this->r.pget<TableOffsetsV1V2>(offset_table_offset);
      this->num_weapon_classes = 0x27;
      this->num_tool_classes = 0x0E;
      this->item_stars_first_id = 0x26;
      this->item_stars_last_id = 0x16C;
      this->special_stars_begin_index = 0xAE;
      this->num_specials = 0x29;
      // TODO: Check if first_rare_mag_index is the same on this version
      break;
    }
    case Version::DC_V2:
    case Version::PC_NTE:
    case Version::PC_V2: {
      this->offsets_v1_v2 = &this->r.pget<TableOffsetsV1V2>(offset_table_offset);
      this->num_weapon_classes = 0x89;
      this->num_tool_classes = 0x10;
      this->item_stars_first_id = 0x4E;
      this->item_stars_last_id = 0x215;
      this->special_stars_begin_index = 0x138;
      this->num_specials = 0x29;
      break;
    }

    case Version::GC_NTE: {
      this->offsets_gc_nte = &this->r.pget<TableOffsetsGCNTE>(offset_table_offset);
      this->num_weapon_classes = 0x8D;
      this->num_tool_classes = 0x13;
      this->item_stars_first_id = 0x76;
      this->item_stars_last_id = 0x298;
      this->special_stars_begin_index = 0x1A3;
      this->num_specials = 0x29;
      break;
    }

    case Version::GC_EP3_NTE:
    case Version::GC_EP3:
    case Version::GC_V3:
    case Version::XB_V3: {
      if (is_big_endian(this->version)) {
        this->offsets_v3_be = &this->r.pget<TableOffsetsV3V4BE>(offset_table_offset);
      } else {
        this->offsets_v3_le = &this->r.pget<TableOffsetsV3V4>(offset_table_offset);
      }
      this->num_weapon_classes = 0xAA;
      this->num_tool_classes = 0x18;
      this->item_stars_first_id = 0x94;
      this->item_stars_last_id = 0x2F7;
      this->special_stars_begin_index = 0x1CB;
      this->num_specials = 0x29;
      break;
    }

    case Version::BB_V4: {
      this->offsets_v4 = &this->r.pget<TableOffsetsV3V4>(offset_table_offset);
      this->num_weapon_classes = 0xED;
      this->num_tool_classes = 0x1B;
      this->item_stars_first_id = 0xB1;
      this->item_stars_last_id = 0x437;
      this->special_stars_begin_index = 0x256;
      this->num_specials = 0x29;
      break;
    }
    default:
      throw logic_error("invalid item parameter table version");
  }

  this->first_rare_mag_index = 0x28;
}

set<uint32_t> ItemParameterTable::compute_all_valid_primary_identifiers() const {
  set<uint32_t> ret;

  auto find_items_1d = [&](uint64_t data1, size_t position) -> size_t {
    ItemData item(data1, 0);
    for (size_t x = 0; x < 0x100; x++) {
      item.data1[position] = x;
      try {
        this->get_item_id(item);
      } catch (const out_of_range&) {
        return x;
      }
      ret.emplace(item.primary_identifier());
    }
    return 0x100;
  };
  auto find_items_2d = [&](uint64_t data1) {
    for (size_t x = 0; x < 0x100; x++) {
      size_t effective_data1 = data1 | (static_cast<uint64_t>(x) << 48);
      size_t data2_position = (effective_data1 == 0x0302000000000000) ? 4 : 2;
      if (find_items_1d(effective_data1, data2_position) == 0) {
        break;
      }
    }
  };

  find_items_2d(0x0000000000000000);
  find_items_1d(0x0101000000000000, 2);
  find_items_1d(0x0102000000000000, 2);
  find_items_1d(0x0103000000000000, 2);
  find_items_1d(0x0200000000000000, 1);
  find_items_2d(0x0300000000000000);
  return ret;
}

ItemParameterTable::WeaponV4 ItemParameterTable::WeaponDCProtos::to_v4() const {
  WeaponV4 ret;
  ret.base.id = this->base.id;
  ret.class_flags = this->class_flags;
  ret.atp_min = this->atp_min;
  ret.atp_max = this->atp_max;
  ret.atp_required = this->atp_required;
  ret.mst_required = this->mst_required;
  ret.ata_required = this->ata_required;
  ret.max_grind = this->max_grind;
  ret.photon = this->photon;
  ret.special = this->special;
  ret.ata = this->ata;
  return ret;
}

ItemParameterTable::WeaponV4 ItemParameterTable::WeaponV1V2::to_v4() const {
  WeaponV4 ret;
  ret.base.id = this->base.id;
  ret.class_flags = this->class_flags;
  ret.atp_min = this->atp_min;
  ret.atp_max = this->atp_max;
  ret.atp_required = this->atp_required;
  ret.mst_required = this->mst_required;
  ret.ata_required = this->ata_required;
  ret.max_grind = this->max_grind;
  ret.photon = this->photon;
  ret.special = this->special;
  ret.ata = this->ata;
  ret.stat_boost = this->stat_boost;
  return ret;
}

ItemParameterTable::WeaponV4 ItemParameterTable::WeaponGCNTE::to_v4() const {
  WeaponV4 ret;
  ret.base.id = this->base.id.load();
  ret.base.type = this->base.type.load();
  ret.base.skin = this->base.skin.load();
  ret.class_flags = this->class_flags.load();
  ret.atp_min = this->atp_min.load();
  ret.atp_max = this->atp_max.load();
  ret.atp_required = this->atp_required.load();
  ret.mst_required = this->mst_required.load();
  ret.ata_required = this->ata_required.load();
  ret.mst = this->mst.load();
  ret.max_grind = this->max_grind;
  ret.photon = this->photon;
  ret.special = this->special;
  ret.ata = this->ata;
  ret.stat_boost = this->stat_boost;
  ret.projectile = this->projectile;
  ret.trail1_x = this->trail1_x;
  ret.trail1_y = this->trail1_y;
  ret.trail2_x = this->trail2_x;
  ret.trail2_y = this->trail2_y;
  ret.color = this->color;
  ret.unknown_a1 = this->unknown_a1;
  ret.unknown_a2 = this->unknown_a2;
  ret.unknown_a3 = this->unknown_a3;
  return ret;
}

template <bool IsBigEndian>
ItemParameterTable::WeaponV4 ItemParameterTable::WeaponV3T<IsBigEndian>::to_v4() const {
  WeaponV4 ret;
  ret.base.id = this->base.id.load();
  ret.base.type = this->base.type.load();
  ret.base.skin = this->base.skin.load();
  ret.class_flags = this->class_flags.load();
  ret.atp_min = this->atp_min.load();
  ret.atp_max = this->atp_max.load();
  ret.atp_required = this->atp_required.load();
  ret.mst_required = this->mst_required.load();
  ret.ata_required = this->ata_required.load();
  ret.mst = this->mst.load();
  ret.max_grind = this->max_grind;
  ret.photon = this->photon;
  ret.special = this->special;
  ret.ata = this->ata;
  ret.stat_boost = this->stat_boost;
  ret.projectile = this->projectile;
  ret.trail1_x = this->trail1_x;
  ret.trail1_y = this->trail1_y;
  ret.trail2_x = this->trail2_x;
  ret.trail2_y = this->trail2_y;
  ret.color = this->color;
  ret.unknown_a1 = this->unknown_a1;
  ret.unknown_a2 = this->unknown_a2;
  ret.unknown_a3 = this->unknown_a3;
  ret.unknown_a4 = this->unknown_a4;
  ret.unknown_a5 = this->unknown_a5;
  ret.tech_boost = this->tech_boost;
  ret.combo_type = this->combo_type;
  return ret;
}

ItemParameterTable::ArmorOrShieldV4 ItemParameterTable::ArmorOrShieldDCProtos::to_v4() const {
  ArmorOrShieldV4 ret;
  ret.base.id = this->base.id;
  ret.dfp = this->dfp;
  ret.evp = this->evp;
  ret.block_particle = this->block_particle;
  ret.block_effect = this->block_effect;
  ret.class_flags = this->class_flags;
  ret.required_level = this->required_level;
  ret.efr = this->efr;
  ret.eth = this->eth;
  ret.eic = this->eic;
  ret.edk = this->edk;
  ret.elt = this->elt;
  ret.dfp_range = this->dfp_range;
  ret.evp_range = this->evp_range;
  return ret;
}

ItemParameterTable::ArmorOrShieldV4 ItemParameterTable::ArmorOrShieldV1V2::to_v4() const {
  ArmorOrShieldV4 ret;
  ret.base.id = this->base.id;
  ret.dfp = this->dfp;
  ret.evp = this->evp;
  ret.block_particle = this->block_particle;
  ret.block_effect = this->block_effect;
  ret.class_flags = this->class_flags;
  ret.required_level = this->required_level;
  ret.efr = this->efr;
  ret.eth = this->eth;
  ret.eic = this->eic;
  ret.edk = this->edk;
  ret.elt = this->elt;
  ret.dfp_range = this->dfp_range;
  ret.evp_range = this->evp_range;
  ret.stat_boost = this->stat_boost;
  ret.tech_boost = this->tech_boost;
  ret.unknown_a2 = this->unknown_a2;
  return ret;
}

template <bool IsBigEndian>
ItemParameterTable::ArmorOrShieldV4 ItemParameterTable::ArmorOrShieldV3T<IsBigEndian>::to_v4() const {
  ArmorOrShieldV4 ret;
  ret.base.id = this->base.id.load();
  ret.base.type = this->base.type.load();
  ret.base.skin = this->base.skin.load();
  ret.dfp = this->dfp.load();
  ret.evp = this->evp.load();
  ret.block_particle = this->block_particle;
  ret.block_effect = this->block_effect;
  ret.class_flags = this->class_flags.load();
  ret.required_level = this->required_level;
  ret.efr = this->efr;
  ret.eth = this->eth;
  ret.eic = this->eic;
  ret.edk = this->edk;
  ret.elt = this->elt;
  ret.dfp_range = this->dfp_range;
  ret.evp_range = this->evp_range;
  ret.stat_boost = this->stat_boost;
  ret.tech_boost = this->tech_boost;
  ret.unknown_a2 = this->unknown_a2.load();
  return ret;
}

ItemParameterTable::UnitV4 ItemParameterTable::UnitDCProtos::to_v4() const {
  UnitV4 ret;
  ret.base.id = this->base.id;
  ret.stat = this->stat;
  ret.stat_amount = this->stat_amount;
  return ret;
}

ItemParameterTable::UnitV4 ItemParameterTable::UnitV1V2::to_v4() const {
  UnitV4 ret;
  ret.base.id = this->base.id;
  ret.stat = this->stat;
  ret.stat_amount = this->stat_amount;
  ret.modifier_amount = this->modifier_amount;
  return ret;
}

template <bool IsBigEndian>
ItemParameterTable::UnitV4 ItemParameterTable::UnitV3T<IsBigEndian>::to_v4() const {
  UnitV4 ret;
  ret.base.id = this->base.id.load();
  ret.base.type = this->base.type.load();
  ret.base.skin = this->base.skin.load();
  ret.stat = this->stat.load();
  ret.stat_amount = this->stat_amount.load();
  ret.modifier_amount = this->modifier_amount.load();
  return ret;
}

ItemParameterTable::MagV4 ItemParameterTable::MagV1::to_v4() const {
  MagV4 ret;
  ret.base.id = this->base.id;
  ret.feed_table = this->feed_table;
  ret.photon_blast = this->photon_blast;
  ret.activation = this->activation;
  ret.on_pb_full = this->on_pb_full;
  ret.on_low_hp = this->on_low_hp;
  ret.on_death = this->on_death;
  ret.on_boss = this->on_boss;
  ret.on_pb_full_flag = this->on_pb_full_flag;
  ret.on_low_hp_flag = this->on_low_hp_flag;
  ret.on_death_flag = this->on_death_flag;
  ret.on_boss_flag = this->on_boss_flag;
  return ret;
}

ItemParameterTable::MagV4 ItemParameterTable::MagV2::to_v4() const {
  MagV4 ret;
  ret.base.id = this->base.id;
  ret.feed_table = this->feed_table;
  ret.photon_blast = this->photon_blast;
  ret.activation = this->activation;
  ret.on_pb_full = this->on_pb_full;
  ret.on_low_hp = this->on_low_hp;
  ret.on_death = this->on_death;
  ret.on_boss = this->on_boss;
  ret.on_pb_full_flag = this->on_pb_full_flag;
  ret.on_low_hp_flag = this->on_low_hp_flag;
  ret.on_death_flag = this->on_death_flag;
  ret.on_boss_flag = this->on_boss_flag;
  ret.class_flags = this->class_flags;
  return ret;
}

template <bool IsBigEndian>
ItemParameterTable::MagV4 ItemParameterTable::MagV3T<IsBigEndian>::to_v4() const {
  MagV4 ret;
  ret.base.id = this->base.id.load();
  ret.base.type = this->base.type.load();
  ret.base.skin = this->base.skin.load();
  ret.feed_table = this->feed_table.load();
  ret.photon_blast = this->photon_blast;
  ret.activation = this->activation;
  ret.on_pb_full = this->on_pb_full;
  ret.on_low_hp = this->on_low_hp;
  ret.on_death = this->on_death;
  ret.on_boss = this->on_boss;
  ret.on_pb_full_flag = this->on_pb_full_flag;
  ret.on_low_hp_flag = this->on_low_hp_flag;
  ret.on_death_flag = this->on_death_flag;
  ret.on_boss_flag = this->on_boss_flag;
  ret.class_flags = this->class_flags.load();
  return ret;
}

ItemParameterTable::ToolV4 ItemParameterTable::ToolV1V2::to_v4() const {
  ToolV4 ret;
  ret.base.id = this->base.id;
  ret.amount = this->amount;
  ret.tech = this->tech;
  ret.cost = this->cost;
  ret.item_flag = this->item_flag;
  return ret;
}

template <bool IsBigEndian>
ItemParameterTable::ToolV4 ItemParameterTable::ToolV3T<IsBigEndian>::to_v4() const {
  ToolV4 ret;
  ret.base.id = this->base.id.load();
  ret.base.type = this->base.type.load();
  ret.base.skin = this->base.skin.load();
  ret.amount = this->amount.load();
  ret.tech = this->tech.load();
  ret.cost = this->cost.load();
  ret.item_flag = this->item_flag.load();
  return ret;
}

template <bool IsBigEndian>
size_t indirect_lookup_2d_count(const StringReader& r, size_t root_offset, size_t co_index) {
  using ArrayRefT = typename std::conditional_t<IsBigEndian, ItemParameterTable::ArrayRefBE, ItemParameterTable::ArrayRef>;
  return r.pget<ArrayRefT>(root_offset + sizeof(ArrayRefT) * co_index).count;
}

template <typename T, bool IsBigEndian>
const T& indirect_lookup_2d(const StringReader& r, size_t root_offset, size_t co_index, size_t item_index) {
  using ArrayRefT = typename std::conditional_t<IsBigEndian, ItemParameterTable::ArrayRefBE, ItemParameterTable::ArrayRef>;

  const auto& co = r.pget<ArrayRefT>(root_offset + sizeof(ArrayRefT) * co_index);
  if (item_index >= co.count) {
    throw out_of_range("item ID out of range");
  }
  return r.pget<T>(co.offset + sizeof(T) * item_index);
}

size_t ItemParameterTable::num_weapons_in_class(uint8_t data1_1) const {
  if (data1_1 >= this->num_weapon_classes) {
    throw out_of_range("weapon ID out of range");
  }
  if (this->offsets_dc_protos) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_dc_protos->weapon_table, data1_1);
  } else if (this->offsets_v1_v2) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v1_v2->weapon_table, data1_1);
  } else if (this->offsets_gc_nte) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_gc_nte->weapon_table, data1_1);
  } else if (this->offsets_v3_le) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v3_le->weapon_table, data1_1);
  } else if (this->offsets_v3_be) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_v3_be->weapon_table, data1_1);
  } else if (this->offsets_v4) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v4->weapon_table, data1_1);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

const ItemParameterTable::WeaponV4& ItemParameterTable::get_weapon(uint8_t data1_1, uint8_t data1_2) const {
  if (data1_1 >= this->num_weapon_classes) {
    throw out_of_range("weapon ID out of range");
  }

  if (this->offsets_v4) {
    return indirect_lookup_2d<WeaponV4, false>(this->r, this->offsets_v4->weapon_table, data1_1, data1_2);
  }

  uint16_t key = (data1_1 << 8) | data1_2;
  try {
    return this->parsed_weapons.at(key);
  } catch (const std::out_of_range&) {
    WeaponV4 def_v4;
    if (this->offsets_dc_protos) {
      def_v4 = indirect_lookup_2d<WeaponDCProtos, false>(this->r, this->offsets_dc_protos->weapon_table, data1_1, data1_2).to_v4();
    } else if (this->offsets_v1_v2) {
      def_v4 = indirect_lookup_2d<WeaponV1V2, false>(this->r, this->offsets_v1_v2->weapon_table, data1_1, data1_2).to_v4();
    } else if (this->offsets_gc_nte) {
      def_v4 = indirect_lookup_2d<WeaponGCNTE, true>(this->r, this->offsets_gc_nte->weapon_table, data1_1, data1_2).to_v4();
    } else if (this->offsets_v3_le) {
      def_v4 = indirect_lookup_2d<WeaponV3, false>(this->r, this->offsets_v3_le->weapon_table, data1_1, data1_2).to_v4();
    } else if (this->offsets_v3_be) {
      def_v4 = indirect_lookup_2d<WeaponV3BE, true>(this->r, this->offsets_v3_be->weapon_table, data1_1, data1_2).to_v4();
    } else {
      throw logic_error("table is not v2, v3, or v4");
    }
    return this->parsed_weapons.emplace(key, def_v4).first->second;
  }
}

size_t ItemParameterTable::num_armors_or_shields_in_class(uint8_t data1_1) const {
  if ((data1_1 < 1) || (data1_1 > 2)) {
    throw out_of_range("armor/shield class ID out of range");
  }
  if (this->offsets_dc_protos) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_dc_protos->armor_table, data1_1 - 1);
  } else if (this->offsets_v1_v2) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v1_v2->armor_table, data1_1 - 1);
  } else if (this->offsets_gc_nte) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_gc_nte->armor_table, data1_1 - 1);
  } else if (this->offsets_v3_le) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v3_le->armor_table, data1_1 - 1);
  } else if (this->offsets_v3_be) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_v3_be->armor_table, data1_1 - 1);
  } else if (this->offsets_v4) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v4->armor_table, data1_1 - 1);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

const ItemParameterTable::ArmorOrShieldV4& ItemParameterTable::get_armor_or_shield(uint8_t data1_1, uint8_t data1_2) const {
  if ((data1_1 < 1) || (data1_1 > 2)) {
    throw out_of_range("armor/shield class ID out of range");
  }

  if (this->offsets_v4) {
    return indirect_lookup_2d<ArmorOrShieldV4, false>(this->r, this->offsets_v4->armor_table, data1_1 - 1, data1_2);
  }

  auto& parsed_vec = (data1_1 == 2) ? this->parsed_shields : this->parsed_armors;
  try {
    const auto& ret = parsed_vec.at(data1_2);
    if (ret.base.id == 0xFFFFFFFF) {
      throw out_of_range("cache entry not populated");
    }
    return ret;
  } catch (const std::out_of_range&) {
    ArmorOrShieldV4 def_v4;

    if (this->offsets_dc_protos) {
      def_v4 = indirect_lookup_2d<ArmorOrShieldDCProtos, false>(this->r, this->offsets_dc_protos->armor_table, data1_1 - 1, data1_2).to_v4();
    } else if (this->offsets_v1_v2) {
      def_v4 = indirect_lookup_2d<ArmorOrShieldV1V2, false>(this->r, this->offsets_v1_v2->armor_table, data1_1 - 1, data1_2).to_v4();
    } else if (this->offsets_gc_nte) {
      def_v4 = indirect_lookup_2d<ArmorOrShieldV3BE, true>(this->r, this->offsets_gc_nte->armor_table, data1_1 - 1, data1_2).to_v4();
    } else if (this->offsets_v3_le) {
      def_v4 = indirect_lookup_2d<ArmorOrShieldV3, false>(this->r, this->offsets_v3_le->armor_table, data1_1 - 1, data1_2).to_v4();
    } else if (this->offsets_v3_be) {
      def_v4 = indirect_lookup_2d<ArmorOrShieldV3BE, true>(this->r, this->offsets_v3_be->armor_table, data1_1 - 1, data1_2).to_v4();
    } else {
      throw logic_error("table is not v2, v3, or v4");
    }
    if (data1_2 >= parsed_vec.size()) {
      parsed_vec.resize(data1_2 + 1);
    }
    parsed_vec[data1_2] = def_v4;
    return parsed_vec[data1_2];
  }
}

size_t ItemParameterTable::num_units() const {
  if (this->offsets_dc_protos) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_dc_protos->unit_table, 0);
  } else if (this->offsets_v1_v2) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v1_v2->unit_table, 0);
  } else if (this->offsets_gc_nte) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_gc_nte->unit_table, 0);
  } else if (this->offsets_v3_le) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v3_le->unit_table, 0);
  } else if (this->offsets_v3_be) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_v3_be->unit_table, 0);
  } else if (this->offsets_v4) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v4->unit_table, 0);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

const ItemParameterTable::UnitV4& ItemParameterTable::get_unit(uint8_t data1_2) const {
  if (this->offsets_v4) {
    return indirect_lookup_2d<UnitV4, false>(this->r, this->offsets_v4->unit_table, 0, data1_2);
  }

  try {
    const auto& ret = this->parsed_units.at(data1_2);
    if (ret.base.id == 0xFFFFFFFF) {
      throw out_of_range("cache entry not populated");
    }
    return ret;
  } catch (const std::out_of_range&) {
    UnitV4 def_v4;
    if (this->offsets_dc_protos) {
      def_v4 = indirect_lookup_2d<UnitDCProtos, false>(this->r, this->offsets_dc_protos->unit_table, 0, data1_2).to_v4();
    } else if (this->offsets_v1_v2) {
      def_v4 = indirect_lookup_2d<UnitV1V2, false>(this->r, this->offsets_v1_v2->unit_table, 0, data1_2).to_v4();
    } else if (this->offsets_gc_nte) {
      def_v4 = indirect_lookup_2d<UnitV3BE, true>(this->r, this->offsets_gc_nte->unit_table, 0, data1_2).to_v4();
    } else if (this->offsets_v3_le) {
      def_v4 = indirect_lookup_2d<UnitV3, false>(this->r, this->offsets_v3_le->unit_table, 0, data1_2).to_v4();
    } else if (this->offsets_v3_be) {
      def_v4 = indirect_lookup_2d<UnitV3BE, true>(this->r, this->offsets_v3_be->unit_table, 0, data1_2).to_v4();
    } else {
      throw logic_error("table is not v2, v3, or v4");
    }
    if (data1_2 >= this->parsed_units.size()) {
      this->parsed_units.resize(data1_2 + 1);
    }
    this->parsed_units[data1_2] = def_v4;
    return this->parsed_units[data1_2];
  }
}

size_t ItemParameterTable::num_mags() const {
  if (this->offsets_dc_protos) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_dc_protos->mag_table, 0);
  } else if (this->offsets_v1_v2) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v1_v2->mag_table, 0);
  } else if (this->offsets_gc_nte) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_gc_nte->mag_table, 0);
  } else if (this->offsets_v3_le) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v3_le->mag_table, 0);
  } else if (this->offsets_v3_be) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_v3_be->mag_table, 0);
  } else if (this->offsets_v4) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v4->mag_table, 0);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

const ItemParameterTable::MagV4& ItemParameterTable::get_mag(uint8_t data1_1) const {
  if (this->offsets_v4) {
    return indirect_lookup_2d<MagV4, false>(this->r, this->offsets_v4->mag_table, 0, data1_1);
  }

  try {
    const auto& ret = this->parsed_mags.at(data1_1);
    if (ret.base.id == 0xFFFFFFFF) {
      throw out_of_range("cache entry not populated");
    }
    return ret;
  } catch (const std::out_of_range&) {
    MagV4 def_v4;
    if (this->offsets_dc_protos) {
      def_v4 = indirect_lookup_2d<MagV1, false>(this->r, this->offsets_dc_protos->mag_table, 0, data1_1).to_v4();
    } else if (this->offsets_v1_v2) {
      if (is_v1(this->version)) {
        def_v4 = indirect_lookup_2d<MagV1, false>(this->r, this->offsets_v1_v2->mag_table, 0, data1_1).to_v4();
      } else {
        def_v4 = indirect_lookup_2d<MagV2, false>(this->r, this->offsets_v1_v2->mag_table, 0, data1_1).to_v4();
      }
    } else if (this->offsets_gc_nte) {
      def_v4 = indirect_lookup_2d<MagV3BE, true>(this->r, this->offsets_gc_nte->mag_table, 0, data1_1).to_v4();
    } else if (this->offsets_v3_le) {
      def_v4 = indirect_lookup_2d<MagV3, false>(this->r, this->offsets_v3_le->mag_table, 0, data1_1).to_v4();
    } else if (this->offsets_v3_be) {
      def_v4 = indirect_lookup_2d<MagV3BE, true>(this->r, this->offsets_v3_be->mag_table, 0, data1_1).to_v4();
    } else {
      throw logic_error("table is not v2, v3, or v4");
    }
    if (data1_1 >= this->parsed_mags.size()) {
      this->parsed_mags.resize(data1_1 + 1);
    }
    this->parsed_mags[data1_1] = def_v4;
    return this->parsed_mags[data1_1];
  }
}

size_t ItemParameterTable::num_tools_in_class(uint8_t data1_1) const {
  if (data1_1 >= this->num_tool_classes) {
    throw out_of_range("tool class ID out of range");
  }
  if (this->offsets_dc_protos) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_dc_protos->tool_table, data1_1);
  } else if (this->offsets_v1_v2) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v1_v2->tool_table, data1_1);
  } else if (this->offsets_gc_nte) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_gc_nte->tool_table, data1_1);
  } else if (this->offsets_v3_le) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v3_le->tool_table, data1_1);
  } else if (this->offsets_v3_be) {
    return indirect_lookup_2d_count<true>(this->r, this->offsets_v3_be->tool_table, data1_1);
  } else if (this->offsets_v4) {
    return indirect_lookup_2d_count<false>(this->r, this->offsets_v4->tool_table, data1_1);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

const ItemParameterTable::ToolV4& ItemParameterTable::get_tool(uint8_t data1_1, uint8_t data1_2) const {
  if (data1_1 >= this->num_tool_classes) {
    throw out_of_range("tool class ID out of range");
  }

  if (this->offsets_v4) {
    return indirect_lookup_2d<ToolV4, false>(this->r, this->offsets_v4->tool_table, data1_1, data1_2);
  }

  uint16_t key = (data1_1 << 8) | data1_2;
  try {
    return this->parsed_tools.at(key);
  } catch (const std::out_of_range&) {
    ToolV4 def_v4;

    if (this->offsets_dc_protos) {
      def_v4 = indirect_lookup_2d<ToolV1V2, false>(this->r, this->offsets_dc_protos->tool_table, data1_1, data1_2).to_v4();
    } else if (this->offsets_v1_v2) {
      def_v4 = indirect_lookup_2d<ToolV1V2, false>(this->r, this->offsets_v1_v2->tool_table, data1_1, data1_2).to_v4();
    } else if (this->offsets_gc_nte) {
      def_v4 = indirect_lookup_2d<ToolV3BE, true>(this->r, this->offsets_gc_nte->tool_table, data1_1, data1_2).to_v4();
    } else if (this->offsets_v3_le) {
      def_v4 = indirect_lookup_2d<ToolV3, false>(this->r, this->offsets_v3_le->tool_table, data1_1, data1_2).to_v4();
    } else if (this->offsets_v3_be) {
      def_v4 = indirect_lookup_2d<ToolV3BE, true>(this->r, this->offsets_v3_be->tool_table, data1_1, data1_2).to_v4();
    } else {
      throw logic_error("table is not v2, v3, or v4");
    }

    return this->parsed_tools.emplace(key, def_v4).first->second;
  }
}

template <typename ToolDefT, bool IsBigEndian>
pair<uint8_t, uint8_t> ItemParameterTable::find_tool_by_id_t(uint32_t tool_table_offset, uint32_t item_id) const {
  const auto* cos = &this->r.pget<ArrayRefT<IsBigEndian>>(
      tool_table_offset, this->num_tool_classes * sizeof(ArrayRefT<IsBigEndian>));
  for (size_t z = 0; z < this->num_tool_classes; z++) {
    const auto& co = cos[z];
    const auto* defs = &this->r.pget<ToolDefT>(co.offset, sizeof(ToolDefT) * co.count);
    for (size_t y = 0; y < co.count; y++) {
      if (defs[y].base.id == item_id) {
        return make_pair(z, y);
      }
    }
  }
  throw out_of_range(string_printf("invalid tool class %08" PRIX32, item_id));
}

pair<uint8_t, uint8_t> ItemParameterTable::find_tool_by_id(uint32_t item_id) const {
  if (this->offsets_dc_protos) {
    return this->find_tool_by_id_t<ToolV1V2, false>(this->offsets_dc_protos->tool_table, item_id);
  } else if (this->offsets_v1_v2) {
    return this->find_tool_by_id_t<ToolV1V2, false>(this->offsets_v1_v2->tool_table, item_id);
  } else if (this->offsets_gc_nte) {
    return this->find_tool_by_id_t<ToolV3BE, true>(this->offsets_gc_nte->tool_table, item_id);
  } else if (this->offsets_v3_le) {
    return this->find_tool_by_id_t<ToolV3, false>(this->offsets_v3_le->tool_table, item_id);
  } else if (this->offsets_v3_be) {
    return this->find_tool_by_id_t<ToolV3BE, true>(this->offsets_v3_be->tool_table, item_id);
  } else if (this->offsets_v4) {
    return this->find_tool_by_id_t<ToolV4, false>(this->offsets_v4->tool_table, item_id);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

template <bool IsBigEndian, typename OffsetsT>
float ItemParameterTable::get_sale_divisor_t(const OffsetsT* offsets, uint8_t data1_0, uint8_t data1_1) const {
  using FloatT = typename std::conditional<IsBigEndian, be_float, le_float>::type;

  switch (data1_0) {
    case 0:
      if (data1_1 >= this->num_weapon_classes) {
        return 0.0f;
      }
      return this->r.pget<FloatT>(offsets->weapon_sale_divisor_table + data1_1 * sizeof(FloatT));

    case 1: {
      const auto& divisors = this->r.pget<NonWeaponSaleDivisorsT<IsBigEndian>>(offsets->sale_divisor_table);
      switch (data1_1) {
        case 1:
          return divisors.armor_divisor;
        case 2:
          return divisors.shield_divisor;
        case 3:
          return divisors.unit_divisor;
      }
      return 0.0f;
    }

    case 2: {
      const auto& divisors = this->r.pget<NonWeaponSaleDivisorsT<IsBigEndian>>(offsets->sale_divisor_table);
      return divisors.mag_divisor;
    }

    default:
      return 0.0f;
  }
}

float ItemParameterTable::get_sale_divisor(uint8_t data1_0, uint8_t data1_1) const {
  if (this->offsets_dc_protos) {
    return this->get_sale_divisor_t<false>(this->offsets_dc_protos, data1_0, data1_1);
  } else if (this->offsets_v1_v2) {
    return this->get_sale_divisor_t<false>(this->offsets_v1_v2, data1_0, data1_1);
  } else if (this->offsets_gc_nte) {
    return this->get_sale_divisor_t<true>(this->offsets_gc_nte, data1_0, data1_1);
  } else if (this->offsets_v3_le) {
    return this->get_sale_divisor_t<false>(this->offsets_v3_le, data1_0, data1_1);
  } else if (this->offsets_v3_be) {
    return this->get_sale_divisor_t<true>(this->offsets_v3_be, data1_0, data1_1);
  } else if (this->offsets_v4) {
    return this->get_sale_divisor_t<false>(this->offsets_v4, data1_0, data1_1);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

const ItemParameterTable::MagFeedResult& ItemParameterTable::get_mag_feed_result(
    uint8_t table_index, uint8_t item_index) const {
  if (table_index >= 8) {
    throw out_of_range("invalid mag feed table index");
  }
  if (item_index >= 11) {
    throw out_of_range("invalid mag feed item index");
  }

  uint32_t offset;
  if (this->offsets_dc_protos) {
    const auto& table_offsets = this->r.pget<MagFeedResultsListOffsets>(this->offsets_dc_protos->mag_feed_table);
    offset = table_offsets.offsets[table_index];
  } else if (this->offsets_v1_v2) {
    const auto& table_offsets = this->r.pget<MagFeedResultsListOffsets>(this->offsets_v1_v2->mag_feed_table);
    offset = table_offsets.offsets[table_index];
  } else if (this->offsets_gc_nte) {
    const auto& table_offsets = this->r.pget<MagFeedResultsListOffsetsBE>(this->offsets_gc_nte->mag_feed_table);
    offset = table_offsets.offsets[table_index];
  } else if (this->offsets_v3_le) {
    const auto& table_offsets = this->r.pget<MagFeedResultsListOffsets>(this->offsets_v3_le->mag_feed_table);
    offset = table_offsets.offsets[table_index];
  } else if (this->offsets_v3_be) {
    const auto& table_offsets = this->r.pget<MagFeedResultsListOffsetsBE>(this->offsets_v3_be->mag_feed_table);
    offset = table_offsets.offsets[table_index];
  } else if (this->offsets_v4) {
    const auto& table_offsets = this->r.pget<MagFeedResultsListOffsets>(this->offsets_v4->mag_feed_table);
    offset = table_offsets.offsets[table_index];
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }

  return this->r.pget<MagFeedResultsList>(offset)[item_index];
}

uint8_t ItemParameterTable::get_item_stars(uint32_t item_id) const {
  uint32_t base_offset;
  if (this->offsets_dc_protos) {
    base_offset = this->offsets_dc_protos->star_value_table;
  } else if (this->offsets_v1_v2) {
    base_offset = this->offsets_v1_v2->star_value_table;
  } else if (this->offsets_gc_nte) {
    base_offset = this->offsets_gc_nte->star_value_table;
  } else if (this->offsets_v3_le) {
    base_offset = this->offsets_v3_le->star_value_table;
  } else if (this->offsets_v3_be) {
    base_offset = this->offsets_v3_be->star_value_table;
  } else if (this->offsets_v4) {
    base_offset = this->offsets_v4->star_value_table;
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }

  return ((item_id >= this->item_stars_first_id) && (item_id < this->item_stars_last_id))
      ? this->r.pget_u8(base_offset + item_id - this->item_stars_first_id)
      : 0;
}

uint8_t ItemParameterTable::get_special_stars(uint8_t special) const {
  return ((special & 0x3F) && !(special & 0x80))
      ? this->get_item_stars(special + this->special_stars_begin_index)
      : 0;
}

const ItemParameterTable::Special& ItemParameterTable::get_special(uint8_t special) const {
  special &= 0x3F;
  if (special >= this->num_specials) {
    throw out_of_range("invalid special index");
  }

  if (this->offsets_dc_protos) {
    return this->r.pget<Special>(this->offsets_dc_protos->special_data_table + sizeof(Special) * special);
  } else if (this->offsets_v1_v2) {
    return this->r.pget<Special>(this->offsets_v1_v2->special_data_table + sizeof(Special) * special);
  } else if (this->offsets_v3_le) {
    return this->r.pget<Special>(this->offsets_v3_le->special_data_table + sizeof(Special) * special);
  } else if (this->offsets_gc_nte) {
    if ((special >= this->parsed_specials.size()) || (this->parsed_specials[special].type != 0xFFFF)) {
      if (special >= this->parsed_specials.size()) {
        this->parsed_specials.resize(special + 1);
      }
      const auto& sp_be = this->r.pget<SpecialBE>(this->offsets_gc_nte->special_data_table + sizeof(SpecialBE) * special);
      this->parsed_specials[special].type = sp_be.type.load();
      this->parsed_specials[special].amount = sp_be.amount.load();
    }
    return this->parsed_specials[special];
  } else if (this->offsets_v3_be) {
    if ((special >= this->parsed_specials.size()) || (this->parsed_specials[special].type != 0xFFFF)) {
      if (special >= this->parsed_specials.size()) {
        this->parsed_specials.resize(special + 1);
      }
      const auto& sp_be = this->r.pget<SpecialBE>(this->offsets_v3_be->special_data_table + sizeof(SpecialBE) * special);
      this->parsed_specials[special].type = sp_be.type.load();
      this->parsed_specials[special].amount = sp_be.amount.load();
    }
    return this->parsed_specials[special];
  } else if (this->offsets_v4) {
    return this->r.pget<Special>(this->offsets_v4->special_data_table + sizeof(Special) * special);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

uint8_t ItemParameterTable::get_max_tech_level(uint8_t char_class, uint8_t tech_num) const {
  if (char_class >= 12) {
    throw out_of_range("invalid character class");
  }
  if (tech_num >= 19) {
    throw out_of_range("invalid technique number");
  }

  if (this->offsets_dc_protos || this->offsets_v1_v2) {
    if ((tech_num == 14) || (tech_num == 17)) { // Ryuker or Reverser
      return 0;
    } else {
      return ((char_class == 6) || (char_class == 7) || (char_class == 8) || (char_class == 10)) ? 29 : 14;
    }
  } else if (this->offsets_gc_nte) {
    return r.pget_u8(this->offsets_gc_nte->max_tech_level_table + tech_num * 12 + char_class);
  } else if (this->offsets_v3_le) {
    return r.pget_u8(this->offsets_v3_le->max_tech_level_table + tech_num * 12 + char_class);
  } else if (this->offsets_v3_be) {
    return r.pget_u8(this->offsets_v3_be->max_tech_level_table + tech_num * 12 + char_class);
  } else if (this->offsets_v4) {
    return r.pget_u8(this->offsets_v4->max_tech_level_table + tech_num * 12 + char_class);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

uint8_t ItemParameterTable::get_weapon_v1_replacement(uint8_t data1_1) const {
  uint32_t offset;
  if (this->offsets_dc_protos) {
    offset = this->offsets_dc_protos->v1_replacement_table;
  } else if (this->offsets_v1_v2) {
    offset = this->offsets_v1_v2->v1_replacement_table;
  } else if (this->offsets_gc_nte) {
    offset = this->offsets_gc_nte->v1_replacement_table;
  } else if (this->offsets_v3_le) {
    offset = this->offsets_v3_le->v1_replacement_table;
  } else if (this->offsets_v3_be) {
    offset = this->offsets_v3_be->v1_replacement_table;
  } else if (this->offsets_v4) {
    offset = this->offsets_v4->v1_replacement_table;
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }

  return (data1_1 < this->num_weapon_classes)
      ? this->r.pget_u8(offset + data1_1)
      : 0x00;
}

uint32_t ItemParameterTable::get_item_id(const ItemData& item) const {
  switch (item.data1[0]) {
    case 0:
      return this->get_weapon(item.data1[1], item.data1[2]).base.id;
    case 1:
      if (item.data1[1] == 3) {
        return this->get_unit(item.data1[2]).base.id;
      } else if ((item.data1[1] == 1) || (item.data1[1] == 2)) {
        return this->get_armor_or_shield(item.data1[1], item.data1[2]).base.id;
      }
      throw runtime_error("invalid item");
    case 2:
      return this->get_mag(item.data1[1]).base.id;
    case 3:
      if (item.data1[1] == 2) {
        return this->get_tool(2, item.data1[4]).base.id;
      } else {
        return this->get_tool(item.data1[1], item.data1[2]).base.id;
      }
      throw logic_error("this should be impossible");
    case 4:
      throw runtime_error("item is meseta and therefore has no definition");
    default:
      throw runtime_error("invalid item");
  }
}

uint32_t ItemParameterTable::get_item_team_points(const ItemData& item) const {
  switch (item.data1[0]) {
    case 0:
      return this->get_weapon(item.data1[1], item.data1[2]).base.team_points;
    case 1:
      if (item.data1[1] == 3) {
        return this->get_unit(item.data1[2]).base.team_points;
      } else if ((item.data1[1] == 1) || (item.data1[1] == 2)) {
        return this->get_armor_or_shield(item.data1[1], item.data1[2]).base.team_points;
      }
      throw runtime_error("invalid item");
    case 2:
      return this->get_mag(item.data1[1]).base.team_points;
    case 3:
      if (item.data1[1] == 2) {
        return this->get_tool(2, item.data1[4]).base.team_points;
      } else {
        return this->get_tool(item.data1[1], item.data1[2]).base.team_points;
      }
      throw logic_error("this should be impossible");
    case 4:
      throw runtime_error("item is meseta and therefore has no definition");
    default:
      throw runtime_error("invalid item");
  }
}

uint8_t ItemParameterTable::get_item_base_stars(const ItemData& item) const {
  if (item.data1[0] == 2) {
    return (item.data1[1] >= this->first_rare_mag_index) ? 12 : 0;
  } else if (item.data1[0] < 2) {
    return this->get_item_stars(this->get_item_id(item));
  } else if (item.data1[0] == 3) {
    const auto& def = (item.data1[1] == 2)
        ? this->get_tool(2, item.data1[4])
        : this->get_tool(item.data1[1], item.data1[2]);
    return (def.item_flag & 0x80) ? 12 : 0;
  } else {
    return 0;
  }
}

uint8_t ItemParameterTable::get_item_adjusted_stars(const ItemData& item, bool ignore_unidentified) const {
  uint8_t ret = this->get_item_base_stars(item);
  if (item.data1[0] == 0) {
    bool is_unidentified = (!ignore_unidentified) && (item.data1[4] & 0x80);
    if (ret < 9) {
      if (!is_unidentified) {
        ret += this->get_special_stars(item.data1[4]);
      }
    } else if (is_unidentified) {
      ret = 0;
    }
  } else if (item.data1[0] == 1) {
    if (item.data1[1] == 3) {
      int16_t unit_bonus = item.get_unit_bonus();
      if (unit_bonus < 0) {
        ret--;
      } else if (unit_bonus > 0) {
        ret++;
      }
    }
  }
  return min<uint8_t>(ret, 12);
}

bool ItemParameterTable::is_item_rare(const ItemData& item) const {
  try {
    return (this->get_item_base_stars(item) >= 9);
  } catch (const out_of_range&) {
    return false;
  }
}

bool ItemParameterTable::is_unsealable_item(uint8_t data1_0, uint8_t data1_1, uint8_t data1_2) const {
  uint32_t offset, count;
  if (this->offsets_dc_protos || this->offsets_v1_v2 || this->offsets_gc_nte) {
    return false;
  } else if (this->offsets_v3_le) {
    const auto& co = this->r.pget<ArrayRef>(this->offsets_v3_le->unsealable_table);
    offset = co.offset;
    count = co.count;
  } else if (this->offsets_v3_be) {
    const auto& co = this->r.pget<ArrayRefBE>(this->offsets_v3_be->unsealable_table);
    offset = co.offset;
    count = co.count;
  } else if (this->offsets_v4) {
    const auto& co = this->r.pget<ArrayRef>(this->offsets_v4->unsealable_table);
    offset = co.offset;
    count = co.count;
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }

  const auto* defs = &this->r.pget<UnsealableItem>(offset, count * sizeof(UnsealableItem));
  for (size_t z = 0; z < count; z++) {
    if ((defs[z].item[0] == data1_0) &&
        (defs[z].item[1] == data1_1) &&
        (defs[z].item[2] == data1_2)) {
      return true;
    }
  }
  return false;
}

bool ItemParameterTable::is_unsealable_item(const ItemData& item) const {
  return this->is_unsealable_item(item.data1[0], item.data1[1], item.data1[2]);
}

const ItemParameterTable::ItemCombination& ItemParameterTable::get_item_combination(
    const ItemData& used_item, const ItemData& equipped_item) const {
  for (const auto& def : this->get_all_combinations_for_used_item(used_item)) {
    if ((def.equipped_item[0] == 0xFF || def.equipped_item[0] == equipped_item.data1[0]) &&
        (def.equipped_item[1] == 0xFF || def.equipped_item[1] == equipped_item.data1[1]) &&
        (def.equipped_item[2] == 0xFF || def.equipped_item[2] == equipped_item.data1[2])) {
      return def;
    }
  }
  throw out_of_range("no item combination applies");
}

const std::vector<ItemParameterTable::ItemCombination>& ItemParameterTable::get_all_combinations_for_used_item(
    const ItemData& used_item) const {
  try {
    uint32_t key = (used_item.data1[0] << 16) | (used_item.data1[1] << 8) | used_item.data1[2];
    return this->get_all_item_combinations().at(key);
  } catch (const out_of_range&) {
    static const vector<ItemCombination> ret;
    return ret;
  }
}

const std::map<uint32_t, std::vector<ItemParameterTable::ItemCombination>>& ItemParameterTable::get_all_item_combinations() const {
  if (this->item_combination_index.empty()) {
    uint32_t offset, count;
    if (this->offsets_dc_protos || this->offsets_v1_v2 || this->offsets_gc_nte) {
      static const std::map<uint32_t, std::vector<ItemParameterTable::ItemCombination>> empty_map;
      return empty_map;
    } else if (this->offsets_v3_le) {
      const auto& co = this->r.pget<ArrayRef>(this->offsets_v3_le->combination_table);
      offset = co.offset;
      count = co.count;
    } else if (this->offsets_v3_be) {
      const auto& co = this->r.pget<ArrayRefBE>(this->offsets_v3_be->combination_table);
      offset = co.offset;
      count = co.count;
    } else if (this->offsets_v4) {
      const auto& co = this->r.pget<ArrayRef>(this->offsets_v4->combination_table);
      offset = co.offset;
      count = co.count;
    } else {
      throw logic_error("table is not v2, v3, or v4");
    }

    const auto* defs = &this->r.pget<ItemCombination>(offset, count * sizeof(ItemCombination));
    for (size_t z = 0; z < count; z++) {
      const auto& def = defs[z];
      uint32_t key = (def.used_item[0] << 16) | (def.used_item[1] << 8) | def.used_item[2];
      this->item_combination_index[key].emplace_back(def);
    }
  }
  return this->item_combination_index;
}

template <bool IsBigEndian>
size_t ItemParameterTable::num_events_t(uint32_t base_offset) const {
  return this->r.pget<ArrayRefT<IsBigEndian>>(base_offset).count;
}

size_t ItemParameterTable::num_events() const {
  if (this->offsets_dc_protos || this->offsets_v1_v2 || this->offsets_gc_nte) {
    return 0;
  } else if (this->offsets_v3_le) {
    return this->num_events_t<false>(this->offsets_v3_le->unwrap_table);
  } else if (this->offsets_v3_be) {
    return this->num_events_t<true>(this->offsets_v3_be->unwrap_table);
  } else if (this->offsets_v4) {
    return this->num_events_t<false>(this->offsets_v4->unwrap_table);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

template <bool IsBigEndian>
std::pair<const ItemParameterTable::EventItem*, size_t> ItemParameterTable::get_event_items_t(
    uint32_t base_offset, uint8_t event_number) const {
  const auto& co = this->r.pget<ArrayRefT<IsBigEndian>>(base_offset);
  if (event_number >= co.count) {
    throw out_of_range("invalid event number");
  }
  const auto& event_co = this->r.pget<ArrayRefT<IsBigEndian>>(co.offset + sizeof(ArrayRefT<IsBigEndian>) * event_number);
  const auto* defs = &this->r.pget<EventItem>(event_co.offset, event_co.count * sizeof(EventItem));
  return make_pair(defs, event_co.count);
}

std::pair<const ItemParameterTable::EventItem*, size_t> ItemParameterTable::get_event_items(uint8_t event_number) const {
  if (this->offsets_dc_protos || this->offsets_v1_v2 || this->offsets_gc_nte) {
    return make_pair(nullptr, 0);
  } else if (this->offsets_v3_le) {
    return this->get_event_items_t<false>(this->offsets_v3_le->unwrap_table, event_number);
  } else if (this->offsets_v3_be) {
    return this->get_event_items_t<true>(this->offsets_v3_be->unwrap_table, event_number);
  } else if (this->offsets_v4) {
    return this->get_event_items_t<false>(this->offsets_v4->unwrap_table, event_number);
  } else {
    throw logic_error("table is not v2, v3, or v4");
  }
}

size_t ItemParameterTable::price_for_item(const ItemData& item) const {
  switch (item.data1[0]) {
    case 0: {
      if (item.data1[4] & 0x80) {
        return 8;
      }
      if (this->is_item_rare(item)) {
        return 80;
      }

      float sale_divisor = this->get_sale_divisor(item.data1[0], item.data1[1]);
      if (sale_divisor == 0.0) {
        throw runtime_error("item sale divisor is zero");
      }

      const auto& def = this->get_weapon(item.data1[1], item.data1[2]);
      double atp_max = def.atp_max + item.data1[3];
      double atp_factor = ((atp_max * atp_max) / sale_divisor);

      double bonus_factor = 0.0;
      for (size_t bonus_index = 0; bonus_index < 3; bonus_index++) {
        uint8_t bonus_type = item.data1[(2 * bonus_index) + 6];
        if ((bonus_type > 0) && (bonus_type < 6)) {
          bonus_factor += item.data1[(2 * bonus_index) + 7];
        }
        bonus_factor += 100.0;
      }

      size_t special_stars = this->get_special_stars(item.data1[4]);
      double special_stars_factor = 1000.0 * special_stars * special_stars;

      return special_stars_factor + ((atp_factor * bonus_factor) / 100.0);
    }

    case 1: {
      if (this->is_item_rare(item)) {
        return 80;
      }

      if (item.data1[1] == 3) { // Unit
        return this->get_item_adjusted_stars(item) * this->get_sale_divisor(item.data1[0], 3);
      }

      double sale_divisor = (double)this->get_sale_divisor(item.data1[0], item.data1[1]);
      if (sale_divisor == 0.0) {
        throw runtime_error("item sale divisor is zero");
      }

      int16_t def_bonus = item.get_armor_or_shield_defense_bonus();
      int16_t evp_bonus = item.get_common_armor_evasion_bonus();

      const auto& def = this->get_armor_or_shield(item.data1[1], item.data1[2]);
      double power_factor = def.dfp + def.evp + def_bonus + evp_bonus;
      double power_factor_floor = static_cast<int32_t>((power_factor * power_factor) / sale_divisor);
      return power_factor_floor + (70.0 * static_cast<double>(item.data1[5] + 1) * static_cast<double>(def.required_level + 1));
    }

    case 2:
      return (item.data1[2] + 1) * this->get_sale_divisor(2, item.data1[1]);

    case 3: {
      const auto& def = (item.data1[1] == 2)
          ? this->get_tool(2, item.data1[4])
          : this->get_tool(item.data1[1], item.data1[2]);
      return def.cost * ((item.data1[1] == 2) ? (item.data1[2] + 1) : 1);
    }

    case 4:
      return item.data2d;

    default:
      throw runtime_error("invalid item");
  }
  throw logic_error("this should be impossible");
}

MagEvolutionTable::MagEvolutionTable(shared_ptr<const string> data)
    : data(data),
      r(*data) {
  size_t offset_table_offset = this->r.pget_u32l(this->data->size() - 0x10);
  this->offsets = &r.pget<TableOffsets>(offset_table_offset);
}

uint8_t MagEvolutionTable::get_evolution_number(uint8_t data1_1) const {
  const auto& table = this->r.pget<EvolutionNumberTable>(this->offsets->evolution_number);
  return table.values[data1_1];
}