package org.apache.onami.autobind.configuration.features;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to You 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.

  */

 import static java.lang.String.format;

 import static java.util.logging.Level.INFO;

 import static java.util.logging.Level.WARNING;

 import static java.util.logging.Logger.getLogger;

 import static org.apache.onami.autobind.configuration.Configuration.Type.BOTH;

 import static org.apache.onami.autobind.configuration.Configuration.Type.CONFIGURATION;

 import static org.apache.onami.autobind.configuration.Configuration.Type.VALUES;

 import static org.apache.onami.autobind.install.BindingStage.BOOT_BEFORE;

 import static org.apache.onami.autobind.install.BindingStage.IGNORE;

 import java.io.File;

 import java.lang.annotation.Annotation;

 import java.net.MalformedURLException;

 import java.net.URL;

 import java.util.Map;

 import java.util.Properties;

 import java.util.logging.Logger;

 import javax.inject.Inject;

 import javax.inject.Named;

 import javax.inject.Provider;

 import javax.inject.Singleton;

 import org.apache.onami.autobind.configuration.Configuration;

 import org.apache.onami.autobind.configuration.ConfigurationBindingJob;

 import org.apache.onami.autobind.configuration.ConfigurationModule;

 import org.apache.onami.autobind.configuration.PathConfig;

 import org.apache.onami.autobind.configuration.PropertiesProvider;

 import org.apache.onami.autobind.install.BindingStage;

 import org.apache.onami.autobind.install.bindjob.BindingJob;

 import org.apache.onami.autobind.scanner.features.BindingScannerFeature;

 import org.apache.onami.configuration.PropertiesURLReader;

 /**

  * This class will bind a Properties-Instance or -Provider for each Class

  * annotated with {@link Configuration}.

  */

 @Singleton

 public class ConfigurationFeature

     extends BindingScannerFeature

 {

     private final Logger _logger = getLogger( getClass().getName() );

     @Inject

     private ConfigurationModule module;

     @Override

     public BindingStage accept( Class<Object> annotatedClass, Map<String, Annotation> annotations )

     {

         if ( annotations.containsKey( Configuration.class.getName() ) )

         {

             Configuration config = (Configuration) annotations.get( Configuration.class.getName() );

             if ( Properties.class.isAssignableFrom( config.to() ) )

             {

                 return BOOT_BEFORE;

             }

         }

         return IGNORE;

     }

     @Override

     public void process( Class<Object> annotatedClass, Map<String, Annotation> annotations )

     {

         Configuration config = (Configuration) annotations.get( Configuration.class.getName() );

         Named name = config.name();

         URL url = null;

         if ( config.alternative().value().length() > 0 )

         {

             url = findURL( name, config.alternative() );

             if ( url != null )

             {

                 try

                 {

                     // TODO Use an Executor to test, if the Stream can be opened?

                     // FIXME What happens if Error Page is returned?

                     /*

                      * final URL alternativeURL = url; Future<URL> submit =

                      * Executors.newSingleThreadExecutor().submit(new Callable<URL>() {

                      * @Override public URL call() throws Exception { alternativeURL.openConnection().getInputStream();

                      * return alternativeURL; } }); submit.get(5, TimeUnit.SECONDS);

                      */

                     url.openStream();

                 }

                 catch ( Exception e )

                 {

                     url = null;

                 }

             }

         }

         if ( url == null )

         {

             url = findURL( name, config.location() );

         }

         if ( url == null )

         {

             _logger.log( WARNING, format( "Ignoring Configuration %s in %s because is couldn't be found in the Classpath.",

                                           name, config.location() ) );

             // TODO Throw an exception if config doesn't exist?

             return;

         }

         if ( VALUES == config.type() || BOTH == config.type() )

         {

             BindingJob job = new ConfigurationBindingJob( config.name(), url.toString() );

             if ( !tracer.contains( job ) )

             {

                 /* && !(url.toString().startsWith("jar:")) */

                 _logger.log( INFO, format( "Trying to bind \"%s\" to rocoto Module.", url ) );

                 PropertiesURLReader reader = new PropertiesURLReader( url ); 

                 if(url.toString().endsWith( ".xml" )){

                         reader.inXMLFormat();

                 }

                 module.addConfigurationReader( reader );

                 // TODO do we need protocol handling? file:/, ...

                 tracer.add( job );

             }

         }

         if ( CONFIGURATION == config.type() || BOTH == config.type() )

         {

             boolean isXML;

             String path = url.toString();

             if ( path.endsWith( ".xml" ) )

             {

                 isXML = true;

             }

             else if ( path.endsWith( ".properties" ) )

             {

                 isXML = false;

             }

             else

             {

                 _logger.log( WARNING, format( "Ignoring Configuration %s in %s because it doesn't end with .xml or .properties.",

                                               name, config.location() ) );

                 // TODO Throw an exception if config has another format?

                 return;

             }

             Named named = null;

             if ( name.value().length() > 0 )

             {

                 named = name;

             }

             if ( !config.lazy() )

             {

                 Properties properties;

                 try

                 {

                         PropertiesURLReader reader = new PropertiesURLReader( url ); 

                     if(isXML){

                             reader.inXMLFormat();

                     }

                     properties = reader.readConfiguration();

                 }

                 catch ( Exception e )

                 {

                     _logger.log( WARNING, format( "Configuration %s in %s cannot be loaded: %s",

                                                   name, url, e.getMessage() ), e );

                     return;

                 }

                 bindInstance( properties, Properties.class, named, null );

             }

             else

             {

                 Provider<Properties> provider = new PropertiesProvider( url, isXML );

                 bindProvider( provider, Properties.class, named, Singleton.class );

             }

         }

     }

     private URL findURL( Named name, PathConfig config )

     {

         URL url = null;

         String path = resolver.resolve( config.value() );

         switch ( config.type() )

         {

             case FILE:

                 File file = new File( path );

                 if ( !file.exists() )

                 {

                     _logger.log( WARNING, format( "Ignoring Configuration %s in %s, no Configuration found in %s",

                                                   name, path, file.getAbsolutePath() ) );

                     return null;

                 }

                 if ( file.isFile() )

                 {

                     try

                     {

                         url = file.toURI().toURL();

                     }

                     catch ( MalformedURLException e )

                     {

                         _logger.log( WARNING, format( "Ignoring Configuration %s in %s due to illegal URL location",

                                                       name, path ), e );

                         return null;

                     }

                 } /*

                    * else if (file.isDirectory()) { for (File entry : file.listFiles()) { try { url =

                    * entry.toURI().toURL(); } catch (MalformedURLException e) { _logger.log(Level.WARNING,

                    * "Ignoring Configuration " + name + " in " + path + ". It has an illegal URL-Format.", e); return

                    * null; } } }

                    */

                 break;

             case URL:

                 try

                 {

                     url = new URL( path );

                 }

                 catch ( MalformedURLException e )

                 {

                     _logger.log( WARNING, format( "Ignoring Configuration %s in %s due to illegal URL location",

                                                   name, path ), e );

                     return null;

                 }

                 break;

             case CLASSPATH:

             default:

                 url = this.getClass().getResource( path );

                 break;

         }

         return url;

     }

 }