ConfigService.java

package ui.entities.config.service;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.persistence.EntityManager;
import jakarta.persistence.Persistence;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Root;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import jakarta.xml.bind.Marshaller;
import jakarta.xml.bind.Unmarshaller;
import libsidutils.IOUtils;
import ui.entities.DatabaseType;
import ui.entities.PersistenceProperties;
import ui.entities.config.Configuration;

import java.io.File;
import java.io.IOException;
import java.util.Optional;

import static libsidplay.config.IConfig.REQUIRED_CONFIG_VERSION;

/**
 * Service of the configuration database.
 *
 * @author ken
 *
 */
public class ConfigService {
    /**
     * Configuration types offered by JSIDPlay2
     *
     * @author ken
     *
     */
    public enum ConfigurationType {
        /**
         * Use JSON configuration files
         */
        JSON(".json"),
        /**
         * Use XML configuration files
         */
        XML(".xml"),
        /**
         * Use binary database files
         */
        DATABASE("");

        private final String fileExt;

        ConfigurationType(String fileExt) {
            this.fileExt = fileExt;
        }
    }

    /**
     * Filename of the jsidplay2 configuration file.
     */
    public static final String CONFIG_FILE = "jsidplay2";

    private EntityManager em;

    private final ConfigurationType configurationType;

    public ConfigService(ConfigurationType configurationType) {
        this.configurationType = configurationType;
    }

    public Configuration load() {
        final File configPath = getConfigPath();

        switch (configurationType) {
            case DATABASE:
                em = Persistence
                        .createEntityManagerFactory(PersistenceProperties.CONFIG_DS,
                                new PersistenceProperties(DatabaseType.HSQL_FILE, "", "", configPath.getAbsolutePath()))
                        .createEntityManager();
                return get(configPath);

            case JSON:
                em = Persistence
                        .createEntityManagerFactory(PersistenceProperties.CONFIG_DS,
                                new PersistenceProperties(DatabaseType.HSQL_MEM, "", "", CONFIG_FILE))
                        .createEntityManager();
                return importJson(configPath);

            case XML:
            default:
                em = Persistence
                        .createEntityManagerFactory(PersistenceProperties.CONFIG_DS,
                                new PersistenceProperties(DatabaseType.HSQL_MEM, "", "", CONFIG_FILE))
                        .createEntityManager();
                return importXml(configPath);
        }
    }

    public void save(Configuration configuration) {
        save(configuration, getConfigPath());
    }

    private void save(Configuration configuration, final File configPath) {
        switch (configurationType) {
            case DATABASE:
                persist(configuration);
                break;

            case JSON:
                exportJson(configuration, configPath);
                break;

            case XML:
            default:
                exportXml(configuration, configPath);
                break;
        }
    }

    /**
     * Get configuration database.
     * <p>
     * If absent or invalid, create a new one.
     *
     * @return configuration
     */
    private Configuration get(File configPath) {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Integer> q = cb.createQuery(Integer.class);
        Root<Configuration> h = q.from(Configuration.class);
        // Read only the version: old entities may have an incompatible schema.
        q.select(h.get("sidplay2Section").get("version"));
        Optional<Integer> version = em.createQuery(q).getResultList().stream().findFirst();

        if (version.isPresent() && version.get() == REQUIRED_CONFIG_VERSION) {
            return em.createQuery("from Configuration", Configuration.class).setMaxResults(1).getSingleResult();
        }
        em.clear();
        var schema = em.getEntityManagerFactory().getSchemaManager();
        schema.drop(false);
        schema.create(false);
        return create();
    }

    /**
     * Create a new configuration and persist into the database.
     *
     * @return newly created configuration
     */
    private Configuration create() {
        Configuration configuration = new Configuration();
        configuration.getSidplay2Section().setVersion(REQUIRED_CONFIG_VERSION);
        persist(configuration);
        return configuration;
    }

    /**
     * Persist configuration database.
     *
     * @param config configuration to persist
     */
    private void persist(Configuration config) {
        try {
            em.getTransaction().begin();
            em.persist(config);
            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            if (em.getTransaction().isActive()) {
                em.getTransaction().rollback();
            }
        }
    }

    /**
     * Close configuration database.
     */
    public void close() {
        em.close();
    }

    /**
     * Import configuration database from an XML file.
     * <p>
     * If absent or invalid, create a new one.
     *
     * @param file XML file to import
     * @return imported configuration
     */
    private Configuration importXml(File file) {
        if (file.exists()) {
            try {
                JAXBContext jaxbContext = JAXBContext.newInstance(Configuration.class);
                Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
                Object obj = unmarshaller.unmarshal(file);
                if (obj instanceof Configuration) {
                    Configuration detachedConfig = (Configuration) obj;

                    // configuration version check
                    if (detachedConfig.getSidplay2Section().getVersion() == REQUIRED_CONFIG_VERSION) {
                        Configuration mergedConfig = em.merge(detachedConfig);
                        persist(mergedConfig);
                        return mergedConfig;
                    }
                    createBackup(detachedConfig, file);
                }
            } catch (JAXBException e) {
                System.err.println(e.getMessage());
            }
        }
        return create();
    }

    /**
     * Import configuration database from an JSON file.
     * <p>
     * If absent or invalid, create a new one.
     *
     * @param file JSON file to import
     * @return imported configuration
     */
    private Configuration importJson(final File file) {
        if (file.exists()) {
            try {
                final ObjectMapper objectMapper = new ObjectMapper();
                objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
                Configuration detachedConfig = objectMapper.readValue(file, Configuration.class);

                // configuration version check
                if (detachedConfig.getSidplay2Section().getVersion() == REQUIRED_CONFIG_VERSION) {
                    Configuration mergedConfig = em.merge(detachedConfig);
                    persist(mergedConfig);
                    return mergedConfig;
                }
                createBackup(detachedConfig, file);
            } catch (IOException e) {
                System.err.println(e.getMessage());
            }
        } else {
            // migration XML to JSON
            File fileAsXml = new File(IOUtils.getFilenameWithoutSuffix(file.getAbsolutePath()) + ".xml");
            if (fileAsXml.exists()) {
                return importXml(fileAsXml);
            }
        }
        return create();
    }

    /**
     * Export configuration database into an XML file.
     *
     * @param configuration configuration to export
     * @param file          target file of the export
     */
    private void exportXml(Configuration configuration, File file) {
        try {
            JAXBContext jaxbContext = JAXBContext.newInstance(Configuration.class);
            Marshaller marshaller = jaxbContext.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
            marshaller.marshal(configuration, file);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
    }

    /**
     * Export configuration database into an JSON file.
     *
     * @param configuration configuration to export
     * @param file          target file of the export
     */
    private void exportJson(Configuration configuration, File file) {
        try {
            new ObjectMapper().writerWithDefaultPrettyPrinter().writeValue(file, configuration);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Search for the configuration. Search in CWD and in the HOME folder.
     *
     * @return XML configuration file
     */
    private File getConfigPath() {
        for (final String s : new String[]{System.getProperty("user.dir"), System.getProperty("user.home"),}) {
            File configPlace = new File(s, CONFIG_FILE + configurationType.fileExt);
            if (configPlace.exists()) {
                return configPlace;
            }
        }
        // default directory
        return new File(System.getProperty("user.home"), CONFIG_FILE + configurationType.fileExt);
    }

    /**
     * Create a backup of the current configuration.
     *
     * @param configuration configuration to backup
     * @param configPath    backup filename without .bak
     */
    private void createBackup(Configuration configuration, File configPath) {
        File bakFile = new File(configPath.getParentFile(), configPath.getName() + ".bak");
        save(configuration, bakFile);

        int currentVersion = configuration.getSidplay2Section().getVersion();
        System.out.println("Configuration file version=" + currentVersion + " is older than expected version="
                + REQUIRED_CONFIG_VERSION + ", a backup has been created: " + bakFile);
    }

}