"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var importer_exports = {};
__export(importer_exports, {
  TIERS: () => TIERS,
  fetch: () => fetch,
  getStatisticsURL: () => getStatisticsURL,
  importAll: () => importAll
});
module.exports = __toCommonJS(importer_exports);
var http = __toESM(require("http"));
var https = __toESM(require("https"));
var url = __toESM(require("url"));
var util = __toESM(require("util"));
var smogon = __toESM(require("smogon"));
var import_lib = require("../../lib");
var import_dex = require("../../sim/dex");
var import_team_validator = require("../../sim/team-validator");
import_dex.Dex.includeModData();
const TIERS = /* @__PURE__ */ new Set([
  "ubers",
  "ou",
  "uu",
  "ru",
  "nu",
  "pu",
  "zu",
  "lc",
  "cap",
  "nationaldex",
  "doublesou",
  "battlespotsingles",
  "battlespotdoubles",
  "battlestadiumsingles",
  // UGH
  "battlestadiumsinglesseries2",
  "battlestadiumsinglesregulationc",
  //
  "vgc2016",
  "vgc2017",
  "vgc2018",
  "vgc2019ultraseries",
  "vgc2020",
  "vgc2023regulatione",
  "vgc",
  "1v1",
  "anythinggoes",
  "nationaldexag",
  "almostanyability",
  "balancedhackmons",
  "letsgoou",
  "monotype",
  "purehackmons",
  "nationaldexmonotype"
]);
const FORMATS = /* @__PURE__ */ new Map();
const VALIDATORS = /* @__PURE__ */ new Map();
for (let gen = 1; gen <= 9; gen++) {
  for (const tier of TIERS) {
    const format = import_dex.Dex.formats.get(`gen${gen}${tier}`);
    if (format.effectType === "Format") {
      FORMATS.set(format.id, { gen, format });
      VALIDATORS.set(format.id, new import_team_validator.TeamValidator(format));
    }
  }
}
async function importAll() {
  const index = await request(smogon.Statistics.URL);
  const imports = [];
  for (let gen = 1; gen <= 9; gen++) {
    imports.push(importGen(gen, index));
  }
  return Promise.all(imports);
}
async function importGen(gen, index) {
  const data = {};
  const smogonSetsByFormat = {};
  const thirdPartySetsByFormat = {};
  const numByFormat = {};
  const imports = [];
  const dex = import_dex.Dex.forFormat(`gen${gen}ou`);
  for (const id in dex.data.Pokedex) {
    if (!eligible(dex, id))
      continue;
    const species = dex.species.get(id);
    if (species.battleOnly)
      continue;
    imports.push(importSmogonSets(dex.species.get(id).name, gen, smogonSetsByFormat, numByFormat));
  }
  await Promise.all(imports);
  for (const { format, gen: g } of FORMATS.values()) {
    if (g !== gen)
      continue;
    if (smogonSetsByFormat[format.id] && Object.keys(smogonSetsByFormat[format.id]).length) {
      data[format.id] = {};
      data[format.id]["dex"] = smogonSetsByFormat[format.id];
      report(format, numByFormat[format.id], "dex");
    }
    for (const source in thirdPartySetsByFormat) {
      if (thirdPartySetsByFormat[source][format.id] && Object.keys(thirdPartySetsByFormat[source][format.id]).length) {
        data[format.id] = data[format.id] || {};
        data[format.id][source] = thirdPartySetsByFormat[source][format.id];
      }
    }
    const stats = await getStatisticsURL(index, format);
    if (!stats)
      continue;
    try {
      const statistics = smogon.Statistics.process(await request(stats.url));
      const sets = importUsageBasedSets(gen, format, statistics, stats.count);
      if (Object.keys(sets).length) {
        data[format.id] = data[format.id] || {};
        data[format.id]["stats"] = sets;
      }
      data[format.id] = data[format.id] || {};
    } catch (err) {
      error(`${stats.url} = ${err}`);
    }
  }
  return data;
}
function eligible(dex, id) {
  const gen = toGen(dex, id);
  if (!gen || gen > dex.gen)
    return false;
  const species = dex.species.get(id);
  if (["Mega", "Primal", "Ultra"].some((f) => species.forme.startsWith(f)))
    return true;
  const unique = ["darmanitan", "meloetta", "greninja", "zygarde"];
  const similar = ["pichu", "pikachu", "genesect", "basculin", "magearna", "keldeo", "vivillon"];
  if (species.battleOnly && !unique.some((f) => id.startsWith(f)))
    return false;
  const capNFE = species.isNonstandard === "CAP" && species.nfe;
  return !id.endsWith("totem") && !capNFE && !similar.some((f) => id.startsWith(f) && id !== f);
}
function toGen(dex, name) {
  const pokemon = dex.species.get(name);
  if (pokemon.isNonstandard === "LGPE")
    return 7;
  if (!pokemon.exists || pokemon.isNonstandard && pokemon.isNonstandard !== "CAP")
    return void 0;
  if (pokemon.gen)
    return pokemon.gen;
  const n = pokemon.num;
  if (n > 905)
    return 9;
  if (n > 810)
    return 8;
  if (n > 721)
    return 7;
  if (n > 649)
    return 6;
  if (n > 493)
    return 5;
  if (n > 386)
    return 4;
  if (n > 251)
    return 3;
  if (n > 151)
    return 2;
  if (n > 0)
    return 1;
}
async function importSmogonSets(pokemon, gen, setsByFormat, numByFormat) {
  const analysesByFormat = await getAnalysesByFormat(pokemon, gen);
  if (!analysesByFormat)
    return;
  for (const [format, analyses] of analysesByFormat.entries()) {
    const dex = import_dex.Dex.forFormat(format);
    let setsForPokemon = setsByFormat[format.id];
    if (!setsForPokemon) {
      setsForPokemon = {};
      setsByFormat[format.id] = setsForPokemon;
    }
    let baseSpecies = dex.species.get(pokemon);
    if (baseSpecies.baseSpecies !== baseSpecies.name)
      baseSpecies = dex.species.get(baseSpecies.baseSpecies);
    const battleOnlyFormes = [];
    if (baseSpecies.otherFormes) {
      for (const forme of baseSpecies.otherFormes) {
        const formeSpecies = dex.species.get(forme);
        if (formeSpecies.battleOnly && eligible(dex, (0, import_dex.toID)(formeSpecies))) {
          battleOnlyFormes.push(formeSpecies);
        }
      }
    }
    for (const analysis of analyses) {
      for (const moveset of analysis.movesets) {
        const set = movesetToPokemonSet(dex, format, pokemon, moveset);
        const name = cleanName(moveset.name);
        addSmogonSet(dex, format, pokemon, name, set, setsForPokemon, numByFormat);
        for (const battleOnlyForme of battleOnlyFormes) {
          const s = { ...set };
          if (!format.id.includes("balancedhackmons"))
            s.ability = battleOnlyForme.abilities[0];
          if (typeof battleOnlyForme.battleOnly !== "string") {
            if (!battleOnlyForme.battleOnly.includes(pokemon))
              continue;
            const species = dex.species.get(pokemon);
            const disambiguated = `${name} - ${species.baseForme || species.forme}`;
            addSmogonSet(dex, format, battleOnlyForme.name, disambiguated, s, setsForPokemon, numByFormat, pokemon);
          } else if (battleOnlyForme.battleOnly === pokemon) {
            addSmogonSet(dex, format, battleOnlyForme.name, name, s, setsForPokemon, numByFormat);
          }
        }
      }
    }
  }
}
function addSmogonSet(dex, format, pokemon, name, set, setsForPokemon, numByFormat, outOfBattleSpeciesName) {
  if (validSet("dex", dex, format, pokemon, name, set, outOfBattleSpeciesName)) {
    setsForPokemon[pokemon] = setsForPokemon[pokemon] || {};
    setsForPokemon[pokemon][name] = set;
    numByFormat[format.id] = (numByFormat[format.id] || 0) + 1;
  }
}
function cleanName(name) {
  return name.replace(/"/g, `'`);
}
function movesetToPokemonSet(dex, format, pokemon, set) {
  const level = getLevel(format, set.levels[0]);
  return {
    level: level === 100 ? void 0 : level,
    moves: set.moveslots.map((ms) => ms[0]).map((s) => s.type ? `${s.move} ${s.type}` : s.move),
    ability: fixedAbility(dex, pokemon, set.abilities[0]),
    item: set.items[0] === "No Item" ? void 0 : set.items[0],
    nature: set.natures[0],
    teraType: set.teratypes ? set.teratypes[0] : void 0,
    ivs: toStatsTable(set.ivconfigs[0], 31),
    evs: toStatsTable(set.evconfigs[0])
  };
}
function toStatsTable(stats, elide = 0) {
  if (!stats)
    return void 0;
  const s = {};
  let stat;
  for (stat in stats) {
    const val = stats[stat];
    if (val !== elide)
      s[stat] = val;
  }
  return s;
}
function fixedAbility(dex, pokemon, ability) {
  if (dex.gen <= 2)
    return void 0;
  const species = dex.species.get(pokemon);
  if (ability && !["Mega", "Primal", "Ultra"].some((f) => species.forme.startsWith(f)))
    return ability;
  return species.abilities[0];
}
function validSet(source, dex, format, pokemon, name, set, outOfBattleSpeciesName) {
  if (skip(dex, format, pokemon, set))
    return false;
  const pset = toPokemonSet(dex, format, pokemon, set, outOfBattleSpeciesName);
  let invalid = VALIDATORS.get(format.id).validateSet(pset, {});
  if (!invalid)
    return true;
  if (invalid.length === 1 && invalid[0].includes("must be shiny")) {
    set.shiny = true;
    pset.shiny = true;
    invalid = VALIDATORS.get(format.id).validateSet(pset, {});
    if (!invalid)
      return true;
  }
  if (format.id === "gen4ubers" && invalid.includes(`${pokemon} is banned.`))
    return true;
  const title = `${format.name}: ${pokemon} (${name})'`;
  const details = `${JSON.stringify(set)} = ${invalid.join(", ")}`;
  console.error(color(`${source} Invalid set ${title}: ${details}`, 90));
  return false;
}
function skip(dex, format, pokemon, set) {
  const { gen } = FORMATS.get(format.id);
  const hasMove = (m) => set.moves?.includes(m);
  const bh = format.id.includes("balancedhackmons");
  if (pokemon === "Groudon-Primal" && set.item !== "Red Orb")
    return true;
  if (pokemon === "Kyogre-Primal" && set.item !== "Blue Orb" && !(bh && gen === 7))
    return true;
  if (bh)
    return false;
  if (dex.species.get(pokemon).forme.startsWith("Mega")) {
    if (pokemon === "Rayquaza-Mega") {
      return format.id.includes("ubers") || !hasMove("Dragon Ascent");
    } else {
      return dex.items.get(set.item).megaStone !== pokemon;
    }
  }
  if (pokemon === "Necrozma-Ultra" && set.item !== "Ultranecrozium Z")
    return true;
  if (pokemon === "Greninja-Ash" && set.ability !== "Battle Bond")
    return true;
  if (pokemon === "Zygarde-Complete" && set.ability !== "Power Construct")
    return true;
  if (pokemon === "Darmanitan-Zen" && set.ability !== "Zen Mode")
    return true;
  if (pokemon === "Meloetta-Pirouette" && !hasMove("Relic Song"))
    return true;
  return false;
}
function toPokemonSet(dex, format, pokemon, set, outOfBattleSpeciesName) {
  const hp = set.moves?.find((m) => m.startsWith("Hidden Power"));
  let fill = dex.gen === 2 ? 30 : 31;
  if (hp) {
    const type = hp.slice(13);
    if (type && dex.getHiddenPower(fillStats(set.ivs, fill)).type !== type) {
      if (!set.ivs || dex.gen >= 7 && (!set.level || set.level === 100)) {
        set.hpType = type;
        fill = 31;
      } else if (dex.gen === 2) {
        const dvs = { ...dex.types.get(type).HPdvs };
        let stat;
        for (stat in dvs) {
          dvs[stat] *= 2;
        }
        set.ivs = { ...dvs, ...set.ivs };
        set.ivs.hp = expectedHP(set.ivs);
      } else {
        set.ivs = { ...dex.types.get(type).HPivs, ...set.ivs };
      }
    }
  }
  const copy = { species: pokemon, ...set };
  copy.ivs = fillStats(set.ivs, fill);
  if (!set.evs && dex.gen >= 3 && format.id !== "gen7letsgoou")
    set.evs = { spe: 1 };
  copy.evs = fillStats(set.evs, dex.gen <= 2 ? 252 : 0);
  copy.ability = copy.ability || "None";
  const species = dex.species.get(pokemon);
  if (species.battleOnly && !format.id.includes("balancedhackmons")) {
    if (outOfBattleSpeciesName) {
      copy.species = outOfBattleSpeciesName;
    } else if (typeof species.battleOnly === "string") {
      copy.species = species.battleOnly;
    } else {
      throw new Error(`Unable to disambiguate out of battle species for ${species.name} in ${format.id}`);
    }
    copy.ability = dex.species.get(copy.species).abilities[0];
  }
  return copy;
}
function expectedHP(ivs) {
  ivs = fillStats(ivs, 31);
  const atkDV = Math.floor(ivs.atk / 2);
  const defDV = Math.floor(ivs.def / 2);
  const speDV = Math.floor(ivs.spe / 2);
  const spcDV = Math.floor(ivs.spa / 2);
  return 2 * (atkDV % 2 * 8 + defDV % 2 * 4 + speDV % 2 * 2 + spcDV % 2);
}
function fillStats(stats, fill = 0) {
  return import_team_validator.TeamValidator.fillStats(stats || null, fill);
}
const SMOGON = {
  uber: "ubers",
  doubles: "doublesou",
  lgpeou: "letsgoou",
  ag: "anythinggoes",
  bh: "balancedhackmons",
  vgc16: "vgc2016",
  vgc17: "vgc2017",
  vgc18: "vgc2018",
  vgc19: "vgc2019ultraseries",
  vgc24regulatione: "vgc2023regulatione",
  // bssseries1: 'battlestadiumsinglesseries1', // ?
  bssseries2: "battlestadiumsinglesseries2"
};
const getAnalysis = retrying(async (u) => {
  try {
    return smogon.Analyses.process(await request(u));
  } catch (err) {
    if (err.message.startsWith("HTTP")) {
      return Promise.reject(err);
    } else {
      return Promise.reject(new RetryableError(err.message));
    }
  }
}, 3, 50);
async function getAnalysesByFormat(pokemon, gen) {
  const u = smogon.Analyses.url(pokemon === "Meowstic" ? "Meowstic-M" : pokemon, gen);
  try {
    const analysesByTier = await getAnalysis(u);
    if (!analysesByTier) {
      error(`Unable to process analysis for ${pokemon} in generation ${gen}`);
      return void 0;
    }
    const analysesByFormat = /* @__PURE__ */ new Map();
    for (const [tier, analyses] of analysesByTier.entries()) {
      let t = (0, import_dex.toID)(tier);
      if (gen === 9 && t === "battlestadiumsingles") {
        t = "battlestadiumsinglesregulationc";
      }
      const f = FORMATS.get(`gen${gen}${SMOGON[t] || t}`);
      if (f)
        analysesByFormat.set(f.format, analyses);
    }
    return analysesByFormat;
  } catch {
    error(`Unable to process analysis for ${pokemon} in generation ${gen}`);
    return void 0;
  }
}
function getLevel(format, level = 0) {
  const ruleTable = import_dex.Dex.formats.getRuleTable(format);
  if (ruleTable.adjustLevel)
    return ruleTable.adjustLevel;
  const maxLevel = ruleTable.maxLevel;
  const adjustLevelDown = ruleTable.adjustLevelDown || maxLevel;
  if (!level)
    level = ruleTable.defaultLevel;
  return level > adjustLevelDown ? adjustLevelDown : level;
}
async function getStatisticsURL(index, format) {
  const current = index.includes(format.id);
  const latest = await smogon.Statistics.latestDate(format.id, !current);
  if (!latest)
    return void 0;
  return { url: smogon.Statistics.url(latest.date, format.id, current || 1500), count: latest.count };
}
function importUsageBasedSets(gen, format, statistics, count) {
  const sets = {};
  const dex = import_dex.Dex.forFormat(format);
  const threshold = getUsageThreshold(format, count);
  let num = 0;
  for (const pokemon in statistics.data) {
    const stats = statistics.data[pokemon];
    if (eligible(dex, (0, import_dex.toID)(pokemon)) && stats.usage >= threshold) {
      const set = {
        level: getLevel(format),
        moves: top(stats.Moves, 4).map((m) => dex.moves.get(m).name).filter((m) => m)
      };
      if (gen >= 2 && format.id !== "gen7letsgoou") {
        const id = top(stats.Items);
        set.item = dex.items.get(id).name;
        if (set.item === "nothing")
          set.item = void 0;
      }
      if (gen >= 3) {
        const id = top(stats.Abilities);
        set.ability = fixedAbility(dex, pokemon, dex.abilities.get(id).name);
        const { nature, evs } = fromSpread(top(stats.Spreads));
        set.nature = nature;
        if (format.id !== "gen7letsgoou") {
          if (!evs || !Object.keys(evs).length)
            continue;
          set.evs = evs;
        }
      }
      const name = "Showdown Usage";
      if (validSet("stats", dex, format, pokemon, name, set)) {
        sets[pokemon] = {};
        sets[pokemon][name] = set;
        num++;
      }
    }
  }
  report(format, num, "stats");
  return sets;
}
function getUsageThreshold(format, count) {
  if (count < 100)
    return Infinity;
  if (count < 400)
    return 0.05;
  return /uber|anythinggoes|doublesou/.test(format.id) ? 0.03 : 0.01;
}
const STATS = import_dex.Dex.stats.ids();
function fromSpread(spread) {
  const [nature, revs] = spread.split(":");
  const evs = {};
  for (const [i, rev] of revs.split("/").entries()) {
    const ev = Number(rev);
    if (ev)
      evs[STATS[i]] = ev;
  }
  return { nature, evs };
}
function top(weighted, n = 1) {
  if (n === 0)
    return void 0;
  if (n === 1) {
    let max;
    for (const key in weighted) {
      if (!max || weighted[max] < weighted[key])
        max = key;
    }
    return max;
  }
  return Object.entries(weighted).sort((a, b) => b[1] - a[1]).slice(0, n).map((x) => x[0]);
}
class RetryableError extends Error {
  constructor(message) {
    super(message);
    Object.setPrototypeOf(this, new.target.prototype);
  }
}
const request = retrying(throttling(fetch, 1, 50), 5, 20);
function fetch(u) {
  const client = u.startsWith("http:") ? http : https;
  return new Promise((resolve, reject) => {
    const req = client.get(u, (res) => {
      if (res.statusCode !== 200) {
        if (res.statusCode >= 500 && res.statusCode < 600) {
          return reject(new RetryableError(`HTTP ${res.statusCode}`));
        } else if (res.statusCode >= 300 && res.statusCode <= 400 && res.headers.location) {
          resolve(fetch(url.resolve(u, res.headers.location)));
        } else {
          return reject(new Error(`HTTP ${res.statusCode}`));
        }
      }
      import_lib.Streams.readAll(res).then(resolve, reject);
    });
    req.on("error", reject);
    req.end();
  });
}
function retrying(fn, retries, wait) {
  const retry = async (args, attempt = 0) => {
    try {
      return await fn(args);
    } catch (err) {
      if (err instanceof RetryableError) {
        attempt++;
        if (attempt > retries)
          return Promise.reject(err);
        const timeout = Math.round(attempt * wait * (1 + Math.random() / 2));
        warn(`Retrying ${args} in ${timeout}ms (${attempt}):`, err);
        return new Promise((resolve) => {
          setTimeout(() => {
            resolve(retry(args, attempt++));
          }, timeout);
        });
      } else {
        return Promise.reject(err);
      }
    }
  };
  return retry;
}
function throttling(fn, limit, interval) {
  const queue = /* @__PURE__ */ new Map();
  let currentTick = 0;
  let activeCount = 0;
  const throttled = (args) => {
    let timeout;
    return new Promise((resolve, reject) => {
      const execute = () => {
        resolve(fn(args));
        queue.delete(timeout);
      };
      const now = Date.now();
      if (now - currentTick > interval) {
        activeCount = 1;
        currentTick = now;
      } else if (activeCount < limit) {
        activeCount++;
      } else {
        currentTick += interval;
        activeCount = 1;
      }
      timeout = setTimeout(execute, currentTick - now);
      queue.set(timeout, reject);
    });
  };
  return throttled;
}
function color(s, code) {
  return util.format(`\x1B[${code}m%s\x1B[0m`, s);
}
function report(format, num, source) {
  console.info(`${format.name}: ${color(num, 33)} ${color(`(${source})`, 90)}`);
}
function warn(s, err) {
  console.warn(`${color(s, 33)} ${color(err.message, 90)}`);
}
function error(s) {
  console.error(color(s, 91));
}
//# sourceMappingURL=importer.js.map