package com.ciclourbana.lloguers;

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 els esdeveniments d'una simulació de demanda. Cada simulació
 * necessita el seu propi acumulador amb estat, així que NO pot ser singleton.
 */
@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)   // equival a @Scope("prototype")
public class SessioSimulacio {

    private final Instant inici = Instant.now();
    private final List<String> esdeveniments = new ArrayList<>();

    public void registrar(String esdeveniment) {
        esdeveniments.add(esdeveniment);
    }

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

    public Instant inici() {
        return inici;
    }
}

@Component
@RequestScope    // = @Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ContextPeticio { /* dades de la petició HTTP en curs */ }

@Component
@SessionScope    // = @Scope(value = "session", proxyMode = ...)
public class CistellaRecarregues { /* estat per usuari, entre peticions */ }

@Service
public class EstacioService {

    private final EstacioRepositori estacioRepositori;

    // PERILL! Camp mutable en un singleton compartit per tots els fils
    private int ultimIdConsultat;
    private List<Estacio> resultatParcial = new ArrayList<>();

    public List<Estacio> cercarPerCapacitatMinima(int minima) {
        resultatParcial.clear();                        // el fil A neteja...
        for (Estacio e : estacioRepositori.cercarTotes()) {
            if (e.capacitat() >= minima) {
                resultatParcial.add(e);                 // ...mentre el fil B afegeix
            }
        }
        return resultatParcial;                         // resultat impredictible
    }
}

@Service
public class EstacioService {

    private final EstacioRepositori estacioRepositori;   // final i immutable

    public EstacioService(EstacioRepositori estacioRepositori) {
        this.estacioRepositori = estacioRepositori;
    }

    public List<Estacio> cercarPerCapacitatMinima(int minima) {
        // Tot l'estat és local al fil: segur per construcció
        return estacioRepositori.cercarTotes().stream()
                .filter(e -> e.capacitat() >= minima)
                .sorted(Comparator.comparing(Estacio::nom))
                .toList();
    }
}

@Service                                    // singleton
public class SimuladorDemanda {

    private final SessioSimulacio sessio;   // prototype

    public SimuladorDemanda(SessioSimulacio sessio) {
        this.sessio = sessio;               // s'injecta UNA vegada, en arrencar
    }

    public void simular() {
        sessio.registrar("simulació executada");   // sempre la MATEIXA sessió!
    }
}

package com.ciclourbana.lloguers;

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

@Service
public class SimuladorDemanda {

    private final ObjectProvider<SessioSimulacio> proveidorSessions;

    public SimuladorDemanda(ObjectProvider<SessioSimulacio> proveidorSessions) {
        this.proveidorSessions = proveidorSessions;
    }

    public void simular(String nomEscenari) {
        // getObject() demana una instància NOVA al contenidor a cada crida
        SessioSimulacio sessio = proveidorSessions.getObject();
        sessio.registrar("escenari: " + nomEscenari);
        sessio.registrar("estacions avaluades: 4");
        // La sessió mor quan surti d'àmbit: Spring no la destrueix
    }
}

@Service
public abstract class SimuladorDemanda {

    public void simular(String nomEscenari) {
        SessioSimulacio sessio = novaSessio();   // instància nova cada vegada
        sessio.registrar("escenari: " + nomEscenari);
    }

    /** Spring implementa aquest mètode per nosaltres. */
    @Lookup
    protected abstract SessioSimulacio novaSessio();
}

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

@Component
public class DiagnosticBean implements BeanNameAware, ApplicationContextAware {

    private String nomBean;
    private ApplicationContext context;

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

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

package com.ciclourbana.estacions;

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;

/**
 * Memòria cau en memòria dels ancoratges lliures per estació.
 *
 * Precalcula els valors en arrencar (@PostConstruct) i bolca
 * estadístiques en tancar (@PreDestroy). És una memòria cau manual: la
 * memòria cau declarativa amb @Cacheable s'estudia a la lliçó 09-02.
 */
@Component
public class CacheDisponibilitat {

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

    private final EstacioRepositori estacioRepositori;

    // ConcurrentHashMap: el bean és singleton i el llegeixen diversos fils
    private final Map<Long, Integer> ancoratgesLliures = new ConcurrentHashMap<>();
    private final AtomicLong encerts = new AtomicLong();
    private final AtomicLong errades = new AtomicLong();

    private Instant momentCarrega;

    public CacheDisponibilitat(EstacioRepositori estacioRepositori) {
        this.estacioRepositori = estacioRepositori;
        // COMPTE: aquí NO precarreguem. El constructor només assigna dependències.
        log.debug("CacheDisponibilitat construïda (encara sense dades)");
    }

    /**
     * S'executa després que totes les dependències estiguin injectades.
     * És el lloc correcte per a feina d'inicialització pesada.
     */
    @PostConstruct
    public void precarregar() {
        Instant inici = Instant.now();

        estacioRepositori.cercarTotes().forEach(estacio ->
                // Simulació: en arrencar considerem la meitat d'ancoratges ocupats
                ancoratgesLliures.put(estacio.id(), estacio.capacitat() / 2));

        this.momentCarrega = Instant.now();
        log.info("Memòria cau de disponibilitat precarregada amb {} estacions en {} ms",
                ancoratgesLliures.size(),
                Duration.between(inici, momentCarrega).toMillis());
    }

    public int ancoratgesLliures(Long estacioId) {
        Integer valor = ancoratgesLliures.get(estacioId);
        if (valor == null) {
            errades.incrementAndGet();
            return recalcular(estacioId);
        }
        encerts.incrementAndGet();
        return valor;
    }

    public void actualitzar(Long estacioId, int lliures) {
        ancoratgesLliures.put(estacioId, lliures);
    }

    private int recalcular(Long estacioId) {
        int lliures = estacioRepositori.cercarPerId(estacioId)
                .map(estacio -> estacio.capacitat() / 2)
                .orElse(0);
        ancoratgesLliures.put(estacioId, lliures);
        return lliures;
    }

    /**
     * S'executa en tancar el context de manera ordenada.
     * Aquí s'alliberarien connexions, fils o fitxers oberts.
     */
    @PreDestroy
    public void alliberar() {
        log.info("Tancant la memòria cau de disponibilitat després de {} de servei",
                Duration.between(momentCarrega, Instant.now()));
        log.info("Estadístiques: {} encerts, {} errades ({}% d'encert)",
                encerts.get(), errades.get(), percentatgeEncert());
        ancoratgesLliures.clear();
    }

    private long percentatgeEncert() {
        long total = encerts.get() + errades.get();
        return total == 0 ? 0 : (encerts.get() * 100) / total;
    }
}

@Component
public class EscalfadorCache {

    private final CacheDisponibilitat cache;
    private final EstacioRepositori repositori;

    public EscalfadorCache(CacheDisponibilitat cache, EstacioRepositori repositori) {
        this.cache = cache;
        this.repositori = repositori;
    }

    /** ApplicationReadyEvent es publica DESPRÉS dels CommandLineRunner. */
    @EventListener(ApplicationReadyEvent.class)
    public void escalfar() {
        repositori.cercarTotes().forEach(e ->
                cache.actualitzar(e.id(), e.capacitat() / 2));
    }
}

./mvnw spring-boot:run

c.c.estacions.CacheDisponibilitat : Memòria cau de disponibilitat precarregada amb 0 estacions en 1 ms
c.c.e.CarregadorEstacionsDemo     : Carregades 4 estacions, 108 ancoratges en total
...
c.c.estacions.CacheDisponibilitat : Tancant la memòria cau de disponibilitat després de PT2M14S de servei
c.c.estacions.CacheDisponibilitat : Estadístiques: 12 encerts, 4 errades (75% d'encert)

@Component
@Lazy   // no es crea fins que algú el demani per primera vegada
public class GeneradorInformesMensuals { /* procés costós, s'utilitza un cop al mes */ }

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

public interface BeanPostProcessor {

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

    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;   // després de @PostConstruct; aquí es retornen els proxies
    }
}

package com.ciclourbana.comu;

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 inicialització dels beans de com.ciclourbana i avisa
 * dels que triguen més del llindar. Eina de diagnòstic d'arrencada.
 */
@Component
public class CronometreInicialitzacioBeans implements BeanPostProcessor {

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

    private static final long LLINDAR_MS = 50;

    // El post-processador s'executa al fil d'arrencada: n'hi ha prou amb HashMap
    private final Map<String, Long> inicis = new HashMap<>();

    @Override
    public Object postProcessBeforeInitialization(Object bean, String nomBean) {
        if (esNostre(bean)) {
            inicis.put(nomBean, System.nanoTime());
        }
        return bean;   // retornem el mateix bean: no el substituïm
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String nomBean) {
        Long inici = inicis.remove(nomBean);
        if (inici != null) {
            long ms = (System.nanoTime() - inici) / 1_000_000;
            if (ms >= LLINDAR_MS) {
                log.warn("Bean lent: '{}' ha trigat {} ms a inicialitzar-se", nomBean, ms);
            } else {
                log.debug("Bean '{}' inicialitzat en {} ms", nomBean, ms);
            }
        }
        return bean;
    }

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

logging.level.com.ciclourbana.comu.CronometreInicialitzacioBeans=DEBUG

c.c.c.CronometreInicialitzacioBeans : Bean 'estacioRepositoriEnMemoria' inicialitzat en 2 ms
c.c.c.CronometreInicialitzacioBeans : Bean 'estacioService' inicialitzat en 1 ms
c.c.c.CronometreInicialitzacioBeans : Bean 'cacheDisponibilitat' inicialitzat en 4 ms
c.c.c.CronometreInicialitzacioBeans : Bean 'tarifaEstandard' inicialitzat en 0 ms

@Service
public class RegistreLloguersActius {

    private int totalIniciats = 0;
    private final List<String> matriculesActives = new ArrayList<>();

    public void iniciar(String matricula) {
        matriculesActives.add(matricula);
        totalIniciats++;
    }

    public void finalitzar(String matricula) {
        matriculesActives.remove(matricula);
    }

    public int actius() {
        return matriculesActives.size();
    }

    public int totalIniciats() {
        return totalIniciats;
    }
}

package com.ciclourbana.comu;

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

import java.util.UUID;

@Component
public class ComptadorSingleton {

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

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

    public ComptadorSingleton() {
        log.info("Construït ComptadorSingleton {}", id);
    }

    public String id() {
        return id;
    }

    @PreDestroy
    public void enDestruir() {
        log.info("Destruït ComptadorSingleton {}", id);
    }
}

package com.ciclourbana.comu;

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 ComptadorPrototype {

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

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

    public String id() {
        return id;
    }

    @PreDestroy
    public void enDestruir() {
        // MAI no s'executa: Spring no gestiona la destrucció dels prototype
        log.info("Destruït ComptadorPrototype {}", id);
    }
}

package com.ciclourbana.comu;

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 DemostracioAmbits implements CommandLineRunner {

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

    private final ApplicationContext context;

    public DemostracioAmbits(ApplicationContext context) {
        this.context = context;
    }

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

Petició 1 -> singleton: a3f91c02 | prototype: 7b2e4d81
Petició 2 -> singleton: a3f91c02 | prototype: c14a9f30
Petició 3 -> singleton: a3f91c02 | prototype: 55d0e7b2
...
Destruït ComptadorSingleton a3f91c02      <- només apareix el del singleton

package com.ciclourbana.lloguers;

import org.springframework.stereotype.Service;

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

/**
 * Registre de lloguers en curs. És un singleton compartit per
 * tots els fils de Tomcat, així que tot el seu estat ha de ser concurrent.
 */
@Service
public class RegistreLloguersActius {

    // Set concurrent: a més evita duplicats, que en aquest domini
    // són un error (una bicicleta no es pot llogar dues vegades)
    private final Set<String> matriculesActives = ConcurrentHashMap.newKeySet();

    // Increment atòmic: sense pèrdua d'actualitzacions
    private final AtomicInteger totalIniciats = new AtomicInteger();

    public void iniciar(String matricula) {
        if (matriculesActives.add(matricula)) {   // add retorna false si ja hi era
            totalIniciats.incrementAndGet();
        }
    }

    public void finalitzar(String matricula) {
        matriculesActives.remove(matricula);
    }

    public int actius() {
        return matriculesActives.size();
    }

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

package com.ciclourbana.lloguers;

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 ProvaConcurrencia implements CommandLineRunner {

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

    private final RegistreLloguersActius registre;

    public ProvaConcurrencia(RegistreLloguersActius registre) {
        this.registre = registre;
    }

    @Override
    public void run(String... args) throws InterruptedException {
        int fils = 100;
        CountDownLatch sortida = new CountDownLatch(1);
        CountDownLatch fi = new CountDownLatch(fils);

        try (ExecutorService pool = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < fils; i++) {
                String matricula = String.format("RB-%04d", i);
                pool.submit(() -> {
                    try {
                        sortida.await();                // tots arrenquen alhora
                        registre.iniciar(matricula);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } finally {
                        fi.countDown();
                    }
                });
            }
            sortida.countDown();
            fi.await();
        }

        log.info("Esperats 100 | actius: {} | totalIniciats: {}",
                registre.actius(), registre.totalIniciats());
    }
}

package com.ciclourbana.comu;

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

/**
 * Marca un bean que ha d'estar operatiu en acabar la seva inicialització.
 * La classe anotada ha d'exposar un mètode públic boolean estaInicialitzat().
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequereixInicialitzacio {

    /** Descripció utilitzada al missatge d'error. */
    String value() default "";
}

package com.ciclourbana.comu;

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 VerificadorInicialitzacio implements BeanPostProcessor {

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

    @Override
    public Object postProcessAfterInitialization(Object bean, String nomBean) {
        // AnnotationUtils travessa proxies i jerarquies de classes
        RequereixInicialitzacio marca =
                AnnotationUtils.findAnnotation(bean.getClass(), RequereixInicialitzacio.class);

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

        try {
            Method metode = bean.getClass().getMethod("estaInicialitzat");
            boolean llest = (boolean) metode.invoke(bean);

            if (!llest) {
                throw new BeanInitializationException(
                        "El bean '" + nomBean + "' no ha quedat inicialitzat. "
                                + marca.value());
            }
            log.info("Bean '{}' verificat: inicialització correcta", nomBean);

        } catch (NoSuchMethodException e) {
            throw new BeanInitializationException(
                    "El bean '" + nomBean + "' porta @RequereixInicialitzacio "
                            + "però no exposa un mètode públic boolean estaInicialitzat()", e);
        } catch (ReflectiveOperationException e) {
            throw new BeanInitializationException(
                    "No s'ha pogut verificar la inicialització de '" + nomBean + "'", e);
        }

        return bean;   // no substituïm el bean, només el validem
    }
}

@Component
@RequereixInicialitzacio("La memòria cau de disponibilitat s'ha de precarregar abans d'acceptar trànsit.")
public class CacheDisponibilitat {

    // ... la resta igual que a l'apartat 7 ...

    /** Contracte exigit per @RequereixInicialitzacio. */
    public boolean estaInicialitzat() {
        return momentCarrega != null;
    }
}

c.c.comu.VerificadorInicialitzacio : Bean 'cacheDisponibilitat' verificat: inicialització correcta

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

org.springframework.beans.factory.BeanInitializationException: El bean
'cacheDisponibilitat' no ha quedat inicialitzat. La memòria cau de disponibilitat
s'ha de precarregar abans d'acceptar trànsit.