package com.ciclourbana.alquileres;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import java.time.Instant;
import java.util.ArrayList;
import java.util.List;

/**
 * Acumula los eventos de una simulación de demanda. Cada simulación
 * necesita su propio acumulador con estado, así que NO puede ser singleton.
 */
@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)   // equivale a @Scope("prototype")
public class SesionSimulacion {

    private final Instant inicio = Instant.now();
    private final List<String> eventos = new ArrayList<>();

    public void registrar(String evento) {
        eventos.add(evento);
    }

    public List<String> eventos() {
        return List.copyOf(eventos);
    }

    public Instant inicio() {
        return inicio;
    }
}

@Component
@RequestScope    // = @Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ContextoPeticion { /* datos de la petición HTTP en curso */ }

@Component
@SessionScope    // = @Scope(value = "session", proxyMode = ...)
public class CarritoRecargas { /* estado por usuario, entre peticiones */ }

@Service
public class EstacionService {

    private final EstacionRepositorio estacionRepositorio;

    // ¡PELIGRO! Campo mutable en un singleton compartido por todos los hilos
    private int ultimoIdConsultado;
    private List<Estacion> resultadoParcial = new ArrayList<>();

    public List<Estacion> buscarPorCapacidadMinima(int minima) {
        resultadoParcial.clear();                       // hilo A limpia...
        for (Estacion e : estacionRepositorio.buscarTodas()) {
            if (e.capacidad() >= minima) {
                resultadoParcial.add(e);                // ...mientras hilo B añade
            }
        }
        return resultadoParcial;                        // resultado impredecible
    }
}

@Service
public class EstacionService {

    private final EstacionRepositorio estacionRepositorio;   // final e inmutable

    public EstacionService(EstacionRepositorio estacionRepositorio) {
        this.estacionRepositorio = estacionRepositorio;
    }

    public List<Estacion> buscarPorCapacidadMinima(int minima) {
        // Todo el estado es local al hilo: seguro por construcción
        return estacionRepositorio.buscarTodas().stream()
                .filter(e -> e.capacidad() >= minima)
                .sorted(Comparator.comparing(Estacion::nombre))
                .toList();
    }
}

@Service                                    // singleton
public class SimuladorDemanda {

    private final SesionSimulacion sesion;  // prototype

    public SimuladorDemanda(SesionSimulacion sesion) {
        this.sesion = sesion;               // se inyecta UNA vez, al arrancar
    }

    public void simular() {
        sesion.registrar("simulación ejecutada");   // ¡siempre la MISMA sesión!
    }
}

package com.ciclourbana.alquileres;

import org.springframework.beans.factory.ObjectProvider;
import org.springframework.stereotype.Service;

@Service
public class SimuladorDemanda {

    private final ObjectProvider<SesionSimulacion> proveedorSesiones;

    public SimuladorDemanda(ObjectProvider<SesionSimulacion> proveedorSesiones) {
        this.proveedorSesiones = proveedorSesiones;
    }

    public void simular(String nombreEscenario) {
        // getObject() pide una instancia NUEVA al contenedor en cada llamada
        SesionSimulacion sesion = proveedorSesiones.getObject();
        sesion.registrar("escenario: " + nombreEscenario);
        sesion.registrar("estaciones evaluadas: 4");
        // La sesión muere cuando salga de ámbito: Spring no la destruye
    }
}

@Service
public abstract class SimuladorDemanda {

    public void simular(String nombreEscenario) {
        SesionSimulacion sesion = nuevaSesion();   // instancia nueva cada vez
        sesion.registrar("escenario: " + nombreEscenario);
    }

    /** Spring implementa este método por nosotros. */
    @Lookup
    protected abstract SesionSimulacion nuevaSesion();
}

@Component
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class SesionSimulacion { /* ... */ }

@Component
public class DiagnosticoBean implements BeanNameAware, ApplicationContextAware {

    private String nombreBean;
    private ApplicationContext contexto;

    @Override
    public void setBeanName(String name) {
        this.nombreBean = name;      // "diagnosticoBean"
    }

    @Override
    public void setApplicationContext(ApplicationContext contexto) {
        this.contexto = contexto;
    }
}

package com.ciclourbana.estaciones;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.time.Instant;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Caché en memoria de los anclajes libres por estación.
 *
 * Precalcula los valores al arrancar (@PostConstruct) y vuelca
 * estadísticas al cerrar (@PreDestroy). Es una caché manual: la
 * caché declarativa con @Cacheable se estudia en la lección 09-02.
 */
@Component
public class CacheDisponibilidad {

    private static final Logger log = LoggerFactory.getLogger(CacheDisponibilidad.class);

    private final EstacionRepositorio estacionRepositorio;

    // ConcurrentHashMap: el bean es singleton y lo leen varios hilos
    private final Map<Long, Integer> anclajesLibres = new ConcurrentHashMap<>();
    private final AtomicLong aciertos = new AtomicLong();
    private final AtomicLong fallos = new AtomicLong();

    private Instant momentoCarga;

    public CacheDisponibilidad(EstacionRepositorio estacionRepositorio) {
        this.estacionRepositorio = estacionRepositorio;
        // OJO: aquí NO precargamos. El constructor solo asigna dependencias.
        log.debug("CacheDisponibilidad construida (aún sin datos)");
    }

    /**
     * Se ejecuta después de que todas las dependencias estén inyectadas.
     * Es el lugar correcto para trabajo de inicialización pesado.
     */
    @PostConstruct
    public void precargar() {
        Instant inicio = Instant.now();

        estacionRepositorio.buscarTodas().forEach(estacion ->
                // Simulación: al arrancar consideramos la mitad de anclajes ocupados
                anclajesLibres.put(estacion.id(), estacion.capacidad() / 2));

        this.momentoCarga = Instant.now();
        log.info("Caché de disponibilidad precargada con {} estaciones en {} ms",
                anclajesLibres.size(),
                Duration.between(inicio, momentoCarga).toMillis());
    }

    public int anclajesLibres(Long estacionId) {
        Integer valor = anclajesLibres.get(estacionId);
        if (valor == null) {
            fallos.incrementAndGet();
            return recalcular(estacionId);
        }
        aciertos.incrementAndGet();
        return valor;
    }

    public void actualizar(Long estacionId, int libres) {
        anclajesLibres.put(estacionId, libres);
    }

    private int recalcular(Long estacionId) {
        int libres = estacionRepositorio.buscarPorId(estacionId)
                .map(estacion -> estacion.capacidad() / 2)
                .orElse(0);
        anclajesLibres.put(estacionId, libres);
        return libres;
    }

    /**
     * Se ejecuta al cerrar el contexto de forma ordenada.
     * Aquí se liberarían conexiones, hilos o ficheros abiertos.
     */
    @PreDestroy
    public void liberar() {
        log.info("Cerrando caché de disponibilidad tras {} de servicio",
                Duration.between(momentoCarga, Instant.now()));
        log.info("Estadísticas: {} aciertos, {} fallos ({}% de acierto)",
                aciertos.get(), fallos.get(), porcentajeAcierto());
        anclajesLibres.clear();
    }

    private long porcentajeAcierto() {
        long total = aciertos.get() + fallos.get();
        return total == 0 ? 0 : (aciertos.get() * 100) / total;
    }
}

@Component
public class CalentadorCache {

    private final CacheDisponibilidad cache;
    private final EstacionRepositorio repositorio;

    public CalentadorCache(CacheDisponibilidad cache, EstacionRepositorio repositorio) {
        this.cache = cache;
        this.repositorio = repositorio;
    }

    /** ApplicationReadyEvent se publica DESPUÉS de los CommandLineRunner. */
    @EventListener(ApplicationReadyEvent.class)
    public void calentar() {
        repositorio.buscarTodas().forEach(e ->
                cache.actualizar(e.id(), e.capacidad() / 2));
    }
}

./mvnw spring-boot:run

c.c.estaciones.CacheDisponibilidad : Caché de disponibilidad precargada con 0 estaciones en 1 ms
c.c.e.CargadorEstacionesDemo       : Cargadas 4 estaciones, 108 anclajes en total
...
c.c.estaciones.CacheDisponibilidad : Cerrando caché de disponibilidad tras PT2M14S de servicio
c.c.estaciones.CacheDisponibilidad : Estadísticas: 12 aciertos, 4 fallos (75% de acierto)

@Component
@Lazy   // no se crea hasta que alguien lo pida por primera vez
public class GeneradorInformesMensuales { /* proceso costoso, se usa una vez al mes */ }

# src/main/resources/application.properties
spring.main.lazy-initialization=true

public interface BeanPostProcessor {

    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;   // antes de @PostConstruct
    }

    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;   // después de @PostConstruct; aquí se devuelven los proxies
    }
}

package com.ciclourbana.comun;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * Cronometra la inicialización de los beans de com.ciclourbana y avisa
 * de los que tardan más del umbral. Herramienta de diagnóstico de arranque.
 */
@Component
public class CronometroInicializacionBeans implements BeanPostProcessor {

    private static final Logger log =
            LoggerFactory.getLogger(CronometroInicializacionBeans.class);

    private static final long UMBRAL_MS = 50;

    // El post-procesador se ejecuta en el hilo de arranque: HashMap basta
    private final Map<String, Long> inicios = new HashMap<>();

    @Override
    public Object postProcessBeforeInitialization(Object bean, String nombreBean) {
        if (esNuestro(bean)) {
            inicios.put(nombreBean, System.nanoTime());
        }
        return bean;   // devolvemos el mismo bean: no lo sustituimos
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String nombreBean) {
        Long inicio = inicios.remove(nombreBean);
        if (inicio != null) {
            long ms = (System.nanoTime() - inicio) / 1_000_000;
            if (ms >= UMBRAL_MS) {
                log.warn("Bean lento: '{}' tardó {} ms en inicializarse", nombreBean, ms);
            } else {
                log.debug("Bean '{}' inicializado en {} ms", nombreBean, ms);
            }
        }
        return bean;
    }

    private boolean esNuestro(Object bean) {
        return bean.getClass().getName().startsWith("com.ciclourbana");
    }
}

logging.level.com.ciclourbana.comun.CronometroInicializacionBeans=DEBUG

c.c.c.CronometroInicializacionBeans : Bean 'estacionRepositorioEnMemoria' inicializado en 2 ms
c.c.c.CronometroInicializacionBeans : Bean 'estacionService' inicializado en 1 ms
c.c.c.CronometroInicializacionBeans : Bean 'cacheDisponibilidad' inicializado en 4 ms
c.c.c.CronometroInicializacionBeans : Bean 'tarifaEstandar' inicializado en 0 ms

@Service
public class RegistroAlquileresActivos {

    private int totalIniciados = 0;
    private final List<String> matriculasActivas = new ArrayList<>();

    public void iniciar(String matricula) {
        matriculasActivas.add(matricula);
        totalIniciados++;
    }

    public void finalizar(String matricula) {
        matriculasActivas.remove(matricula);
    }

    public int activos() {
        return matriculasActivas.size();
    }

    public int totalIniciados() {
        return totalIniciados;
    }
}

package com.ciclourbana.comun;

import jakarta.annotation.PreDestroy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.UUID;

@Component
public class ContadorSingleton {

    private static final Logger log = LoggerFactory.getLogger(ContadorSingleton.class);

    private final String id = UUID.randomUUID().toString().substring(0, 8);

    public ContadorSingleton() {
        log.info("Construido ContadorSingleton {}", id);
    }

    public String id() {
        return id;
    }

    @PreDestroy
    public void alDestruir() {
        log.info("Destruido ContadorSingleton {}", id);
    }
}

package com.ciclourbana.comun;

import jakarta.annotation.PreDestroy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import java.util.UUID;

@Component
@Scope("prototype")
public class ContadorPrototype {

    private static final Logger log = LoggerFactory.getLogger(ContadorPrototype.class);

    private final String id = UUID.randomUUID().toString().substring(0, 8);

    public String id() {
        return id;
    }

    @PreDestroy
    public void alDestruir() {
        // NUNCA se ejecuta: Spring no gestiona la destrucción de los prototype
        log.info("Destruido ContadorPrototype {}", id);
    }
}

package com.ciclourbana.comun;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(50)
public class DemostracionAmbitos implements CommandLineRunner {

    private static final Logger log = LoggerFactory.getLogger(DemostracionAmbitos.class);

    private final ApplicationContext contexto;

    public DemostracionAmbitos(ApplicationContext contexto) {
        this.contexto = contexto;
    }

    @Override
    public void run(String... args) {
        for (int i = 1; i <= 3; i++) {
            log.info("Petición {} -> singleton: {} | prototype: {}",
                    i,
                    contexto.getBean(ContadorSingleton.class).id(),
                    contexto.getBean(ContadorPrototype.class).id());
        }
    }
}

Petición 1 -> singleton: a3f91c02 | prototype: 7b2e4d81
Petición 2 -> singleton: a3f91c02 | prototype: c14a9f30
Petición 3 -> singleton: a3f91c02 | prototype: 55d0e7b2
...
Destruido ContadorSingleton a3f91c02      <- solo aparece el del singleton

package com.ciclourbana.alquileres;

import org.springframework.stereotype.Service;

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Registro de alquileres en curso. Es un singleton compartido por
 * todos los hilos de Tomcat, así que todo su estado debe ser concurrente.
 */
@Service
public class RegistroAlquileresActivos {

    // Set concurrente: además evita duplicados, que en este dominio
    // son un error (una bicicleta no puede alquilarse dos veces)
    private final Set<String> matriculasActivas = ConcurrentHashMap.newKeySet();

    // Incremento atómico: sin pérdida de actualizaciones
    private final AtomicInteger totalIniciados = new AtomicInteger();

    public void iniciar(String matricula) {
        if (matriculasActivas.add(matricula)) {   // add devuelve false si ya estaba
            totalIniciados.incrementAndGet();
        }
    }

    public void finalizar(String matricula) {
        matriculasActivas.remove(matricula);
    }

    public int activos() {
        return matriculasActivas.size();
    }

    public int totalIniciados() {
        return totalIniciados.get();
    }
}

package com.ciclourbana.alquileres;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Component
public class PruebaConcurrencia implements CommandLineRunner {

    private static final Logger log = LoggerFactory.getLogger(PruebaConcurrencia.class);

    private final RegistroAlquileresActivos registro;

    public PruebaConcurrencia(RegistroAlquileresActivos registro) {
        this.registro = registro;
    }

    @Override
    public void run(String... args) throws InterruptedException {
        int hilos = 100;
        CountDownLatch salida = new CountDownLatch(1);
        CountDownLatch fin = new CountDownLatch(hilos);

        try (ExecutorService pool = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < hilos; i++) {
                String matricula = String.format("RB-%04d", i);
                pool.submit(() -> {
                    try {
                        salida.await();                 // todos arrancan a la vez
                        registro.iniciar(matricula);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } finally {
                        fin.countDown();
                    }
                });
            }
            salida.countDown();
            fin.await();
        }

        log.info("Esperados 100 | activos: {} | totalIniciados: {}",
                registro.activos(), registro.totalIniciados());
    }
}

package com.ciclourbana.comun;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marca un bean que debe estar operativo al terminar su inicialización.
 * La clase anotada debe exponer un método público boolean estaInicializado().
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiereInicializacion {

    /** Descripción usada en el mensaje de error. */
    String value() default "";
}

package com.ciclourbana.comun;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
public class VerificadorInicializacion implements BeanPostProcessor {

    private static final Logger log = LoggerFactory.getLogger(VerificadorInicializacion.class);

    @Override
    public Object postProcessAfterInitialization(Object bean, String nombreBean) {
        // AnnotationUtils atraviesa proxies y jerarquías de clases
        RequiereInicializacion marca =
                AnnotationUtils.findAnnotation(bean.getClass(), RequiereInicializacion.class);

        if (marca == null) {
            return bean;
        }

        try {
            Method metodo = bean.getClass().getMethod("estaInicializado");
            boolean listo = (boolean) metodo.invoke(bean);

            if (!listo) {
                throw new BeanInitializationException(
                        "El bean '" + nombreBean + "' no quedó inicializado. "
                                + marca.value());
            }
            log.info("Bean '{}' verificado: inicialización correcta", nombreBean);

        } catch (NoSuchMethodException e) {
            throw new BeanInitializationException(
                    "El bean '" + nombreBean + "' lleva @RequiereInicializacion "
                            + "pero no expone un método público boolean estaInicializado()", e);
        } catch (ReflectiveOperationException e) {
            throw new BeanInitializationException(
                    "No se pudo verificar la inicialización de '" + nombreBean + "'", e);
        }

        return bean;   // no sustituimos el bean, solo lo validamos
    }
}

@Component
@RequiereInicializacion("La caché de disponibilidad debe precargarse antes de aceptar tráfico.")
public class CacheDisponibilidad {

    // ... el resto igual que en el apartado 7 ...

    /** Contrato exigido por @RequiereInicializacion. */
    public boolean estaInicializado() {
        return momentoCarga != null;
    }
}

c.c.comun.VerificadorInicializacion : Bean 'cacheDisponibilidad' verificado: inicialización correcta

***************************
APPLICATION FAILED TO START
***************************

org.springframework.beans.factory.BeanInitializationException: El bean
'cacheDisponibilidad' no quedó inicializado. La caché de disponibilidad
debe precargarse antes de aceptar tráfico.