/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package de.smartics.properties.impl.config.ds;
  
  import java.sql.DatabaseMetaData;
  import java.sql.SQLException;
  import java.util.List;
  
  import javax.annotation.concurrent.ThreadSafe;
  import javax.naming.NamingException;
  
  import de.smartics.properties.api.config.domain.ConfigurationException;
  import de.smartics.properties.api.config.domain.ConfigurationPropertiesManagement;
  import de.smartics.properties.api.config.domain.PropertyProvider;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.config.domain.key.ConfigurationKeyFactory;
  import de.smartics.properties.impl.config.cache.CacheConfigurationPropertiesManagement;
  import de.smartics.properties.spi.config.domain.key.ConfigurationKeyContextManager;
  import de.smartics.properties.spi.config.ds.DataSourceCode;
  import de.smartics.properties.spi.config.ds.DataSourceConfigurationMessageBean;
  import de.smartics.properties.spi.config.ds.DataSourceConfigurationPropertyProvider;
  import de.smartics.properties.spi.config.ds.DataSourceConnector;
  import de.smartics.properties.spi.config.ds.DataSourceException;
  import de.smartics.properties.spi.config.ds.DataSourceProxy;
  import de.smartics.properties.spi.config.ds.JndiDataSourceProxy;
  import de.smartics.properties.spi.config.ds.PropertiesStore;
  import de.smartics.properties.spi.config.support.AbstractConfigurationPropertiesFactory;
  import de.smartics.properties.spi.config.support.ConfigurationPropertiesManagementSpi;
  
  /**
   * Factory, configured by properties in the
   * <code>{@value de.smartics.properties.impl.config.ds.DataSourceConfigurationLoader#CLASSPATH_LOCATION}</code>
   * folder, to create instances of {@link DataSourceConfigurationProperties}.
   * <p>
   * Please refer to {@link DataSourceConfiguration} for configuration options.
   * </p>
   */
  @ThreadSafe
  public class AutodetectDataSourceConfigurationPropertiesFactory extends
      AbstractConfigurationPropertiesFactory<ConfigurationPropertiesManagement>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * The class version identifier.
     */
    private static final long serialVersionUID = 1L;
  
    // --- members --------------------------------------------------------------
  
    /**
     * The cached manager for reuse to access properties information.
     */
    private volatile PropertiesStore manager;
  
    /**
     * Optional datasource configuration. When not set via constructor it will be
     * searched for a configuration in META-INF.
     */
    private final DataSourceConfiguration configuration;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     */
    public AutodetectDataSourceConfigurationPropertiesFactory()
    {
      getFactoryConfiguration().setSkipClassPathPropertyLoading(true);
      this.configuration = new DataSourceConfigurationLoader().load();
      init();
    }
  
    /**
     * Constructor that enables the configuration to be set.
     *
     * @param configuration the configuration to use for this factory.
     */
    public AutodetectDataSourceConfigurationPropertiesFactory(
        final DataSourceConfiguration configuration)
    {
      this.configuration = configuration;
     getFactoryConfiguration().setSkipClassPathPropertyLoading(true);
     init();
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private void init()
   {
 
     final DataSourceProxy dataSourceProxy =
         createDataSourceProxy(configuration);
 
     this.manager = createManager(configuration, dataSourceProxy);
 
     if (configuration.isCreateTable())
     {
       manager.createConfigTable();
     }
 
     addProviders();
   }
 
   private DataSourceProxy createDataSourceProxy(
       final DataSourceConfiguration config)
   {
     final JndiDataSourceProxy jndiProxy = createProxy(config);
     final String databaseId = createDatabaseId(jndiProxy);
     final DataSourceConnector connector =
         DataSourceProxyManager.getConnectorFor(databaseId);
     final DataSourceProxy dataSourceProxy = connector.create(jndiProxy);
     return dataSourceProxy;
   }
 
   private PropertiesStore createManager(final DataSourceConfiguration config,
       final DataSourceProxy dataSourceProxy)
   {
     final PropertiesStore.Builder builder = new PropertiesStore.Builder();
     builder.setDataSourceProxy(dataSourceProxy);
     builder.setIgnoreTableCreationProblems(false);
     builder.setCreateTableSqlStatementTemplate(dataSourceProxy
         .getCreateTableSqlTemplate());
     builder.setInsertOrUpdateSqlStatementTemplate(dataSourceProxy
         .getInsertOrUpdateSqlTemplate());
     builder.setDropTable(config.isDropTable());
     return builder.build();
   }
 
   private void addProviders()
   {
     final List<String> keys = manager.getConfigurationKeys();
     for (final String key : keys)
     {
       final ConfigurationKey<?> configurationKey = parseKey(key);
       final PropertyProvider provider =
           new DataSourceConfigurationPropertyProvider(configurationKey, manager);
       addPropertyProviders(provider);
     }
   }
 
   private ConfigurationKey<?> parseKey(final String key)
   {
     final ConfigurationKeyFactory<?> factory =
         ConfigurationKeyContextManager.INSTANCE.context()
             .configurationKeyFactory();
     try
     {
       final ConfigurationKey<?> configurationKey =
           factory.createKeyFromString(key);
       return configurationKey;
 
     }
     catch (final IllegalArgumentException e)
     {
       final DataSourceConfigurationMessageBean message =
           new DataSourceConfigurationMessageBean(
               DataSourceCode.INVALID_CONFIGURATION_KEY, e,
               manager.getDataSourceId(), null);
       throw new DataSourceException(message); // NOPMD
     }
   }
 
   private JndiDataSourceProxy createProxy(final DataSourceConfiguration config)
   {
     try
     {
       return new JndiDataSourceProxy(config.getJndiName());
     }
     catch (final NamingException e)
     {
       throw new IllegalArgumentException("Cannot access JNDI context: "
                                          + e.getMessage(), e);
     }
   }
 
   private static String createDatabaseId(final JndiDataSourceProxy proxy)
   {
     try
     {
       final DatabaseMetaData metaData =
           proxy.getDataSource().getConnection().getMetaData();
       final String databaseId = metaData.getDatabaseProductName();
       return databaseId;
     }
     catch (final SQLException e)
     {
       throw new IllegalArgumentException("Cannot read database metadata: "
                                          + e.getMessage(), e);
     }
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   @Override
   protected ConfigurationPropertiesManagement createNewConfiguration(
       final ConfigurationKey<?> key) throws NullPointerException,
     ConfigurationException
   {
     final ConfigurationPropertiesManagement config = createCache(key);
     return config;
   }
 
   private ConfigurationPropertiesManagement createCache(
       final ConfigurationKey<?> key)
   {
     final ConfigurationPropertiesManagementSpi uncached =
         new DataSourceConfigurationProperties(key, getRegistry(), manager,
             getFactoryConfiguration().getDecrypter());
     if (getFactoryConfiguration().isUseCache())
     {
       return new CacheConfigurationPropertiesManagement(uncached);
     }
     else
     {
       return uncached;
     }
   }
 
   // --- object basics --------------------------------------------------------
 
 }