public final class HibernateUtil {

    private final Properties properties;

    private SessionFactory sessionFactory;
    private StandardServiceRegistry standardServiceRegistry;

    private static final Logger LOGGER = LoggerFactory.getLogger(HibernateUtil.class);

    private static HibernateUtil instance;

    private HibernateUtil() {

        this.properties = ApplicationManager.getPropertiesManager().getProperties();

        try {

            //Persistence.createEntityManagerFactory("info.tsyklop.betsautoplacerbot.persistence.entity");

            StandardServiceRegistryBuilder registryBuilder = new StandardServiceRegistryBuilder();

            Map<String, Object> settings = new HashMap<>();

            settings.put(Environment.DRIVER, properties.getDatasourceH2DriverClassName());
            settings.put(Environment.URL, properties.getDatasourceH2Url());
            settings.put(Environment.USER, properties.getDatasourceH2User());
            settings.put(Environment.PASS, properties.getDatasourceH2Password());
            settings.put(Environment.DIALECT, "org.hibernate.dialect.H2Dialect");

            settings.put(Environment.DATASOURCE, "com.zaxxer.hikari.HikariDataSource");

            settings.put(Environment.SHOW_SQL, properties.getProperty("hibernate.show_sql"));
            settings.put(Environment.FORMAT_SQL, properties.getProperty("hibernate.format_sql"));
            settings.put(Environment.HBM2DDL_AUTO, properties.getProperty("hibernate.hbm2ddl.auto"));
            settings.put(Environment.HBM2DDL_CHARSET_NAME, "utf-8");

            settings.put(Environment.CONNECTION_PROVIDER, properties.getProperty("hibernate.connection.provider_class"));

            settings.putAll(properties.getSubset("hibernate.hikari"));

            this.standardServiceRegistry = registryBuilder.applySettings(settings).build();

            MetadataSources metadataSources = new MetadataSources(this.standardServiceRegistry);

            Reflections reflections = new Reflections("info.tsyklop.desktop.persistence.entity");
            Set<Class<? extends AbstractEntity>> entitiesClasses = reflections.getSubTypesOf(AbstractEntity.class);

            for (Class<? extends AbstractEntity> abstractEntity : entitiesClasses) {
                metadataSources.addAnnotatedClass(abstractEntity);
            }

            this.sessionFactory = metadataSources.getMetadataBuilder().build().getSessionFactoryBuilder().build();

        } catch (Exception e) {
            if (this.standardServiceRegistry != null) {
                StandardServiceRegistryBuilder.destroy(this.standardServiceRegistry);
            }
            throw new HibernateException(e);
        }

    }

    public static HibernateUtil getInstance() {
        HibernateUtil localInstance = instance;
        if (localInstance == null) {
            synchronized (HibernateUtil.class) {
                localInstance = instance;
                if (localInstance == null) {
                    instance = localInstance = new HibernateUtil();
                }
            }
        }
        return localInstance;
    }

    public Session getSession() {
        return sessionFactory.openSession();
    }

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public void shutdown() {
        if (this.standardServiceRegistry != null) {
            StandardServiceRegistryBuilder.destroy(this.standardServiceRegistry);
        }
    }

}

public abstract class BaseRepository<E extends AbstractEntity> implements Repository<E> {

    protected final Class<E> entityClass;

    protected final HibernateUtil hibernateUtil = HibernateUtil.getInstance();

    private static final Logger LOGGER = LoggerFactory.getLogger(BaseRepository.class);

    protected BaseRepository() {
        this.entityClass = (Class<E>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public E save(E entity) throws DataSourceException {
        Session session = null;
        try {

            session = openSession();
            session.beginTransaction();

            session.save(entity);

            commit(session);

        } catch (Exception e) {
            showException(e);
            rollback(session);
            rethrow(e);
        } finally {
            closeSession(session);
        }
        return entity;
    }

    public List<E> findAll() throws DataSourceException {

        Session session = null;

        List<E> list = new ArrayList<>();

        try {

            session = openSession();
            session.beginTransaction();

            list.addAll(session.createQuery("SELECT e FROM " + this.entityClass.getName() + " e", this.entityClass).getResultList());

            commit(session);

        } catch (Exception e) {
            showException(e);
            rollback(session);
            rethrow(e);
        } finally {
            closeSession(session);
        }

        return list;
    }

    //public abstract Optional<E> findById(Long id) throws HibernateException;

    public Optional<E> findById(Long id) throws DataSourceException {

        Session session = null;

        Optional<E> entityOptional = Optional.empty();

        try {

            session = openSession();
            session.beginTransaction();

            entityOptional = Optional.of(session.get(entityClass, id));

            commit(session);

        } catch (Exception e) {
            showException(e);
            rollback(session);
            rethrow(e);
        } finally {
            closeSession(session);
        }
        return entityOptional;
    }

    //public abstract boolean update(E entity) throws HibernateException;

    public boolean update(E entity) throws DataSourceException {
        Session session = null;
        try {

            session = openSession();
            session.beginTransaction();

            session.update(entity);

            commit(session);

            return true;

        } catch (Exception e) {
            showException(e);
            rollback(session);
            rethrow(e);
        } finally {
            closeSession(session);
        }
        return false;
    }

    public boolean delete(E entity) throws DataSourceException {
        Session session = null;
        try {

            session = openSession();
            session.beginTransaction();

            session.delete(entity);

            commit(session);

            return true;

        } catch (Exception e) {
            showException(e);
            rollback(session);
            rethrow(e);
        } finally {
            closeSession(session);
        }
        return false;
    }

    public void clear() throws DataSourceException {

        Session session = null;

        try {

            session = openSession();
            session.beginTransaction();

            session.createQuery("DELETE FROM " + entityClass.getName()).executeUpdate();

            commit(session);

        } catch (Exception e) {
            showException(e);
            rollback(session);
            rethrow(e);
        } finally {
            closeSession(session);
        }

    }

    protected Session openSession() {
        return hibernateUtil.getSession();
    }

    protected void commit(Session session) {
        if (session != null) {
            session.getTransaction().commit();
        }
    }

    protected void rollback(Session session) {
        if (session != null) {
            session.getTransaction().rollback();
        }
    }

    protected void closeSession(Session session) {
        if (session != null) {
            try {
                session.close();
            } catch (Exception ignored) {
            }
        }
    }

    protected void showException(Exception e) {
        LOGGER.error(this.entityClass.getName() + " REPOSITORY ERROR", e);
    }

    protected void rethrow(Exception e) {
        throw new DataSourceException(e);
    }

}