SearchIndexCreator.java

/**
 *
 */
package ui.musiccollection.search;

import jakarta.persistence.EntityManager;
import libsidutils.IOUtils;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.id.OptimizableGenerator;
import sidplay.Player;
import ui.entities.collection.HVSCEntry;
import ui.entities.collection.service.HVSCEntryService;
import ui.entities.collection.service.STILService;
import ui.entities.collection.service.VersionService;

import java.io.File;
import java.util.function.Consumer;

public final class SearchIndexCreator {

    private final EntityManager em;
    private final HVSCEntryService hvscEntryService;
    private final STILService stilService;
    private final VersionService versionService;

    private final Player player;
    private final File root;

    public SearchIndexCreator(File root, final Player player, final EntityManager em) {
        this.root = root;
        this.player = player;
        this.em = em;
        this.hvscEntryService = new HVSCEntryService(em);
        this.stilService = new STILService(em);
        this.versionService = new VersionService(em);
    }

    /**
     * Recreate the index schema, including enum constraints from the current mappings.
     */
    private void clearPreviousSearchIndex() {
        em.clear();
        var factory = em.getEntityManagerFactory().unwrap(SessionFactoryImplementor.class);
        // Discard pooled identifiers before recreating the sequences on a subsequent indexing run.
        factory.getMappingMetamodel().forEachEntityDescriptor(entity -> {
            if (entity.getGenerator() instanceof OptimizableGenerator optimizable) {
                optimizable.getOptimizer().reset();
            }
        });
        var schema = factory.getSchemaManager();
        schema.drop(false);
        schema.create(false);
    }

    public Consumer<Void> getSearchStart() {
        return x -> {
            clearPreviousSearchIndex();

            em.getTransaction().begin();
        };
    }

    public Consumer<File> getSearchHit() {
        return file -> {
            if (!file.isFile()) {
                return;
            }
            try {
                String collectionRelName = IOUtils.getCollectionName(root, file);
                if (collectionRelName != null) {
                    HVSCEntry hvscEntry = hvscEntryService.add(player, collectionRelName, file);
                    stilService.add(player::getStilEntry, hvscEntry);
                }
            } catch (final Exception e) {
                System.err.println("Indexing failure on: " + file.getAbsolutePath() + ": " + e.getMessage());
            }
        };
    }

    public Consumer<Boolean> getSearchStop() {
        return cancelled -> {
            versionService.setExpectedVersion();
            em.getTransaction().commit();
        };
    }
}