// Cálculo lambda (1936):   λx. x * 2
// JavaScript moderno:      x => x * 2

const doble = x => x * 2;
console.log(doble(21)); // 42

const cuadrado = x => x * x;

const a = cuadrado(4) + cuadrado(4);
const b = 16 + 16;   // podemos reemplazar cuadrado(4) por 16 sin cambiar nada

console.log(a === b); // true

const estudiante = { nombre: "Luis", nota: 70 };

// En lugar de modificar:  estudiante.nota = 85;
// creamos una copia con el cambio:
const actualizado = { ...estudiante, nota: 85 };

console.log(estudiante);  // { nombre: "Luis", nota: 70 }
console.log(actualizado); // { nombre: "Luis", nota: 85 }

// Función tradicional
function sumar(a, b) {
  return a + b;
}

// La misma función escrita como función flecha (arrow function)
const sumarFlecha = (a, b) => a + b;

// Con un solo parámetro los paréntesis son opcionales
const cuadrado = x => x * x;

console.log(sumar(2, 3), sumarFlecha(2, 3), cuadrado(5)); // 5 5 25

// 1. Guardar una función en una variable
const saludar = nombre => "Hola, " + nombre;

// 2. Pasar una función como argumento
function aplicarDosVeces(fn, valor) {
  return fn(fn(valor));
}
const sumarDiez = x => x + 10;
console.log(aplicarDosVeces(sumarDiez, 5)); // 25

// 3. Devolver una función como resultado
function crearMultiplicador(factor) {
  return x => x * factor;   // la función "recuerda" el factor (closure)
}
const triple = crearMultiplicador(3);
console.log(triple(7));     // 21

// 4. Guardar funciones dentro de estructuras de datos
const operaciones = [x => x + 1, x => x * 2];
console.log(operaciones[1](8)); // 16

const estudiantes = [
  { nombre: "Ana",   nota: 85 },
  { nombre: "Luis",  nota: 58 },
  { nombre: "María", nota: 92 },
  { nombre: "Pedro", nota: 64 },
  { nombre: "Sofía", nota: 77 },
];

// map: transforma CADA elemento -> devuelve un arreglo del mismo tamaño
const nombres = estudiantes.map(e => e.nombre);
console.log(nombres);  // ["Ana", "Luis", "María", "Pedro", "Sofía"]

const curva = estudiantes.map(e => ({ ...e, nota: e.nota + 5 }));
console.log(curva[1]); // { nombre: "Luis", nota: 63 }

// filter: se queda SOLO con los que cumplen la condición
const aprobados = estudiantes.filter(e => e.nota >= 65);
console.log(aprobados.length); // 3  (Ana, María y Sofía)

// reduce: combina todos los elementos en UN solo valor
//                        (acumulado, actual) => nuevo acumulado,  valor inicial
const suma = estudiantes.reduce((acc, e) => acc + e.nota, 0);
const promedio = suma / estudiantes.length;
console.log(promedio); // 75.2

// Lista de honor: aprobados, ordenados por nota, solo el nombre en mayúsculas
const listaHonor = estudiantes
  .filter(e => e.nota >= 65)             // 1. quedarse con los aprobados
  .toSorted((a, b) => b.nota - a.nota)   // 2. ordenar SIN mutar el original
  .map(e => e.nombre.toUpperCase());     // 3. transformar a texto

console.log(listaHonor); // ["MARÍA", "ANA", "SOFÍA"]

// Funciones pequeñas, cada una hace UNA sola cosa
const quitarEspacios = texto => texto.trim();
const aMinusculas    = texto => texto.toLowerCase();
const cambiarEspacios = texto => texto.replaceAll(" ", "-");

// pipe: ejecuta las funciones de izquierda a derecha
const pipe = (...fns) => valor => fns.reduce((acc, fn) => fn(acc), valor);

const crearSlug = pipe(quitarEspacios, aMinusculas, cambiarEspacios);

console.log(crearSlug("  Paradigmas de Programación ")); // "paradigmas-de-programación"

// Con bucle (imperativo)
function cuentaRegresivaFor(n) {
  for (let i = n; i > 0; i--) {
    console.log(i);
  }
  console.log("¡Despegue!");
}

// Con recursión (funcional)
function cuentaRegresiva(n) {
  if (n === 0) {                 // 1. CASO BASE: cuándo detenerse
    console.log("¡Despegue!");
    return;
  }
  console.log(n);
  cuentaRegresiva(n - 1);        // 2. PASO RECURSIVO: un problema más pequeño
}

cuentaRegresiva(3); // 3, 2, 1, ¡Despegue!

// factorial(4) = 4 * 3 * 2 * 1 = 24
const factorial = n =>
  n === 0 ? 1                    // caso base
          : n * factorial(n - 1); // paso recursivo

console.log(factorial(4)); // 24

/* ¿Cómo se evalúa?
   factorial(4)
   = 4 * factorial(3)
   = 4 * 3 * factorial(2)
   = 4 * 3 * 2 * factorial(1)
   = 4 * 3 * 2 * 1 * factorial(0)
   = 4 * 3 * 2 * 1 * 1  =  24          */

// Sumar una lista separándola en "primero" y "resto"
function sumarLista(lista) {
  if (lista.length === 0) return 0;        // caso base: lista vacía
  const [primero, ...resto] = lista;       // desestructuración
  return primero + sumarLista(resto);      // primero + suma del resto
}

console.log(sumarLista([4, 7, 1, 3])); // 15
// 4 + sumarLista([7,1,3]) -> 4 + 7 + sumarLista([1,3]) -> ... -> 15

// En React, un componente es simplemente una función:
// recibe datos (props) y devuelve lo que se debe mostrar.
function Saludo({ nombre }) {
  return <h1>Hola, {nombre}</h1>;
}

// Y el estado se actualiza de forma inmutable:
setTareas(tareas => [...tareas, nuevaTarea]);