package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.modelo.Prestamo;
import com.nexussoftware.bibliotech.repositorio.PrestamoRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.net.http.HttpClient;   // ¿qué hace esto aquí?

@Service
public class GestorPrestamos {

    private final PrestamoRepository repositorio;
    private final HttpClient http;   // un servicio de negocio con un cliente HTTP dentro
    // ...
}

// PRESENTACIÓN: traduce HTTP a una llamada de caso de uso. Nada más.
@PostMapping("/api/prestamos/{id}/devolucion")
public ResponseEntity<FichaPrestamo> devolver(@PathVariable Long id) {
    return ResponseEntity.ok(gestorPrestamos.devolver(id));
}

// APLICACIÓN: orquesta, delimita la transacción, no decide reglas.
@Transactional
public FichaPrestamo devolver(Long id) {
    Prestamo prestamo = repositorio.findById(id)
        .orElseThrow(() -> new PrestamoNoEncontradoException(id));
    Dinero multa = prestamo.registrarDevolucion(LocalDate.now(reloj));  // la regla vive en el dominio
    avisos.notificarDevolucion(prestamo);
    return FichaPrestamo.desde(prestamo);
}

// DOMINIO: la regla de negocio. Sin Spring, sin JPA visible, sin HTTP.
public Dinero registrarDevolucion(LocalDate fecha) {
    if (this.fechaDevolucion.isPresent()) {
        throw new PrestamoYaDevueltoException(this.id);
    }
    this.fechaDevolucion = Optional.of(fecha);
    this.estado = EstadoPrestamo.DEVUELTO;
    return CalculadoraMultas.calcular(this.fechaVencimiento, fecha);
}

// EN EL DOMINIO: una interfaz que el dominio define porque el dominio la necesita.
package com.nexussoftware.bibliotech.dominio.puerto;

public interface RepositorioPrestamos {
    Optional<Prestamo> buscarPorId(Long id);
    Prestamo guardar(Prestamo prestamo);
    List<Prestamo> vencidosA(LocalDate fecha);
}

// EN LA INFRAESTRUCTURA: la implementación, que sí conoce JPA.
package com.nexussoftware.bibliotech.infraestructura.persistencia;

@Repository
class RepositorioPrestamosJpa implements RepositorioPrestamos {

    private final PrestamoSpringDataRepository delegado;   // Spring Data, módulo 11

    RepositorioPrestamosJpa(PrestamoSpringDataRepository delegado) {
        this.delegado = delegado;
    }

    @Override
    public Optional<Prestamo> buscarPorId(Long id) {
        return delegado.findById(id);
    }
    // ...
}

@Test
void devolverConRetrasoGeneraMulta() {
    var repositorio = new RepositorioPrestamosEnMemoria();   // adaptador de prueba
    var notificador  = new NotificadorSilencioso();
    var reloj = Clock.fixed(Instant.parse("2026-03-20T10:00:00Z"), ZoneId.of("Europe/Madrid"));
    var gestor = new GestorPrestamos(repositorio, notificador, reloj);

    repositorio.guardar(unPrestamoDe("978-0000000001", "Marta Ruiz")
        .conVencimiento(LocalDate.of(2026, 3, 10)));

    Dinero multa = gestor.devolver(1L).multa();

    assertThat(multa).isEqualTo(Dinero.euros("5.00"));   // 10 días × 0,50 €
}

com.nexussoftware.bibliotech
├── controlador
├── servicio
├── dominio
└── repositorio

com.nexussoftware.bibliotech
├── catalogo
├── prestamos
├── reservas
└── empleados

package com.nexussoftware.bibliotech.prestamos;

// package-private: NADIE fuera de la funcionalidad "prestamos" puede tocar esto.
class CalculadoraMultas { ... }

src/main/java/com/nexussoftware/bibliotech/
├── BiblioTechApplication.java
├── controlador/
│   ├── PrestamoController.java
│   ├── CatalogoController.java
│   └── ReservaController.java
├── servicio/
│   ├── GestorPrestamos.java
│   ├── ProcesadorReservas.java
│   ├── ServicioAvisos.java
│   ├── EstadisticasBiblioTech.java
│   └── EnriquecedorCatalogo.java
├── dominio/
│   ├── Material.java
│   ├── Libro.java
│   ├── Revista.java
│   ├── Dvd.java
│   ├── Prestamo.java
│   ├── Reserva.java
│   ├── Empleado.java
│   ├── EstadoPrestamo.java
│   └── Gravedad.java
├── repositorio/
│   ├── PrestamoRepository.java
│   ├── MaterialRepository.java
│   └── ReservaRepository.java
└── dto/
    ├── FichaMaterialDto.java
    └── CrearPrestamoDto.java

src/main/java/com/nexussoftware/bibliotech/
├── BiblioTechApplication.java
├── compartido/                      ← solo lo genuinamente transversal
│   ├── Dinero.java
│   ├── Isbn.java
│   ├── Gravedad.java
│   └── BiblioTechException.java
├── catalogo/
│   ├── Material.java                (package-private donde se puede)
│   ├── Libro.java
│   ├── Revista.java
│   ├── Dvd.java
│   ├── TipoMaterial.java
│   ├── CatalogoService.java         ← API pública de la funcionalidad
│   ├── CatalogoController.java
│   ├── MaterialRepository.java
│   └── metadatos/
│       ├── PasarelaMetadatos.java   (puerto)
│       └── ClienteMetadatos.java    (adaptador HTTP)
├── prestamos/
│   ├── Prestamo.java
│   ├── EstadoPrestamo.java
│   ├── CalculadoraMultas.java       (package-private)
│   ├── GestorPrestamos.java         ← API pública
│   ├── PrestamoController.java
│   └── PrestamoRepository.java
├── reservas/
│   ├── Reserva.java
│   ├── ProcesadorReservas.java
│   └── ReservaRepository.java
├── empleados/
│   ├── Empleado.java
│   └── EmpleadoRepository.java
└── avisos/
    ├── NotificadorAvisos.java       (puerto)
    └── ServicioAvisos.java          (adaptador)

bibliotech/
├── pom.xml                       ← POM padre (packaging: pom)
├── mvnw / mvnw.cmd / .mvn/
├── bibliotech-dominio/
│   ├── pom.xml
│   └── src/{main,test}/java/...
├── bibliotech-aplicacion/
│   ├── pom.xml
│   └── src/{main,test}/java/...
├── bibliotech-infraestructura/
│   ├── pom.xml
│   └── src/{main,test}/{java,resources}/...
├── bibliotech-consola/
│   ├── pom.xml
│   └── src/{main,test}/{java,resources}/...
└── bibliotech-web/
    ├── pom.xml
    └── src/{main,test}/{java,resources}/...

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                             https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <!-- Heredamos de Spring Boot: nos da el BOM con las versiones compatibles
       de más de 400 librerías, y la configuración por defecto de los plugins. -->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.4</version>
    <relativePath/>
  </parent>

  <groupId>com.nexussoftware</groupId>
  <artifactId>bibliotech</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <packaging>pom</packaging>            <!-- clave: agregador, no produce jar -->
  <name>BiblioTech</name>
  <description>Gestión de la biblioteca técnica interna de Nexus Software</description>

  <!-- El orden aquí es irrelevante: Maven ordena los módulos por sus dependencias. -->
  <modules>
    <module>bibliotech-dominio</module>
    <module>bibliotech-aplicacion</module>
    <module>bibliotech-infraestructura</module>
    <module>bibliotech-consola</module>
    <module>bibliotech-web</module>
  </modules>

  <properties>
    <java.version>21</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <picocli.version>4.7.6</picocli.version>
    <mapstruct.version>1.6.2</mapstruct.version>
    <springdoc.version>2.6.0</springdoc.version>
  </properties>

  <dependencyManagement>
    <dependencies>
      <!-- Nuestros propios módulos: los hijos los usarán sin repetir la versión. -->
      <dependency>
        <groupId>com.nexussoftware</groupId>
        <artifactId>bibliotech-dominio</artifactId>
        <version>${project.version}</version>
      </dependency>
      <dependency>
        <groupId>com.nexussoftware</groupId>
        <artifactId>bibliotech-aplicacion</artifactId>
        <version>${project.version}</version>
      </dependency>
      <dependency>
        <groupId>com.nexussoftware</groupId>
        <artifactId>bibliotech-infraestructura</artifactId>
        <version>${project.version}</version>
      </dependency>

      <!-- Externas que Spring Boot no gestiona -->
      <dependency>
        <groupId>info.picocli</groupId>
        <artifactId>picocli-spring-boot-starter</artifactId>
        <version>${picocli.version}</version>
      </dependency>
      <dependency>
        <groupId>org.springdoc</groupId>
        <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
        <version>${springdoc.version}</version>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <!-- Estas sí las hereda TODO el mundo, porque todo el mundo prueba. -->
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.assertj</groupId>
      <artifactId>assertj-core</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

<project ...>
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>com.nexussoftware</groupId>
    <artifactId>bibliotech</artifactId>
    <version>1.0.0-SNAPSHOT</version>
  </parent>

  <artifactId>bibliotech-dominio</artifactId>
  <name>BiblioTech :: Dominio</name>

  <!-- Fíjate bien: NO HAY <dependencies> de producción.
       Ni Spring, ni Hibernate, ni Jackson, ni HttpClient de terceros.
       Solo la biblioteca estándar de Java 21.
       Esto no es un adorno: es la regla de dependencia, hecha cumplir por Maven. -->
</project>

<project ...>
  <parent>
    <groupId>com.nexussoftware</groupId>
    <artifactId>bibliotech</artifactId>
    <version>1.0.0-SNAPSHOT</version>
  </parent>

  <artifactId>bibliotech-infraestructura</artifactId>
  <name>BiblioTech :: Infraestructura</name>

  <dependencies>
    <dependency>
      <groupId>com.nexussoftware</groupId>
      <artifactId>bibliotech-aplicacion</artifactId>   <!-- versión heredada del padre -->
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>org.flywaydb</groupId>
      <artifactId>flyway-core</artifactId>
    </dependency>
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <scope>runtime</scope>
    </dependency>
  </dependencies>
</project>

# Construye los cinco módulos en el orden correcto (Maven lo deduce del grafo)
./mvnw clean install

# Solo el dominio y lo que necesita para compilar (-am = also make)
./mvnw -pl bibliotech-dominio -am test

# El árbol de dependencias del dominio: debe ser prácticamente vacío
./mvnw -pl bibliotech-dominio dependency:tree

package com.nexussoftware.bibliotech.dominio.prestamos;

import org.springframework.stereotype.Service;   // en bibliotech-dominio

@Service
public class CalculadoraMultas { ... }

$ ./mvnw -pl bibliotech-dominio compile
[ERROR] /.../CalculadoraMultas.java:[3,32] package org.springframework.stereotype does not exist
[ERROR] /.../CalculadoraMultas.java:[5,2] cannot find symbol: class Service
[INFO] BUILD FAILURE

[ERROR] The projects in the reactor contain a cyclic reference:
        bibliotech-dominio -> bibliotech-infraestructura -> bibliotech-dominio

@AnalyzeClasses(packages = "com.nexussoftware.bibliotech")
class ReglasDeArquitecturaTest {

    @ArchTest
    static final ArchRule elDominioNoDependeDeSpring =
        noClasses().that().resideInAPackage("..dominio..")
            .should().dependOnClassesThat().resideInAnyPackage("org.springframework..");

    @ArchTest
    static final ArchRule elDominioNoDependeDeJpa =
        noClasses().that().resideInAPackage("..dominio..")
            .should().dependOnClassesThat().resideInAnyPackage("jakarta.persistence..");

    @ArchTest
    static final ArchRule sinCiclos =
        slices().matching("com.nexussoftware.bibliotech.(*)..").should().beFreeOfCycles();
}

package com.nexussoftware.bibliotech.web.dto;

/**
 * Lo que la API DEVUELVE de un préstamo. Contrato público, estable,
 * independiente de cómo esté modelada la entidad por dentro.
 */
public record PrestamoResponse(
        Long id,
        String tituloMaterial,
        String isbn,
        String nombreEmpleado,
        LocalDate fechaPrestamo,
        LocalDate fechaVencimiento,
        LocalDate fechaDevolucion,   // null si sigue prestado: JSON no tiene Optional
        String estado,
        long diasRestantes,          // campo calculado que la entidad no tiene
        BigDecimal multa) {

    public static PrestamoResponse desde(Prestamo p, LocalDate hoy) {
        return new PrestamoResponse(
            p.getId(),
            p.getMaterial().getTitulo(),
            p.getMaterial().getIsbn().valor(),
            p.getEmpleado().getNombre(),
            p.getFechaPrestamo(),
            p.getFechaVencimiento(),
            p.getFechaDevolucion().orElse(null),
            p.getEstado().name(),
            ChronoUnit.DAYS.between(hoy, p.getFechaVencimiento()),
            p.multaAcumulada(hoy).importe());
    }
}

/**
 * Lo que la API ACEPTA para crear un préstamo. Solo los campos que
 * el cliente tiene derecho a decidir. Ni id, ni version, ni estado.
 */
public record CrearPrestamoRequest(
        @NotBlank @Isbn String isbn,
        @NotNull Long idEmpleado,
        @Positive @Max(30) Integer dias) {
}

@Mapper(componentModel = "spring")
public interface PrestamoMapper {
    @Mapping(target = "tituloMaterial", source = "material.titulo")
    @Mapping(target = "nombreEmpleado", source = "empleado.nombre")
    PrestamoResponse aResponse(Prestamo prestamo);
}

spring:
  application:
    name: bibliotech
  jpa:
    open-in-view: false            # desactívalo SIEMPRE: evita consultas en la capa de vista (11-03)
    properties:
      hibernate:
        jdbc.batch_size: 25
  threads:
    virtual:
      enabled: true                # hilos virtuales de Java 21 (10-06), se explica en 12-04

server:
  port: 8080
  shutdown: graceful               # apagado ordenado, se desarrolla en 12-06

bibliotech:                        # nuestras propiedades, tipadas en PropiedadesBiblioTech
  prestamo:
    dias-por-defecto: 15
    maximo-activos-por-empleado: 3
  multa:
    importe-por-dia: 0.50
    importe-maximo: 20.00
  metadatos:
    url-base: https://api.metadatos.ejemplo/v1
    tiempo-espera: 3s

logging:
  level:
    com.nexussoftware.bibliotech: INFO

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/bibliotech
    username: bibliotech
    password: bibliotech            # local, desechable, nunca reutilizada fuera
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: validate            # nunca 'update': el esquema lo gobierna Flyway (12-06)
  flyway:
    enabled: true

logging:
  level:
    com.nexussoftware.bibliotech: DEBUG
    org.hibernate.SQL: DEBUG

spring:
  datasource:
    url: ${BIBLIOTECH_DB_URL}       # sin valor por defecto: si falta, la app NO arranca
    username: ${BIBLIOTECH_DB_USER}
    password: ${BIBLIOTECH_DB_PASSWORD}
    hikari:
      maximum-pool-size: 20
  jpa:
    show-sql: false
    hibernate:
      ddl-auto: validate

server:
  error:
    include-stacktrace: never       # nunca filtrar trazas al cliente (12-04, 12-07)
    include-message: never

logging:
  level:
    root: WARN
    com.nexussoftware.bibliotech: INFO

# En desarrollo
./mvnw -pl bibliotech-web spring-boot:run -Dspring-boot.run.profiles=dev

# En producción (variable de entorno, no argumento)
SPRING_PROFILES_ACTIVE=prod java -jar bibliotech-web.jar

# Buscar secretos en TODO el historial, no solo en el árbol actual
gitleaks detect --source . --verbose

# Como enganche de pre-commit, para que no llegue ni a entrar
pre-commit run --all-files

# --- Maven ---
target/
!.mvn/wrapper/maven-wrapper.jar
.mvn/timing.properties
dependency-reduced-pom.xml

# --- Java ---
*.class
*.jar
*.war
hs_err_pid*.log
replay_pid*.log

# --- IDE: IntelliJ ---
.idea/
*.iml
*.iws

# --- IDE: Eclipse ---
.classpath
.project
.settings/
bin/

# --- IDE: VS Code (se versiona launch.json si el equipo lo comparte) ---
.vscode/*
!.vscode/launch.json
!.vscode/settings.json

# --- Sistema operativo ---
.DS_Store
Thumbs.db

# --- Local y secretos ---
.env
*.local.yml
application-local.yml
/config/secrets/
*.p12
*.jks
*.pem

feat(api)!: eliminar el campo `disponible` de MaterialResponse

BREAKING CHANGE: los clientes deben usar `unidadesDisponibles`, que es un
entero, en lugar del booleano `disponible`. El campo antiguo estuvo marcado
como deprecado desde la versión 1.4.0.

root = true

[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
indent_style = space
indent_size = 4
max_line_length = 120

[*.{xml,yml,yaml,json}]
indent_size = 2

[*.md]
trim_trailing_whitespace = false   # dos espacios finales = salto de línea en Markdown

[*.{sh,bash}]
indent_size = 2

<build>
  <pluginManagement>
    <plugins>
      <plugin>
        <groupId>com.diffplug.spotless</groupId>
        <artifactId>spotless-maven-plugin</artifactId>
        <version>2.43.0</version>
        <configuration>
          <java>
            <palantirJavaFormat/>          <!-- o <googleJavaFormat/> -->
            <removeUnusedImports/>
            <importOrder>
              <order>java,javax,jakarta,org,com,com.nexussoftware,</order>
            </importOrder>
            <licenseHeader>
              <content>/* BiblioTech - Nexus Software */</content>
            </licenseHeader>
          </java>
          <pom>
            <sortPom/>
          </pom>
        </configuration>
        <executions>
          <execution>
            <goals>
              <!-- 'check' falla la construcción; 'apply' arregla.
                   En CI queremos que falle. -->
              <goal>check</goal>
            </goals>
            <phase>validate</phase>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </pluginManagement>
</build>

./mvnw spotless:apply    # formatea todo el proyecto
./mvnw spotless:check    # solo comprueba: esto es lo que corre en CI

# .git-blame-ignore-revs
# Reformateo inicial con Spotless (sin cambios funcionales)
a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0

git config blame.ignoreRevsFile .git-blame-ignore-revs

# BiblioTech

Sistema de gestión de la biblioteca técnica interna de Nexus Software.
Gestiona el catálogo de materiales (libros, revistas, DVD), los préstamos
a empleados, las reservas y las multas por retraso.

## Requisitos

| Herramienta | Versión | Comprobación |
|---|---|---|
| JDK | 21+ | `java -version` |
| Docker | 24+ | `docker --version` |
| Maven | No hace falta: usa `./mvnw` | — |

## Arranque rápido

Comprobación:

Documentación de la API: <http://localhost:8080/swagger-ui.html>

## Comandos habituales

| Objetivo | Comando |
|---|---|
| Compilar todo | `./mvnw clean install` |
| Solo pruebas unitarias | `./mvnw test` |
| Pruebas de integración | `./mvnw verify` |
| Informe de cobertura | `./mvnw verify` → `target/site/jacoco/index.html` |
| Formatear el código | `./mvnw spotless:apply` |
| CLI | `java -jar bibliotech-consola/target/bibliotech-consola.jar catalogo listar` |

## Estructura

| Módulo | Responsabilidad |
|---|---|
| `bibliotech-dominio` | Entidades y reglas de negocio. Sin dependencias externas |
| `bibliotech-aplicacion` | Casos de uso |
| `bibliotech-infraestructura` | JPA, HTTP, correo, configuración de Spring |
| `bibliotech-consola` | CLI con Picocli |
| `bibliotech-web` | API REST |

Decisiones de arquitectura: [`docs/adr/`](docs/adr/).

## Configuración

Todas las propiedades propias están bajo `bibliotech.*` en `application.yml`.
En producción se inyectan por variables de entorno (ver `docs/despliegue.md`).
**Nunca** se añaden secretos al repositorio.

## Contribuir

1. Rama desde `main`: `feature/descripcion-corta`
2. Commits con [Conventional Commits](https://www.conventionalcommits.org/)
3. `./mvnw verify` y `./mvnw spotless:check` en verde
4. Pull Request; requiere una aprobación y CI en verde

# ADR-004: Renunciar a `sealed` en la jerarquía Material

- **Estado:** Aceptada
- **Fecha:** 2026-06-18
- **Decisores:** Marta Ruiz, Diego Alonso

## Contexto

`Material` era una interfaz `sealed` (Java 17, módulo 10) con `Libro`, `Revista`
y `Dvd` como únicas implementaciones permitidas, lo que habilitaba pattern
matching exhaustivo sin `default`.

Al pasar a JPA con estrategia `SINGLE_TABLE`, Hibernate necesita crear proxies
por subclase y las entidades no pueden pertenecer a una jerarquía sellada
gestionada de ese modo.

## Decisión

Convertir `Material` en clase abstracta no sellada, con `@Inheritance(SINGLE_TABLE)`
y `@DiscriminatorColumn(name = "tipo")`.

## Consecuencias

**Positivas:** persistencia polimórfica con una sola consulta; sin JOIN por tipo.

**Negativas:** se pierde la exhaustividad del `switch`; hay que mantener una rama
`default` que lance `IllegalStateException`. Cualquiera puede heredar de `Material`
sin que el compilador lo impida.

**Mitigación:** una prueba de ArchUnit comprueba que las subclases de `Material`
son exactamente tres.

## Alternativas descartadas

- **`TABLE_PER_CLASS`:** mantendría el modelo, pero las consultas polimórficas
  se convierten en `UNION` y el rendimiento del catálogo se degrada.
- **Modelo de dominio separado del de persistencia:** conserva `sealed`, a costa
  de duplicar nueve clases y sus mapeos. Desproporcionado para este proyecto.

# compose.yaml — solo dependencias, NO la aplicación.
# En desarrollo la app corre en el IDE, con recarga en caliente y depurador.
services:
  postgres:
    image: postgres:16-alpine
    container_name: bibliotech-db
    environment:
      POSTGRES_DB: bibliotech
      POSTGRES_USER: bibliotech
      POSTGRES_PASSWORD: bibliotech
    ports:
      - "5432:5432"
    volumes:
      - bibliotech-datos:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U bibliotech"]
      interval: 5s
      timeout: 3s
      retries: 10

volumes:
  bibliotech-datos:

docker compose up -d        # levantar
docker compose logs -f      # ver registros
docker compose down         # parar (los datos sobreviven en el volumen)
docker compose down -v      # parar y BORRAR los datos

#!/usr/bin/env bash
set -euo pipefail          # -e: falla al primer error; -u: variable sin definir es error;
                           # -o pipefail: un fallo en medio de una tubería cuenta

cd "$(dirname "$0")/.."    # ejecutable desde cualquier directorio

echo "==> Levantando dependencias"
docker compose up -d --wait     # --wait espera a que el healthcheck esté en verde

echo "==> Construyendo"
./mvnw -q clean install -DskipTests

echo "==> Arrancando BiblioTech (perfil dev)"
exec ./mvnw -pl bibliotech-web spring-boot:run -Dspring-boot.run.profiles=dev

bibliotech/
├── .editorconfig                       # estilo común a todos los editores
├── .gitignore
├── .git-blame-ignore-revs              # ignora el commit de reformateo
├── .github/
│   └── workflows/
│       └── ci.yml                      # se escribe en 12-05
├── compose.yaml                        # PostgreSQL local
├── mvnw, mvnw.cmd, .mvn/               # wrapper: misma versión de Maven para todos (11-05)
├── pom.xml                             # POM padre: módulos + dependencyManagement
├── README.md
├── docs/
│   ├── adr/
│   │   ├── 0001-arquitectura-por-capas-con-puertos.md
│   │   ├── 0002-proyecto-multimodulo-maven.md
│   │   ├── 0003-postgresql-en-lugar-de-h2.md
│   │   └── 0004-renunciar-a-sealed-en-material.md
│   └── despliegue.md                   # 12-06
├── scripts/
│   ├── dev.sh
│   └── bibliotech                      # lanzador de la CLI (12-03)
│
├── bibliotech-dominio/                 # ── SIN DEPENDENCIAS EXTERNAS ──
│   ├── pom.xml
│   └── src/main/java/com/nexussoftware/bibliotech/dominio/
│       ├── compartido/
│       │   ├── Dinero.java
│       │   ├── Isbn.java
│       │   ├── Gravedad.java
│       │   └── BiblioTechException.java        # jerarquía del módulo 6
│       ├── catalogo/
│       │   ├── Material.java
│       │   ├── Libro.java  Revista.java  Dvd.java
│       │   ├── TipoMaterial.java
│       │   └── puerto/
│       │       ├── RepositorioMateriales.java
│       │       └── PasarelaMetadatos.java
│       ├── prestamos/
│       │   ├── Prestamo.java
│       │   ├── EstadoPrestamo.java
│       │   ├── CalculadoraMultas.java
│       │   ├── ReglaTarifa.java                # Estrategia, se formaliza en 12-02
│       │   └── puerto/RepositorioPrestamos.java
│       ├── reservas/
│       │   ├── Reserva.java
│       │   └── puerto/RepositorioReservas.java
│       └── empleados/
│           ├── Empleado.java
│           └── puerto/RepositorioEmpleados.java
│
├── bibliotech-aplicacion/              # ── casos de uso ──
│   ├── pom.xml                         # depende SOLO de dominio
│   └── src/main/java/com/nexussoftware/bibliotech/aplicacion/
│       ├── prestamos/
│       │   ├── GestionarPrestamos.java         # puerto de entrada
│       │   └── GestorPrestamos.java            # implementación
│       ├── catalogo/
│       │   ├── ConsultarCatalogo.java
│       │   ├── CatalogoService.java
│       │   └── EnriquecedorCatalogo.java
│       ├── reservas/ProcesadorReservas.java
│       ├── avisos/ServicioAvisos.java
│       └── estadisticas/EstadisticasBiblioTech.java
│
├── bibliotech-infraestructura/         # ── adaptadores de salida ──
│   ├── pom.xml
│   └── src/main/
│       ├── java/com/nexussoftware/bibliotech/infraestructura/
│       │   ├── persistencia/
│       │   │   ├── RepositorioPrestamosJpa.java
│       │   │   ├── PrestamoSpringDataRepository.java
│       │   │   ├── RepositorioMaterialesJpa.java
│       │   │   └── convertidor/IsbnConverter.java
│       │   ├── metadatos/ClienteMetadatos.java     # HttpClient (módulo 9)
│       │   ├── avisos/NotificadorCorreo.java
│       │   ├── sockets/ServidorCatalogo.java       # el del módulo 9, sigue vivo
│       │   └── config/
│       │       ├── PropiedadesBiblioTech.java
│       │       ├── ConfiguracionReloj.java         # Clock inyectable (10-05)
│       │       └── AspectoCronometro.java          # AOP (11-02)
│       └── resources/db/migration/                 # Flyway (12-06)
│           ├── V1__esquema_inicial.sql
│           └── V2__indices_catalogo.sql
│
├── bibliotech-consola/                 # ── adaptador de entrada: CLI (12-03) ──
│   ├── pom.xml
│   └── src/main/java/com/nexussoftware/bibliotech/consola/
│       ├── BiblioTechCli.java
│       └── comandos/…
│
└── bibliotech-web/                     # ── adaptador de entrada: REST (12-04) ──
    ├── pom.xml
    └── src/main/
        ├── java/com/nexussoftware/bibliotech/web/
        │   ├── BiblioTechApplication.java
        │   ├── prestamos/PrestamoController.java
        │   ├── catalogo/CatalogoController.java
        │   ├── dto/…
        │   └── error/ManejadorGlobalErrores.java
        └── resources/
            ├── application.yml
            ├── application-dev.yml
            ├── application-prod.yml
            └── logback-spring.xml                  # SLF4J + MDC (11-07)

$ ./mvnw -pl bibliotech-dominio dependency:tree
[INFO] com.nexussoftware:bibliotech-dominio:jar:1.0.0-SNAPSHOT
[INFO] +- org.springframework.boot:spring-boot-starter-test:jar:3.3.4:test
[INFO] \- org.assertj:assertj-core:jar:3.25.3:test

package com.nexussoftware.bibliotech.dominio.avisos;

import com.nexussoftware.bibliotech.dominio.prestamos.Prestamo;
import com.nexussoftware.bibliotech.infraestructura.correo.ServidorSmtp;
import org.springframework.stereotype.Service;

@Service
public class ServicioAvisos {

    private final ServidorSmtp smtp = new ServidorSmtp("smtp.nexussoftware.com", 587);

    public void avisarVencimiento(Prestamo prestamo) {
        String cuerpo = "Hola " + prestamo.getEmpleado().getNombre()
                      + ", el préstamo de \"" + prestamo.getMaterial().getTitulo()
                      + "\" vence el " + prestamo.getFechaVencimiento() + ".";
        smtp.enviar(prestamo.getEmpleado().getCorreo(), "Aviso de vencimiento", cuerpo);
    }
}

spring:
  datasource:
    url: jdbc:postgresql://db-produccion.nexussoftware.com:5432/bibliotech
    username: admin
    password: Nexus2026!
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
server:
  port: 8080
  error:
    include-stacktrace: always
bibliotech:
  metadatos:
    api-key: sk-live-9f3a2b1c8d7e6f5a
logging:
  level:
    root: DEBUG

// bibliotech-dominio/…/dominio/avisos/puerto/NotificadorAvisos.java
package com.nexussoftware.bibliotech.dominio.avisos.puerto;

import com.nexussoftware.bibliotech.dominio.avisos.Aviso;

/**
 * Puerto de salida: el dominio declara QUÉ necesita (notificar),
 * sin decir CÓMO (correo, SMS, consola, cola de mensajes).
 */
public interface NotificadorAvisos {
    void notificar(Aviso aviso);
}

// bibliotech-dominio/…/dominio/avisos/Aviso.java
package com.nexussoftware.bibliotech.dominio.avisos;

public record Aviso(String destinatario,
                    TipoAviso tipo,
                    String nombreEmpleado,
                    String tituloMaterial,
                    LocalDate fecha) {

    public static Aviso porVencimiento(Prestamo prestamo) {
        return new Aviso(
            prestamo.correoDelEmpleado(),          // método del propio Prestamo: sin cadena de getters
            TipoAviso.VENCIMIENTO,
            prestamo.nombreDelEmpleado(),
            prestamo.tituloDelMaterial(),
            prestamo.getFechaVencimiento());
    }
}

// bibliotech-aplicacion/…/aplicacion/avisos/ServicioAvisos.java
package com.nexussoftware.bibliotech.aplicacion.avisos;

public class ServicioAvisos {

    private final NotificadorAvisos notificador;   // el PUERTO, no la implementación
    private final RepositorioPrestamos prestamos;
    private final Clock reloj;                     // 10-05: nunca LocalDate.now() a pelo

    public ServicioAvisos(NotificadorAvisos notificador,
                          RepositorioPrestamos prestamos,
                          Clock reloj) {
        this.notificador = notificador;
        this.prestamos = prestamos;
        this.reloj = reloj;
    }

    public int avisarVencimientosProximos(int diasDeAntelacion) {
        LocalDate limite = LocalDate.now(reloj).plusDays(diasDeAntelacion);
        List<Prestamo> proximos = prestamos.vencidosA(limite);
        proximos.forEach(p -> notificador.notificar(Aviso.porVencimiento(p)));
        return proximos.size();
    }
}

// bibliotech-infraestructura/…/infraestructura/avisos/NotificadorCorreo.java
package com.nexussoftware.bibliotech.infraestructura.avisos;

@Component
class NotificadorCorreo implements NotificadorAvisos {

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

    private final JavaMailSender correo;
    private final PropiedadesBiblioTech props;     // host, puerto y remitente vienen de aquí

    NotificadorCorreo(JavaMailSender correo, PropiedadesBiblioTech props) {
        this.correo = correo;
        this.props = props;
    }

    @Override
    public void notificar(Aviso aviso) {
        var mensaje = new SimpleMailMessage();
        mensaje.setFrom(props.avisos().remitente());
        mensaje.setTo(aviso.destinatario());
        mensaje.setSubject("BiblioTech: aviso de vencimiento");
        mensaje.setText("""
                Hola %s,

                El préstamo de "%s" vence el %s.

                — BiblioTech, Nexus Software
                """.formatted(aviso.nombreEmpleado(), aviso.tituloMaterial(), aviso.fecha()));
        try {
            correo.send(mensaje);
        } catch (MailException e) {
            // Frontera de errores (06-07): traducir a la excepción del dominio
            log.warn("No se pudo enviar el aviso a {}", aviso.destinatario(), e);
            throw new NotificacionFallidaException(aviso.destinatario(), e);
        }
    }
}

// bibliotech-infraestructura/…/infraestructura/config/ConfiguracionAvisos.java
@Configuration
class ConfiguracionAvisos {

    @Bean
    ServicioAvisos servicioAvisos(NotificadorAvisos notificador,
                                  RepositorioPrestamos prestamos,
                                  Clock reloj) {
        return new ServicioAvisos(notificador, prestamos, reloj);
    }
}

// DOMINIO: los datos del informe. Sin PDF, sin ficheros, sin fechas de servidor.
package com.nexussoftware.bibliotech.dominio.informes;

public record InformeMensual(YearMonth periodo,
                             List<LineaMaterial> masPrestados,
                             List<LineaEmpleado> masMultados,
                             double porcentajeDevolucionesConRetraso) {

    public String nombreSugerido() {
        return "bibliotech-%s.pdf".formatted(periodo);   // yyyy-MM
    }
}

// PUERTO: convertir el informe en bytes. El dominio no sabe que existe el PDF.
package com.nexussoftware.bibliotech.dominio.informes.puerto;

public interface GeneradorInforme {
    byte[] generar(InformeMensual informe);
    String tipoMime();     // "application/pdf", "text/csv"…
}

// PUERTO: dónde se guarda. El dominio no sabe si es disco, S3 o base de datos.
public interface AlmacenInformes {
    URI guardar(String nombre, byte[] contenido, String tipoMime);
}

// PUERTO: de dónde salen los agregados. El dominio no sabe qué es JPQL.
public interface RepositorioEstadisticas {
    List<LineaMaterial> materialesMasPrestados(YearMonth periodo, int limite);
    List<LineaEmpleado> empleadosMasMultados(YearMonth periodo, int limite);
    double porcentajeConRetraso(YearMonth periodo);
}

// APLICACIÓN
package com.nexussoftware.bibliotech.aplicacion.informes;

public interface EmitirInformeMensual {           // puerto de ENTRADA
    ResultadoInforme emitir(YearMonth periodo, boolean enviarPorCorreo);
}

public class ServicioInformeMensual implements EmitirInformeMensual {

    private final RepositorioEstadisticas estadisticas;
    private final GeneradorInforme generador;
    private final AlmacenInformes almacen;
    private final NotificadorAvisos notificador;
    private final Clock reloj;

    // constructor con los cinco puertos…

    @Override
    public ResultadoInforme emitir(YearMonth periodo, boolean enviarPorCorreo) {
        var informe = new InformeMensual(
                periodo,
                estadisticas.materialesMasPrestados(periodo, 10),
                estadisticas.empleadosMasMultados(periodo, 10),
                estadisticas.porcentajeConRetraso(periodo));

        byte[] contenido = generador.generar(informe);
        URI ubicacion = almacen.guardar(informe.nombreSugerido(), contenido, generador.tipoMime());

        if (enviarPorCorreo) {
            notificador.notificar(Aviso.informeDisponible(periodo, ubicacion));
        }
        return new ResultadoInforme(periodo, ubicacion, contenido.length);
    }
}

// infraestructura: automático el día 1 a las 06:00
@Component
class PlanificadorInformes {
    private final EmitirInformeMensual caso;
    @Scheduled(cron = "0 0 6 1 * *")
    void mensual() { caso.emitir(YearMonth.now().minusMonths(1), true); }
}

// consola (12-03)
@Command(name = "informe", description = "Genera el informe mensual de uso")
class ComandoInforme implements Callable<Integer> { … }

// web (12-04)
@PostMapping("/api/informes/{periodo}")
ResponseEntity<InformeResponse> generar(@PathVariable YearMonth periodo) { … }

spring:
  application:
    name: bibliotech
  jpa:
    open-in-view: false
    hibernate:
      ddl-auto: validate        # el esquema lo gobierna Flyway; validate detecta desajustes
  flyway:
    enabled: true

server:
  port: ${SERVER_PORT:8080}     # con valor por defecto: no es un secreto
  shutdown: graceful
  error:
    include-stacktrace: never
    include-message: never

bibliotech:
  metadatos:
    url-base: https://api.metadatos.ejemplo/v1
    tiempo-espera: 3s
    # api-key NO está aquí: llega por variable de entorno

logging:
  level:
    root: INFO
    com.nexussoftware.bibliotech: INFO

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/bibliotech
    username: bibliotech
    password: bibliotech        # aceptable: base local en un contenedor efímero
  jpa:
    show-sql: true

server:
  error:
    include-stacktrace: on_param   # ?trace=true, cómodo al depurar

bibliotech:
  metadatos:
    api-key: ${METADATOS_API_KEY:clave-de-desarrollo}

logging:
  level:
    com.nexussoftware.bibliotech: DEBUG
    org.hibernate.SQL: DEBUG
    org.hibernate.orm.jdbc.bind: TRACE   # ver los parámetros ligados: solo en dev

spring:
  datasource:
    url: ${BIBLIOTECH_DB_URL}
    username: ${BIBLIOTECH_DB_USER}         # usuario con permisos mínimos, NO admin
    password: ${BIBLIOTECH_DB_PASSWORD}
    hikari:
      maximum-pool-size: 20
  jpa:
    show-sql: false

bibliotech:
  metadatos:
    api-key: ${METADATOS_API_KEY}           # sin defecto: si falta, no arranca

logging:
  level:
    root: WARN
    com.nexussoftware.bibliotech: INFO