Clean code: SOLID, KISS, DRY y patrones

// Antes: ¿qué es 'w'? ¿qué hace 'd'?
var w = h.victorias / h.partidas;
function d(lista, r) { /* ... */ }

// Después: el nombre ya lo dice todo.
// proporción de victorias sobre partidas
const winrate = heroe.victorias / heroe.partidas;
// filtra y ordena por rol
function heroesFiablesPorRol(lista, rol) { /* ... */ }

// Antes: filtra, calcula el winrate, asigna etiqueta Y ordena. Cuatro cosas.
function hacerCosas(lista, r) {
  var res = [];
  for (var i = 0; i < lista.length; i++) {
    if (lista[i].rol === r) {
      if (lista[i].partidas >= 40) {
        // calcula winrate
        var w = lista[i].victorias / lista[i].partidas;
        var etiqueta = '';
        // asigna etiqueta
        if (w >= 0.6) { etiqueta = 'estrella'; }
        else if (w >= 0.5) { etiqueta = 'solido'; }
        else { etiqueta = 'flojo'; }
        res.push({ nombre: lista[i].nombre, winrate: w, etiqueta: etiqueta });
      }
    }
  }
  // ... sort a mano de 7 líneas más
  return res;
}

// Después: cada función hace una sola cosa y tiene un nombre que lo dice.
// calcula el winrate de un héroe
function winrateDe(heroe) {
  return heroe.victorias / heroe.partidas;
}
// asigna la etiqueta según el winrate
function etiquetaPorWinrate(winrate) {
  if (winrate >= 0.6) return 'estrella';
  if (winrate >= 0.5) return 'solido';
  return 'flojo';
}
// decide si el héroe tiene datos fiables
function esFiable(heroe) {
  return heroe.partidas >= 40;
}
// construye la ficha a partir del héroe crudo
function aFicha(heroe) {
  // delega en winrateDe
  const winrate = winrateDe(heroe);
  return { nombre: heroe.nombre, winrate: winrate, etiqueta: etiquetaPorWinrate(winrate) };
}
// comparador: mayor winrate primero
function porWinrateDesc(a, b) {
  return b.winrate - a.winrate;
}
// orquesta: filtra, transforma y ordena
function heroesFiablesPorRol(lista, rol) {
  return lista
    // filtra por rol y fiabilidad
    .filter(function (h) { return h.rol === rol && esFiable(h); })
    // transforma cada héroe en una ficha
    .map(aFicha)
    // ordena de mayor a menor winrate
    .sort(porWinrateDesc);
}

// Sin DRY: el número 40 aparece tres veces.
// Si el equipo decide subir el umbral a 50, hay que buscarlo en todo el fichero.
if (heroe.partidas >= 40) { /* ... */ }
if (lista[i].partidas >= 40) { /* ... */ }
if (h.partidas >= 40) { /* ... */ }

// Con DRY: el conocimiento vive en un solo sitio.
// aquí se cambia y punto
const MINIMO_PARTIDAS_FIABLE = 40;
function esFiable(heroe) {
  // usa la constante
  return heroe.partidas >= MINIMO_PARTIDAS_FIABLE;
}

// Sobre-ingeniería: una clase con estado, configuración inyectable y eventos,
// para algo que solo necesita filtrar un array.
class HeroeFilterEngine {
  constructor(config) { this.config = config; }
  setStrategy(strategy) { this.strategy = strategy; }
  execute(lista) { /* 40 líneas */ }
}

// KISS: una función que resuelve el problema concreto.
function heroesFiablesPorRol(lista, rol) {
  return lista.filter(function (h) { return h.rol === rol && esFiable(h); })
    .map(aFicha)
    .sort(porWinrateDesc);
}

// Viola SRP: esta función calcula el winrate Y decide si es fiable Y construye la ficha.
// Tiene tres razones distintas para cambiar.
function procesarHeroe(heroe) {
  // responsabilidad 1: calcular winrate
  var winrate = heroe.victorias / heroe.partidas;
  // responsabilidad 2: decidir si es fiable
  if (heroe.partidas < 40) return null;
  // responsabilidad 3: etiquetar
  var etiqueta = winrate >= 0.6 ? 'estrella' : 'solido';
  // responsabilidad 4: construir ficha
  return { nombre: heroe.nombre, winrate: winrate, etiqueta: etiqueta };
}

// Con SRP: cada función tiene una sola responsabilidad.
// solo calcula el winrate
function winrateDe(heroe) {
  return heroe.victorias / heroe.partidas;
}
// solo decide si hay suficientes partidas
function esFiable(heroe) {
  return heroe.partidas >= MINIMO_PARTIDAS_FIABLE;
}
// solo construye la ficha
function aFicha(heroe) {
  // delega el cálculo en winrateDe
  const winrate = winrateDe(heroe);
  return { nombre: heroe.nombre, winrate: winrate, etiqueta: etiquetaPorWinrate(winrate) };
}

// Viola OCP: añadir 'leyenda' exige abrir este switch y modificarlo,
// con riesgo de romper los casos existentes.
function etiquetaPorWinrate(winrate) {
  if (winrate >= 0.6) return 'estrella';
  if (winrate >= 0.5) return 'solido';
  return 'flojo';
  // Para añadir 'leyenda' hay que abrir esta función y editar sus entrañas.
}

// Con OCP: una tabla de niveles. Añadir 'leyenda' es añadir una fila.
// La función etiquetaPorWinrate no cambia: está cerrada a modificación.
const NIVELES = [
  // nueva fila — no tocas nada más
  { minimo: 0.75, etiqueta: 'leyenda' },
  { minimo: 0.6,  etiqueta: 'estrella' },
  { minimo: 0.5,  etiqueta: 'solido' },
  { minimo: 0,    etiqueta: 'flojo' },
];

function etiquetaPorWinrate(winrate) {
  // recorre la tabla de arriba a abajo
  for (let i = 0; i < NIVELES.length; i++) {
    // devuelve la primera que cumple
    if (winrate >= NIVELES[i].minimo) return NIVELES[i].etiqueta;
  }
  // fallback: la última fila
  return NIVELES[NIVELES.length - 1].etiqueta;
}

// Clase base: cualquier héroe del Team Builder.
class Heroe {
  constructor(nombre, rol, partidas, victorias) {
    // nombre del héroe
    this.nombre = nombre;
    // 'dps', 'tank' o 'support'
    this.rol = rol;
    // total de partidas jugadas
    this.partidas = partidas;
    // total de victorias
    this.victorias = victorias;
  }
  // Contrato: winrate() devuelve un número entre 0 y 1.
  winrate() {
    // proporción de victorias
    return this.victorias / this.partidas;
  }
}

// Función cliente escrita ANTES de que existieran subtipos.
// Solo sabe que recibe un Heroe y que heroe.winrate() devuelve un número.
function describir(heroe) {
  // usa el contrato, no la implementación
  return heroe.nombre + ': ' + heroe.winrate();
}

// --- Subtipo que RESPETA el contrato ---

class HeroeLegendario extends Heroe {
  constructor(nombre, rol, partidas, victorias, skin) {
    // delega la inicialización base
    super(nombre, rol, partidas, victorias);
    // propiedad extra: nombre de la skin legendaria
    this.skin = skin;
  }
  // Sobrescribe winrate() pero sigue devolviendo un número: contrato respetado.
  winrate() {
    // Penalización cosmética, pero el resultado sigue siendo un número.
    // ajuste de balance interno
    return (this.victorias / this.partidas) - 0.02;
  }
}

// tipo base
const mercy = new Heroe('Mercy', 'support', 60, 39);
// subtipo
const ana   = new HeroeLegendario('Ana', 'support', 80, 52, 'Comandante');

// describir() funciona con ambos sin modificarse: LSP se cumple.
// 'Mercy: 0.65'
console.log(describir(mercy));
// 'Ana: 0.63' — resultado diferente, pero sigue siendo un número
console.log(describir(ana));

// --- Subtipo que VIOLA el contrato ---

// (Este ejemplo es prosa: muestra la violación sin ejecutarse)

// Viola LSP: winrate() lanza un error cuando no hay partidas,
// en vez de devolver un número como espera el contrato.
class HeroeSinPartidas extends Heroe {
  constructor(nombre, rol) {
    // sin partidas ni victorias
    super(nombre, rol, 0, 0);
  }
  winrate() {
    // VIOLA el contrato: la base devuelve un número
    throw new Error('No hay partidas registradas');
  }
}

var novato = new HeroeSinPartidas('Novato', 'dps');

// describir(novato) se rompe aunque describir() no ha cambiado.
// El cliente asumía que cualquier Heroe tiene un winrate() que devuelve un número.
// lanza Error — LSP violado
describir(novato);

// Viola ISP: la función recibe el héroe completo pero solo usa 'victorias' y 'partidas'.
// El llamador tiene que proporcionar un objeto con todos los campos aunque no hagan falta.
function winrateDe(heroe) {
  // solo usa dos campos del héroe
  return heroe.victorias / heroe.partidas;
  // heroe.nombre, heroe.rol, heroe.skin... ignorados
}

// Con ISP: la función declara exactamente lo que necesita.
// Funciona con cualquier objeto que tenga 'victorias' y 'partidas', no solo con Heroe.
function calcularWinrate(victorias, partidas) {
  // interfaz mínima: solo lo que se usa
  return victorias / partidas;
}

// pasas solo lo necesario
const winrate = calcularWinrate(mercy.victorias, mercy.partidas);

// Viola DIP: heroesFiablesPorRol depende de la variable global 'heroes'.
// No puedes cambiar la fuente de datos sin modificar la función.
var heroes = [
  { nombre: 'Tracer', rol: 'dps', partidas: 120, victorias: 70 },
  // ...
];

// sin parámetro de lista: lee la global
function heroesFiablesPorRol(rol) {
  // acoplada a la variable global 'heroes'
  return heroes
    .filter(function (h) { return h.rol === rol && esFiable(h); })
    .map(aFicha)
    .sort(porWinrateDesc);
}

// Con DIP: la fuente de datos entra por parámetro.
// La función depende de 'cualquier lista de héroes', no de 'la variable global heroes'.
// 'lista' es la abstracción: cualquier array de héroes
function heroesFiablesPorRol(lista, rol) {
  // no importa de dónde venga la lista
  return lista
    .filter(function (h) { return h.rol === rol && esFiable(h); })
    .map(aFicha)
    .sort(porWinrateDesc);
}

// Ahora puedes llamarla con cualquier fuente:
// con la lista real
heroesFiablesPorRol(heroes, 'dps');
// con datos de test
heroesFiablesPorRol(heroesDePrueba, 'dps');
// con datos de una API
heroesFiablesPorRol(heroesDeLaAPI, 'dps');

// Sin Factory: la lógica de qué habilidad tiene cada rol está repetida en cada sitio.
// Si el rol 'dps' cambia de 'movilidad' a 'daño', hay que buscar y cambiar cada uno.
const tracer = { nombre: 'Tracer', rol: 'dps', partidas: 120, victorias: 70, habilidad: 'movilidad' };
// el llamador tiene que recordar qué habilidad corresponde a cada rol
const mercy  = { nombre: 'Mercy', rol: 'support', partidas: 60, victorias: 39, habilidad: 'curación' };

// Con Factory: el llamador solo conoce crearHeroe(); la decisión de qué forma
// tiene el objeto de cada rol vive en un solo sitio.
function crearHeroe(nombre, rol, partidas, victorias) {
  // La Factory decide la forma del objeto según el rol.
  if (rol === 'dps') {
    return { nombre: nombre, rol: 'dps', partidas: partidas, victorias: victorias, habilidad: 'movilidad' };
  }
  if (rol === 'support') {
    return { nombre: nombre, rol: 'support', partidas: partidas, victorias: victorias, habilidad: 'curación' };
  }
  if (rol === 'tank') {
    return { nombre: nombre, rol: 'tank', partidas: partidas, victorias: victorias, habilidad: 'resistencia' };
  }
  // rol desconocido: objeto base
  return { nombre: nombre, rol: rol, partidas: partidas, victorias: victorias };
}

// el llamador no sabe qué objeto exacto se crea
const tracer = crearHeroe('Tracer', 'dps', 120, 70);
// la lógica de creación está en un solo lugar
const mercy  = crearHeroe('Mercy', 'support', 60, 39);

// config-team-builder.js — Singleton con módulo ESM.
// La variable 'instancia' vive en el ámbito del módulo: es privada.
// Solo este fichero puede crearla o modificarla.
let instancia = null;

// Devuelve siempre la misma instancia de configuración.
function obtenerConfig() {
  if (instancia === null) {
    // crea el objeto de configuración solo la primera vez
    instancia = {
      // límite de héroes por rol en el equipo
      maxHeroesPorRol: 2,
      // umbrales de etiqueta
      umbrales: { estrella: 0.6, solido: 0.5 },
      // versión de la configuración
      version: '2026.1',
    };
  }
  // siempre devuelve la misma referencia
  return instancia;
}

export { obtenerConfig };

// equipo.js — cualquier fichero que importe obtenerConfig recibe la misma instancia.
import { obtenerConfig } from './config-team-builder.js';

// primera llamada: crea la instancia
const config = obtenerConfig();
// segunda llamada: devuelve la misma (instancia ya no era null)
const config2 = obtenerConfig();

// true: es la misma referencia
console.log(config === config2);

// Lo que devuelve la API de Blizzard: campos en inglés y en snake_case.
const respuestaBlizzard = {
  heroName: 'Mercy',
  primaryRole: 'support',
  gamesPlayed: 60,
  wins: 39,
};

// Lo que espera el resto del código del Team Builder: campos en castellano.
// { nombre, rol, partidas, victorias }

// Adapter: traduce el formato de Blizzard al modelo interno del Team Builder.
// Ninguno de los dos lados cambia: solo el adapter.
function adaptarHeroeBlizzard(apiData) {
  return {
    // heroName  → nombre
    nombre: apiData.heroName,
    // primaryRole → rol
    rol: apiData.primaryRole,
    // gamesPlayed → partidas
    partidas: apiData.gamesPlayed,
    // wins → victorias
    victorias: apiData.wins,
  };
}

// ahora mercy tiene el formato interno
const mercy = adaptarHeroeBlizzard(respuestaBlizzard);
// { nombre: 'Mercy', rol: 'support', partidas: 60, victorias: 39 }
console.log(mercy);