How to Build a Random Pokemon Generator

interface Pokemon {
  id: number;
  name: string;
  types: string[];
  generation: number;
  stats: {
    hp: number; attack: number; defense: number;
    spAtk: number; spDef: number; speed: number;
  },
  bst: number; // base stat total
  sprite: string;
  isLegendary: boolean;
  isMythical: boolean;
  evolutionStage: number; // 1 = basic, 2 = stage 1, 3 = stage 2
  }

  interface PokemonFilters {
  generation?: number[];    // [1, 2, 3] for gens 1-3
  types?: string[];         // ["fire", "dragon"]
  minBST?: number;
  maxBST?: number;
  evolutionStage?: number;
  excludeLegendary?: boolean;
  excludeMythical?: boolean;
  }

  async function fetchPokemonPool(filters: PokemonFilters): Promise<Pokemon[]> {
  // PokeAPI: fetch species list, then filter
  const speciesRes = await fetch("https://pokeapi.co/api/v2/pokemon-species?limit=1025");
  const speciesList = await speciesRes.json();

  // Cache full pokemon data locally after first fetch
  const allPokemon: Pokemon[] = await Promise.all(
    speciesList.results.map(async (s: any, i: number) => {
      const [pokemon, species] = await Promise.all([
        fetch(`https://pokeapi.co/api/v2/pokemon/${i + 1}`).then(r => r.json()),
        fetch(s.url).then(r => r.json()),
      ]);
      return {
        id: pokemon.id,
        name: pokemon.name,
        types: pokemon.types.map((t: any) => t.type.name),
        generation: parseInt(species.generation.url.split("/").slice(-2, -1)[0]),
        stats: {
          hp: pokemon.stats[0].base_stat,
          attack: pokemon.stats[1].base_stat,
          defense: pokemon.stats[2].base_stat,
          spAtk: pokemon.stats[3].base_stat,
          spDef: pokemon.stats[4].base_stat,
          speed: pokemon.stats[5].base_stat,
        },
        bst: pokemon.stats.reduce((sum: number, s: any) => sum + s.base_stat, 0),
        sprite: pokemon.sprites.other["official-artwork"].front_default,
        isLegendary: species.is_legendary,
        isMythical: species.is_mythical,
        evolutionStage: species.evolves_from_species ? 2 : 1, // simplified
      },
    })
  );

  return allPokemon.filter(p => {
    if (filters.generation?.length && !filters.generation.includes(p.generation)) return false;
    if (filters.types?.length && !filters.types.some(t => p.types.includes(t))) return false;
    if (filters.minBST && p.bst < filters.minBST) return false;
    if (filters.maxBST && p.bst > filters.maxBST) return false;
    if (filters.excludeLegendary && p.isLegendary) return false;
    if (filters.excludeMythical && p.isMythical) return false;
    return true;
  });
  }

  function generateRandomTeam(pool: Pokemon[], size = 6): Pokemon[] {
  const team: Pokemon[] = [];
  const available = [...pool];
  while (team.length < size && available.length > 0) {
    const idx = Math.floor(Math.random() * available.length);
    team.push(available.splice(idx, 1)[0]);
  }
  return team;
  }