package io.trygvis.spring;

import com.jolbox.bonecp.*;
import io.trygvis.model.*;
import org.hibernate.*;
import org.hibernate.annotations.*;
import org.hibernate.cfg.*;
import org.hibernate.ejb.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.context.annotation.*;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.*;
import org.springframework.data.jpa.repository.config.*;
import org.springframework.jdbc.core.*;
import org.springframework.jdbc.datasource.*;
import org.springframework.orm.hibernate4.*;
import org.springframework.orm.jpa.*;
import org.springframework.transaction.*;
import org.springframework.transaction.annotation.*;
import org.springframework.transaction.support.*;

import javax.persistence.*;
import javax.sql.*;
import java.util.*;

import static org.hibernate.cfg.AvailableSettings.*;
import static org.hibernate.ejb.AvailableSettings.*;
import static org.springframework.transaction.TransactionDefinition.*;

@Configuration
@ComponentScan(basePackages = "io.trygvis")
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "io.trygvis.data")
public class Config {

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() throws Exception {
        return new PropertySourcesPlaceholderConfigurer() {{
//            setLocation(new UrlResource("file:environment.properties"));
            setProperties(System.getProperties());
            setLocalOverride(true);
        }};
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

//    public SpringBeanJobFactory springBeanJobFactory() {
//        SpringBeanJobFactory factory = new SpringBeanJobFactory();
//        return factory;
//    }

/*
    @Bean
    public SchedulerFactoryBean quartz(DataSource dataSource, PlatformTransactionManager transactionManager) {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        bean.setApplicationContextSchedulerContextKey("applicationContext");
        bean.setDataSource(dataSource);
        bean.setTransactionManager(transactionManager);
//        bean.setJobFactory(new JobFactory() {
//            public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler) throws SchedulerException {
//                Class<? extends Job> klass = bundle.getJobDetail().getJobClass();
//            }
//        });

        Properties quartzProperties = new Properties();
        quartzProperties.setProperty("org.quartz.scheduler.skipUpdateCheck", "true");
//        quartzProperties.setProperty("org.quartz.jobStore.selectWithLockSQL", "false");
        quartzProperties.setProperty("org.quartz.jobStore.driverDelegateClass", PostgreSQLDelegate.class.getName());
        quartzProperties.setProperty("org.quartz.scheduler.jmx.export", "true");
        bean.setQuartzProperties(quartzProperties);
        return bean;
    }
*/

    // This turns out to be fairly useless as Spring won't register them automatically.
    // It's probably better to use @Scheduled/@Async instead
    /*
    @Bean(name = "my-job")
    public JobDetailFactoryBean myJobDetailBean() {
        JobDetailFactoryBean bean = new JobDetailFactoryBean();
        bean.setJobClass(MyJob.class);
        bean.setDurability(true);

        return bean;
    }

    @Bean
    public CronTriggerFactoryBean myJobTrigger(JobDetail jobDetail) {
        CronTriggerFactoryBean bean = new CronTriggerFactoryBean();
        bean.setName("my-trigger");
        bean.setBeanName("my-job");
        bean.setJobDetail(jobDetail);
        bean.setCronExpression("0/10 * * * * ?");

        return bean;
    }
    */

    @Bean
    public DataSource dataSource(@Value("${database.url}") String jdbcUrl,
                                 @Value("${database.username}") String username,
                                 @Value("${database.password}") String password) {
        BoneCPDataSource ds = new BoneCPDataSource();

        ds.setLogStatementsEnabled(true);

        ds.setJdbcUrl(jdbcUrl);
        ds.setUsername(username);
        ds.setPassword(password);

        ds.setIdleConnectionTestPeriodInSeconds(60);
        ds.setIdleMaxAgeInSeconds(240);
        ds.setMaxConnectionsPerPartition(40);
        ds.setMinConnectionsPerPartition(0);
        ds.setPartitionCount(1);
        ds.setAcquireIncrement(1);
        ds.setStatementsCacheSize(1000);
        ds.setReleaseHelperThreads(3);
        ds.setStatisticsEnabled(true);
        return new TransactionAwareDataSourceProxy(new LazyConnectionDataSourceProxy(ds));
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource,
                                                                       @Value("${hibernate.hbm2ddl.auto}") String hbm2ddl,
                                                                       @Value("${hibernate.showSql:false}") boolean showSql,
                                                                       @Value("${hibernate.dialect}") String dialect) {
        LocalContainerEntityManagerFactoryBean x = new LocalContainerEntityManagerFactoryBean();
        x.setDataSource(dataSource);
        x.setJpaPropertyMap(createJpaMap(hbm2ddl, showSql, dialect));
        x.setPackagesToScan(Article.class.getPackage().getName());
        HibernatePersistence persistenceProvider = new HibernatePersistence();
        x.setPersistenceProvider(persistenceProvider);
        return x;
    }

    public static Map<String, Object> createJpaMap(String hbm2ddl, boolean showSql, String dialect) {
        Map<String, Object> map = new HashMap<>();
        map.put(HBM2DDL_AUTO, hbm2ddl);
        map.put(FORMAT_SQL, showSql);
        map.put(SHOW_SQL, showSql);
        map.put(USE_SQL_COMMENTS, showSql);
        map.put(GENERATE_STATISTICS, true);
        map.put(NAMING_STRATEGY, ImprovedNamingStrategy.class.getName());

        map.put(DEFAULT_CACHE_CONCURRENCY_STRATEGY, CacheConcurrencyStrategy.READ_WRITE.toString());
        map.put(CURRENT_SESSION_CONTEXT_CLASS, SpringSessionContext.class.getName());
//        map.put(CACHE_REGION_FACTORY, EhCacheRegionFactory.class.getName());
        map.put(USE_SECOND_LEVEL_CACHE, false);
        map.put(USE_QUERY_CACHE, false);
//        map.put(SHARED_CACHE_MODE, SharedCacheMode.ENABLE_SELECTIVE.toString());

        map.put(DIALECT, dialect);
        map.put("hibernate.temp.use_jdbc_metadata_defaults", "false");

        return map;
    }

    @Bean
    public SessionFactory sessionFactory(LocalContainerEntityManagerFactoryBean entityManagerFactory) {
        return ((HibernateEntityManagerFactory) entityManagerFactory.nativeEntityManagerFactory).getSessionFactory();
    }

    @Bean
    public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }

    @Bean
    public TransactionTemplate transactionTemplate(PlatformTransactionManager platformTransactionManager) {
        DefaultTransactionDefinition td = new DefaultTransactionDefinition();
        td.setPropagationBehavior(PROPAGATION_REQUIRED);
        td.setIsolationLevel(ISOLATION_READ_COMMITTED);
        return new TransactionTemplate(platformTransactionManager, td);
    }
}