public interface AuthorRepository extends Repository<Author, UUID> {
    List<Author> findByLastName(String lastNamePart);
    Optional<Author> findByFullName(String lastName, String firstName);
}

List<Audiobook> findByGenre(String genre);
List<Audiobook> findByGenreAndYear(String genre, Integer year);
List<Audiobook> findByGenreAndYearRange(String genre, Integer minYear, Integer maxYear);
List<Audiobook> findByGenreAndMinDuration(String genre, Integer minDuration);
// ... ще десятки методів для всіх комбінацій

// Прості специфікації — будівельні блоки
Specification<Audiobook> poetry = new GenreSpec("Поезія");
Specification<Audiobook> prose  = new GenreSpec("Проза");
Specification<Audiobook> after2020 = new YearAfterSpec(2020);
Specification<Audiobook> affordable = new PriceRangeSpec(
    BigDecimal.valueOf(100), 
    BigDecimal.valueOf(500)
);
Specification<Audiobook> ukrainian = new LanguageSpec("українська");

// Композиція через логічні оператори
Specification<Audiobook> poetryOrProse = poetry.or(prose);
Specification<Audiobook> complexQuery = poetryOrProse
    .and(after2020)
    .and(affordable)
    .and(ukrainian);

// Використання у репозиторії
List<Audiobook> results = audiobookRepository.findAll(complexQuery);

package com.example.audiobook.specification;

/**
 * Базовий інтерфейс Specification Pattern за Еріком Евансом (DDD, 2003).
 * <p>
 * Specification інкапсулює бізнес-правило у вигляді предиката, що може бути:
 * <ul>
 *   <li>Застосований до об'єкта у пам'яті ({@link #isSatisfiedBy});</li>
 *   <li>Перетворений на SQL WHERE-умову ({@link #toSql});</li>
 *   <li>Скомбінований з іншими специфікаціями ({@link #and}, {@link #or}, {@link #not}).</li>
 * </ul>
 * <p>
 * <b>Приклад використання:</b>
 * <pre>{@code
 * Specification<Audiobook> affordable = new PriceRangeSpec(100, 500);
 * Specification<Audiobook> ukrainian  = new LanguageSpec("українська");
 * Specification<Audiobook> query = affordable.and(ukrainian);
 * 
 * // In-memory фільтрація
 * boolean matches = query.isSatisfiedBy(someBook);
 * 
 * // SQL-генерація
 * String whereClause = query.toSql();  // "price BETWEEN ? AND ? AND language = ?"
 * List<Object> params = query.getParameters();  // [100, 500, "українська"]
 * }</pre>
 *
 * @param <T> тип доменної сутності (Author, Genre, Audiobook)
 */
public interface Specification<T> {

    /**
     * Перевіряє, чи задовольняє об'єкт умовам специфікації (in-memory).
     * <p>
     * Використовується для валідації об'єктів у пам'яті або фільтрації
     * невеликих колекцій через {@code stream().filter(spec::isSatisfiedBy)}.
     *
     * @param candidate об'єкт для перевірки
     * @return {@code true} якщо об'єкт задовольняє умовам
     */
    boolean isSatisfiedBy(T candidate);

    /**
     * Генерує SQL WHERE-умову для цієї специфікації.
     * <p>
     * Повертає фрагмент SQL без ключового слова {@code WHERE}.
     * Параметри представлені як {@code ?} (JDBC placeholders).
     * <p>
     * <b>Приклад:</b> {@code "price <= ? AND language = ?"}
     *
     * @return SQL-фрагмент для WHERE-умови
     */
    String toSql();

    /**
     * Повертає список параметрів для {@link #toSql()} у порядку появи {@code ?}.
     * <p>
     * Ці значення передаються у {@link java.sql.PreparedStatement#setObject}.
     *
     * @return список параметрів (може бути порожнім)
     */
    java.util.List<Object> getParameters();

    /**
     * Логічне AND: обидві специфікації мають бути задоволені.
     *
     * @param other друга специфікація
     * @return нова специфікація {@code this AND other}
     */
    default Specification<T> and(Specification<T> other) {
        return new AndSpecification<>(this, other);
    }

    /**
     * Логічне OR: хоча б одна специфікація має бути задоволена.
     *
     * @param other друга специфікація
     * @return нова специфікація {@code this OR other}
     */
    default Specification<T> or(Specification<T> other) {
        return new OrSpecification<>(this, other);
    }

    /**
     * Логічне NOT: інверсія умови.
     *
     * @return нова специфікація {@code NOT this}
     */
    default Specification<T> not() {
        return new NotSpecification<>(this);
    }
}

package com.example.audiobook.specification;

import java.util.ArrayList;
import java.util.List;

/**
 * Логічне AND: обидві специфікації мають бути задоволені.
 * <p>
 * SQL-генерація: {@code (left) AND (right)}.
 * Дужки обов'язкові для правильного пріоритету операторів.
 */
public class AndSpecification<T> implements Specification<T> {

    private final Specification<T> left;
    private final Specification<T> right;

    public AndSpecification(Specification<T> left, Specification<T> right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public boolean isSatisfiedBy(T candidate) {
        // Обидві умови мають бути true
        return left.isSatisfiedBy(candidate) && right.isSatisfiedBy(candidate);
    }

    @Override
    public String toSql() {
        // Дужки критично важливі: (a OR b) AND c ≠ a OR (b AND c)
        return "(" + left.toSql() + ") AND (" + right.toSql() + ")";
    }

    @Override
    public List<Object> getParameters() {
        // Об'єднуємо параметри обох специфікацій у порядку появи
        List<Object> params = new ArrayList<>();
        params.addAll(left.getParameters());
        params.addAll(right.getParameters());
        return params;
    }
}

package com.example.audiobook.specification;

import java.util.ArrayList;
import java.util.List;

/**
 * Логічне OR: хоча б одна специфікація має бути задоволена.
 * <p>
 * SQL-генерація: {@code (left) OR (right)}.
 */
public class OrSpecification<T> implements Specification<T> {

    private final Specification<T> left;
    private final Specification<T> right;

    public OrSpecification(Specification<T> left, Specification<T> right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public boolean isSatisfiedBy(T candidate) {
        // Достатньо однієї true
        return left.isSatisfiedBy(candidate) || right.isSatisfiedBy(candidate);
    }

    @Override
    public String toSql() {
        return "(" + left.toSql() + ") OR (" + right.toSql() + ")";
    }

    @Override
    public List<Object> getParameters() {
        List<Object> params = new ArrayList<>();
        params.addAll(left.getParameters());
        params.addAll(right.getParameters());
        return params;
    }
}

package com.example.audiobook.specification;

import java.util.List;

/**
 * Логічне NOT: інверсія умови.
 * <p>
 * SQL-генерація: {@code NOT (spec)}.
 */
public class NotSpecification<T> implements Specification<T> {

    private final Specification<T> spec;

    public NotSpecification(Specification<T> spec) {
        this.spec = spec;
    }

    @Override
    public boolean isSatisfiedBy(T candidate) {
        // Інверсія результату
        return !spec.isSatisfiedBy(candidate);
    }

    @Override
    public String toSql() {
        return "NOT (" + spec.toSql() + ")";
    }

    @Override
    public List<Object> getParameters() {
        // Параметри залишаються незмінними
        return spec.getParameters();
    }
}

-- Без дужок (НЕПРАВИЛЬНО):
SELECT * FROM audiobooks WHERE price <= 500 AND language = 'uk' OR year > 2020

-- SQL інтерпретує як:
(price <= 500 AND language = 'uk') OR (year > 2020)

-- Але ми хотіли:
price <= 500 AND (language = 'uk' OR year > 2020)

package com.example.audiobook.repository;

import com.example.audiobook.specification.Specification;

import java.util.List;
import java.util.Optional;

/**
 * Базовий контракт репозиторію з підтримкою Specification Pattern.
 */
public interface Repository<T, ID> {

    Optional<T> findById(ID id);
    List<T> findAll();
    void save(T entity);
    void update(T entity);
    boolean deleteById(ID id);
    long count();
    boolean existsById(ID id);

    /**
     * Знаходить всі сутності, що задовольняють заданій специфікації.
     * <p>
     * Специфікація перетворюється на SQL WHERE-умову, що виконується на рівні БД.
     * Це забезпечує ефективність для великих таблиць (використання індексів).
     *
     * @param spec специфікація для фільтрації
     * @return список сутностей, що задовольняють умовам (може бути порожнім)
     */
    List<T> findAll(Specification<T> spec);
}

package com.example.audiobook.repository.jdbc;

import com.example.audiobook.db.ConnectionManager;
import com.example.audiobook.db.DatabaseException;
import com.example.audiobook.repository.Repository;
import com.example.audiobook.specification.Specification;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * Абстрактний JDBC-репозиторій з підтримкою Specification Pattern.
 */
public abstract class AbstractJdbcRepository<T, ID> implements Repository<T, ID> {

    protected final ConnectionManager connectionManager;

    protected AbstractJdbcRepository(ConnectionManager connectionManager) {
        this.connectionManager = connectionManager;
    }

    // ... існуючі методи findById, findAll, save, update, deleteById ...

    /**
     * Знаходить сутності за специфікацією.
     * <p>
     * Алгоритм:
     * <ol>
     *   <li>Отримати базовий SELECT-запит від підкласу ({@link #getSelectAllSql()});</li>
     *   <li>Додати WHERE-умову зі специфікації ({@code spec.toSql()});</li>
     *   <li>Встановити параметри ({@code spec.getParameters()});</li>
     *   <li>Виконати запит і змаппити результати.</li>
     * </ol>
     */
    @Override
    public List<T> findAll(Specification<T> spec) {
        // Базовий SELECT без WHERE (наприклад, "SELECT ... FROM audiobooks ab JOIN ...")
        String baseSql = getSelectAllSql();
        
        // Додаємо WHERE-умову зі специфікації
        String sql = baseSql + " WHERE " + spec.toSql();

        List<T> results = new ArrayList<>();

        try (Connection conn = connectionManager.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            // Встановлюємо параметри зі специфікації
            List<Object> params = spec.getParameters();
            for (int i = 0; i < params.size(); i++) {
                stmt.setObject(i + 1, params.get(i));
            }

            try (ResultSet rs = stmt.executeQuery()) {
                while (rs.next()) {
                    results.add(mapRow(rs));
                }
            }

        } catch (SQLException e) {
            throw new DatabaseException(
                "Помилка findAll(Specification) для таблиці " + getTableName(), e);
        }

        return results;
    }

    // Абстрактні методи, що підкласи зобов'язані реалізувати
    protected abstract T mapRow(ResultSet rs) throws SQLException;
    protected abstract String getTableName();
    protected abstract String getSelectAllSql();
    // ... інші абстрактні методи
}

CREATE TABLE audiobooks (
    id               UUID PRIMARY KEY,
    author_id        UUID NOT NULL REFERENCES authors(id),
    genre_id         UUID NOT NULL REFERENCES genres(id),
    title            VARCHAR(255) NOT NULL,
    duration         INTEGER NOT NULL CHECK (duration > 0),
    release_year     INTEGER NOT NULL CHECK (release_year >= 1900),
    description      TEXT,
    cover_image_path VARCHAR(2048)
);

package com.example.audiobook.specification.audiobook;

import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.specification.Specification;

import java.util.ArrayList;
import java.util.List;

/**
 * Специфікація: аудіокнига з тривалістю у заданому діапазоні (у секундах).
 * <p>
 * SQL: {@code duration BETWEEN ? AND ?} або {@code duration >= ?} / {@code duration <= ?}.
 */
public class DurationRangeSpecification implements Specification<Audiobook> {

    private final Integer minDuration; // у секундах
    private final Integer maxDuration; // у секундах

    /**
     * @param minDuration мінімальна тривалість (включно), може бути {@code null} — без нижньої межі
     * @param maxDuration максимальна тривалість (включно), може бути {@code null} — без верхньої межі
     */
    public DurationRangeSpecification(Integer minDuration, Integer maxDuration) {
        this.minDuration = minDuration;
        this.maxDuration = maxDuration;
    }

    @Override
    public boolean isSatisfiedBy(Audiobook candidate) {
        Integer duration = candidate.getDuration();
        if (duration == null) return false;

        boolean satisfiesMin = (minDuration == null) || duration >= minDuration;
        boolean satisfiesMax = (maxDuration == null) || duration <= maxDuration;

        return satisfiesMin && satisfiesMax;
    }

    @Override
    public String toSql() {
        if (minDuration != null && maxDuration != null) {
            return "ab.duration BETWEEN ? AND ?";
        } else if (minDuration != null) {
            return "ab.duration >= ?";
        } else if (maxDuration != null) {
            return "ab.duration <= ?";
        } else {
            return "1=1"; // завжди true — немає обмежень
        }
    }

    @Override
    public List<Object> getParameters() {
        List<Object> params = new ArrayList<>();
        if (minDuration != null) params.add(minDuration);
        if (maxDuration != null) params.add(maxDuration);
        return params;
    }
}

package com.example.audiobook.specification.audiobook;

import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.specification.Specification;

import java.util.ArrayList;
import java.util.List;

/**
 * Специфікація: аудіокнига опублікована у заданому діапазоні років.
 * <p>
 * SQL: {@code release_year BETWEEN ? AND ?}.
 */
public class YearRangeSpecification implements Specification<Audiobook> {

    private final Integer minYear;
    private final Integer maxYear;

    /**
     * @param minYear мінімальний рік (включно), може бути {@code null}
     * @param maxYear максимальний рік (включно), може бути {@code null}
     */
    public YearRangeSpecification(Integer minYear, Integer maxYear) {
        this.minYear = minYear;
        this.maxYear = maxYear;
    }

    @Override
    public boolean isSatisfiedBy(Audiobook candidate) {
        Integer year = candidate.getReleaseYear();
        if (year == null) return false;

        boolean satisfiesMin = (minYear == null) || year >= minYear;
        boolean satisfiesMax = (maxYear == null) || year <= maxYear;

        return satisfiesMin && satisfiesMax;
    }

    @Override
    public String toSql() {
        if (minYear != null && maxYear != null) {
            return "ab.release_year BETWEEN ? AND ?";
        } else if (minYear != null) {
            return "ab.release_year >= ?";
        } else if (maxYear != null) {
            return "ab.release_year <= ?";
        } else {
            return "1=1";
        }
    }

    @Override
    public List<Object> getParameters() {
        List<Object> params = new ArrayList<>();
        if (minYear != null) params.add(minYear);
        if (maxYear != null) params.add(maxYear);
        return params;
    }
}

package com.example.audiobook.specification.audiobook;

import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.specification.Specification;

import java.util.List;

/**
 * Специфікація: аудіокнига належить до заданого жанру.
 * <p>
 * SQL: {@code g.name = ?} (припускаємо, що у SELECT є JOIN до genres).
 */
public class GenreSpecification implements Specification<Audiobook> {

    private final String genreName;

    public GenreSpecification(String genreName) {
        this.genreName = genreName;
    }

    @Override
    public boolean isSatisfiedBy(Audiobook candidate) {
        return candidate.getGenre() != null 
            && genreName.equals(candidate.getGenre().getName());
    }

    @Override
    public String toSql() {
        // Припускаємо, що у SELECT є JOIN genres g
        return "g.name = ?";
    }

    @Override
    public List<Object> getParameters() {
        return List.of(genreName);
    }
}

package com.example.audiobook.specification.audiobook;

import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.specification.Specification;

import java.util.List;

/**
 * Специфікація: назва аудіокниги містить заданий підрядок (регістр-незалежний пошук).
 * <p>
 * SQL: {@code LOWER(ab.title) LIKE LOWER(?)}.
 */
public class TitleContainsSpecification implements Specification<Audiobook> {

    private final String titlePart;

    public TitleContainsSpecification(String titlePart) {
        this.titlePart = titlePart;
    }

    @Override
    public boolean isSatisfiedBy(Audiobook candidate) {
        String title = candidate.getTitle();
        return title != null && title.toLowerCase().contains(titlePart.toLowerCase());
    }

    @Override
    public String toSql() {
        return "LOWER(ab.title) LIKE LOWER(?)";
    }

    @Override
    public List<Object> getParameters() {
        return List.of("%" + titlePart + "%");
    }
}

package com.example.audiobook.repository.jdbc;

import com.example.audiobook.db.ConnectionManager;
import com.example.audiobook.db.DatabaseException;
import com.example.audiobook.domain.Author;
import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.domain.Genre;
import com.example.audiobook.repository.AudiobookRepository;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * JDBC-реалізація {@link AudiobookRepository} з підтримкою Specification Pattern.
 * <p>
 * Клас зберігає всі специфічні методи пошуку (findByAuthorId, findByGenreName)
 * і додає універсальний метод findAll(Specification) для складних запитів.
 */
public class JdbcAudiobookRepository 
    extends AbstractJdbcRepository<Audiobook, UUID>
    implements AudiobookRepository {

    /**
     * Базовий SELECT з усіма JOIN для специфікацій.
     * <p>
     * Важливо: псевдоніми таблиць (ab, a, g) мають відповідати тим,
     * що використовуються у специфікаціях (ab.duration, g.name тощо).
     */
    private static final String SQL_SELECT_BASE = """
        SELECT ab.id,
               ab.title, ab.duration, ab.release_year,
               ab.description, ab.cover_image_path,
               a.id         AS author_id,
               a.first_name, a.last_name, a.bio, a.image_path,
               g.id         AS genre_id,
               g.name       AS genre_name,
               g.description AS genre_description
        FROM audiobooks ab
        JOIN authors a ON ab.author_id = a.id
        JOIN genres  g ON ab.genre_id  = g.id
        """;

    private static final String SQL_SELECT_BY_ID =
        SQL_SELECT_BASE + "WHERE ab.id = ?";

    private static final String SQL_INSERT = """
        INSERT INTO audiobooks
          (id, title, author_id, genre_id, duration, release_year, description, cover_image_path)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        """;

    private static final String SQL_UPDATE = """
        UPDATE audiobooks
        SET title            = ?,
            author_id        = ?,
            genre_id         = ?,
            duration         = ?,
            release_year     = ?,
            description      = ?,
            cover_image_path = ?
        WHERE id = ?
        """;

    // Специфічні SQL для методів AudiobookRepository
    private static final String SQL_FIND_BY_AUTHOR_ID =
        SQL_SELECT_BASE + "WHERE ab.author_id = ? ORDER BY ab.release_year DESC";

    private static final String SQL_FIND_BY_GENRE_NAME =
        SQL_SELECT_BASE + "WHERE g.name = ? ORDER BY ab.release_year DESC";

    public JdbcAudiobookRepository(ConnectionManager connectionManager) {
        super(connectionManager);
    }

    // === Реалізація абстрактних методів AbstractJdbcRepository ===

    @Override
    protected String getTableName() {
        return "audiobooks";
    }

    @Override
    protected String getSelectByIdSql() {
        return SQL_SELECT_BY_ID;
    }

    @Override
    protected String getSelectAllSql() {
        // Повертаємо базовий SELECT без WHERE — WHERE додається у findAll(Specification)
        return SQL_SELECT_BASE;
    }

    @Override
    protected String getInsertSql() {
        return SQL_INSERT;
    }

    @Override
    protected String getUpdateSql() {
        return SQL_UPDATE;
    }

    /**
     * Data Mapper: ResultSet → Audiobook з вкладеними Author та Genre.
     */
    @Override
    protected Audiobook mapRow(ResultSet rs) throws SQLException {
        // Відновлюємо вкладені об'єкти з JOIN-рядка
        Author author = new Author(
            rs.getObject("author_id", UUID.class),
            rs.getString("first_name"),
            rs.getString("last_name"),
            rs.getString("bio"),
            rs.getString("image_path")
        );

        Genre genre = new Genre(
            rs.getObject("genre_id", UUID.class),
            rs.getString("genre_name"),
            rs.getString("genre_description")
        );

        return new Audiobook(
            rs.getObject("id", UUID.class),
            rs.getString("title"),
            author,
            genre,
            rs.getInt("duration"),
            rs.getInt("release_year"),
            rs.getString("description"),
            rs.getString("cover_image_path")
        );
    }

    @Override
    protected void setInsertParams(PreparedStatement stmt, Audiobook audiobook) throws SQLException {
        stmt.setObject(1, audiobook.getId());
        stmt.setString(2, audiobook.getTitle());
        stmt.setObject(3, audiobook.getAuthor().getId());
        stmt.setObject(4, audiobook.getGenre().getId());
        stmt.setInt(5, audiobook.getDuration());
        stmt.setInt(6, audiobook.getReleaseYear());
        stmt.setString(7, audiobook.getDescription());
        stmt.setString(8, audiobook.getCoverImagePath());
    }

    @Override
    protected void setUpdateParams(PreparedStatement stmt, Audiobook audiobook) throws SQLException {
        stmt.setString(1, audiobook.getTitle());
        stmt.setObject(2, audiobook.getAuthor().getId());
        stmt.setObject(3, audiobook.getGenre().getId());
        stmt.setInt(4, audiobook.getDuration());
        stmt.setInt(5, audiobook.getReleaseYear());
        stmt.setString(6, audiobook.getDescription());
        stmt.setString(7, audiobook.getCoverImagePath());
        stmt.setObject(8, audiobook.getId()); // WHERE id = ?
    }

    @Override
    protected UUID getId(Audiobook audiobook) {
        return audiobook.getId();
    }

    // === Специфічні методи AudiobookRepository — ЗБЕРІГАЄМО ЇХ ===

    /**
     * Знаходить всі аудіокниги заданого автора.
     * Цей метод залишається у репозиторії — Specification не замінює його.
     */
    @Override
    public List<Audiobook> findByAuthorId(UUID authorId) {
        List<Audiobook> books = new ArrayList<>();

        try (Connection conn = connectionManager.getConnection();
             PreparedStatement stmt = conn.prepareStatement(SQL_FIND_BY_AUTHOR_ID)) {

            stmt.setObject(1, authorId);
            try (ResultSet rs = stmt.executeQuery()) {
                while (rs.next()) {
                    books.add(mapRow(rs));
                }
            }

        } catch (SQLException e) {
            throw new DatabaseException("Помилка findByAuthorId для: " + authorId, e);
        }
        return books;
    }

    /**
     * Знаходить всі аудіокниги заданого жанру за назвою.
     * Цей метод також залишається — він є зручним для простих запитів.
     */
    @Override
    public List<Audiobook> findByGenreName(String genreName) {
        List<Audiobook> books = new ArrayList<>();

        try (Connection conn = connectionManager.getConnection();
             PreparedStatement stmt = conn.prepareStatement(SQL_FIND_BY_GENRE_NAME)) {

            stmt.setString(1, genreName);
            try (ResultSet rs = stmt.executeQuery()) {
                while (rs.next()) {
                    books.add(mapRow(rs));
                }
            }

        } catch (SQLException e) {
            throw new DatabaseException("Помилка findByGenreName для: " + genreName, e);
        }
        return books;
    }

    // Метод findAll(Specification) успадкований від AbstractJdbcRepository
    // і використовує getSelectAllSql() + spec.toSql()
}

package com.example.audiobook;

import com.example.audiobook.db.ConnectionManager;
import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.repository.AudiobookRepository;
import com.example.audiobook.repository.jdbc.JdbcAudiobookRepository;
import com.example.audiobook.specification.Specification;
import com.example.audiobook.specification.audiobook.*;

import java.util.List;

public class Main {

    public static void main(String[] args) {

        ConnectionManager cm = ConnectionManager.forH2("./data/audiobook_db");
        AudiobookRepository repo = new JdbcAudiobookRepository(cm);

        // === Сценарій 1: Простий запит ===
        System.out.println("=== Аудіокниги жанру 'Поезія' ===");
        Specification<Audiobook> poetry = new GenreSpecification("Поезія");
        List<Audiobook> result1 = repo.findAll(poetry);
        System.out.println("Знайдено: " + result1.size());

        // === Сценарій 2: Композиція через AND ===
        System.out.println("\n=== Поезія, опублікована після 2020 року ===");
        Specification<Audiobook> after2020 = new YearRangeSpecification(2020, null);
        
        Specification<Audiobook> query2 = poetry.and(after2020);
        List<Audiobook> result2 = repo.findAll(query2);
        System.out.println("Знайдено: " + result2.size());

        // === Сценарій 3: Композиція через OR ===
        System.out.println("\n=== Поезія АБО проза ===");
        Specification<Audiobook> prose = new GenreSpecification("Проза");
        Specification<Audiobook> poetryOrProse = poetry.or(prose);
        List<Audiobook> result3 = repo.findAll(poetryOrProse);
        System.out.println("Знайдено: " + result3.size());

        // === Сценарій 4: Складна композиція ===
        System.out.println("\n=== (Поезія АБО проза) І (2020-2023) І (тривалість 3600-7200 сек) ===");
        Specification<Audiobook> yearRange = new YearRangeSpecification(2020, 2023);
        Specification<Audiobook> durationRange = new DurationRangeSpecification(3600, 7200); // 1-2 години

        Specification<Audiobook> complexQuery = poetryOrProse
            .and(yearRange)
            .and(durationRange);

        List<Audiobook> result4 = repo.findAll(complexQuery);
        System.out.println("Знайдено: " + result4.size());

        // Виведемо згенерований SQL для діагностики
        System.out.println("\nЗгенерований SQL WHERE:");
        System.out.println(complexQuery.toSql());
        System.out.println("\nПараметри:");
        System.out.println(complexQuery.getParameters());

        // === Сценарій 5: Динамічна побудова запиту ===
        System.out.println("\n=== Динамічний фільтр (користувацький ввід) ===");
        
        // Імітація користувацького вводу
        String userGenre = "Фантастика";  // може бути null
        Integer userMinYear = 2015;       // може бути null
        Integer userMaxDuration = 10800;  // може бути null (3 години у секундах)

        Specification<Audiobook> dynamicQuery = buildDynamicQuery(
            userGenre, userMinYear, userMaxDuration
        );

        List<Audiobook> result5 = repo.findAll(dynamicQuery);
        System.out.println("Знайдено: " + result5.size());

        // === Сценарій 6: Пошук за назвою + жанр ===
        System.out.println("\n=== Назва містить 'Кобзар' І жанр 'Поезія' ===");
        Specification<Audiobook> titleContains = new TitleContainsSpecification("Кобзар");
        Specification<Audiobook> query6 = titleContains.and(poetry);
        List<Audiobook> result6 = repo.findAll(query6);
        System.out.println("Знайдено: " + result6.size());

        cm.close();
    }

    /**
     * Будує специфікацію динамічно на основі користувацького вводу.
     * Якщо параметр null — він не включається у запит.
     */
    private static Specification<Audiobook> buildDynamicQuery(
            String genre, Integer minYear, Integer maxDuration) {

        // Початкова специфікація — завжди true (1=1)
        Specification<Audiobook> spec = new AlwaysTrueSpecification<>();

        if (genre != null) {
            spec = spec.and(new GenreSpecification(genre));
        }
        if (minYear != null) {
            spec = spec.and(new YearRangeSpecification(minYear, null));
        }
        if (maxDuration != null) {
            spec = spec.and(new DurationRangeSpecification(null, maxDuration));
        }

        return spec;
    }
}

package com.example.audiobook.specification;

import java.util.Collections;
import java.util.List;

/**
 * Специфікація, що завжди задоволена (нейтральний елемент для AND).
 * <p>
 * SQL: {@code 1=1} (завжди true).
 * <p>
 * Використовується як початкова точка для динамічної побудови запитів:
 * <pre>{@code
 * Specification<T> spec = new AlwaysTrueSpecification<>();
 * if (condition1) spec = spec.and(new SomeSpec());
 * if (condition2) spec = spec.and(new OtherSpec());
 * }</pre>
 */
public class AlwaysTrueSpecification<T> implements Specification<T> {

    @Override
    public boolean isSatisfiedBy(T candidate) {
        return true; // завжди задоволена
    }

    @Override
    public String toSql() {
        return "1=1"; // SQL-константа, що завжди true
    }

    @Override
    public List<Object> getParameters() {
        return Collections.emptyList(); // немає параметрів
    }
}

@Override
public String toSql() {
    return "genre_name = ?";  // Припускає, що є псевдонім genre_name
}

SELECT ... FROM audiobooks ab
JOIN authors a ON ab.author_id = a.id
WHERE a.id IN (
    SELECT author_id FROM audiobooks GROUP BY author_id HAVING COUNT(*) > 10
)

@Override
public String toSql() {
    return "genreName = ?";  // Помилка: має бути genre_name
}
// Компілятор не виявить помилку — SQLException під час виконання

// Java-версія
@Override
public boolean isSatisfiedBy(Audiobook candidate) {
    return candidate.getPrice().compareTo(maxPrice) <= 0;
}

// SQL-версія
@Override
public String toSql() {
    return "price <= ?";
}