/*

  * $Id: BaseLocaleUrlDefinitionDAO.java 1297705 2012-03-06 20:44:30Z nlebas $

  *

  * 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.

  */

 package org.apache.tiles.definition.dao;

 import java.io.FileNotFoundException;

 import java.io.IOException;

 import java.io.InputStream;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Locale;

 import java.util.Map;

 import java.util.Set;

 import org.apache.tiles.Definition;

 import org.apache.tiles.definition.DefinitionsFactoryException;

 import org.apache.tiles.definition.DefinitionsReader;

 import org.apache.tiles.definition.RefreshMonitor;

 import org.apache.tiles.request.ApplicationContext;

 import org.apache.tiles.request.ApplicationResource;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 /**

  * Base abstract class for a DAO that is based on URLs and locale as a

  * customization key.

  *

  * @version $Rev: 1297705 $ $Date: 2012-03-07 07:44:30 +1100 (Wed, 07 Mar 2012) $

  * @since 2.1.0

  */

 public abstract class BaseLocaleUrlDefinitionDAO implements

         DefinitionDAO<Locale>, RefreshMonitor {

     /**

      * The logging object.

      */

     private final Logger log = LoggerFactory

             .getLogger(BaseLocaleUrlDefinitionDAO.class);

     /**

      * Contains the URL objects identifying where configuration data is found.

      *

      * @since 2.1.0

      */

     protected List<ApplicationResource> sources;

     /**

      * Contains the dates that the URL sources were last modified.

      *

      * @since 2.1.0

      */

     protected Map<String, Long> lastModifiedDates;

     /**

      * Reader used to get definitions from the sources.

      *

      * @since 2.1.0

      */

     protected DefinitionsReader reader;

     /**

      * ApplicationContext to locate the source files.

      * 

      * @since 3.0.0

      */

     protected ApplicationContext applicationContext;

     /**

      * Constructor.

      */

     public BaseLocaleUrlDefinitionDAO(ApplicationContext applicationContext) {

         this.applicationContext = applicationContext;

         lastModifiedDates = new HashMap<String, Long>();

     }

     public void setSources(List<ApplicationResource> sources) {

         // filter out any sources that are already localized

         ArrayList<ApplicationResource> defaultSources = new ArrayList<ApplicationResource>();

         for(ApplicationResource source: sources) {

             if(Locale.ROOT.equals(source.getLocale())) {

                 defaultSources.add(source);

             }

         }

         this.sources = defaultSources;

     }

     public void setReader(DefinitionsReader reader) {

         this.reader = reader;

     }

     /** {@inheritDoc} */

     public boolean refreshRequired() {

         boolean status = false;

         Set<String> paths = lastModifiedDates.keySet();

         try {

             for (String path : paths) {

                 Long lastModifiedDate = lastModifiedDates.get(path);

                 ApplicationResource resource = applicationContext.getResource(path);

                 long newModDate = resource.getLastModified();

                 if (newModDate != lastModifiedDate) {

                     status = true;

                     break;

                 }

             }

         } catch (IOException e) {

             log.warn("Exception while monitoring update times.", e);

             return true;

         }

         return status;

     }

     /**

      * Loads definitions from an URL without loading from "parent" URLs.

      *

      * @param resource The URL to read.

      * @return The definition map that has been read.

      */

     protected Map<String, Definition> loadDefinitionsFromResource(ApplicationResource resource) {

         Map<String, Definition> defsMap = null;

         InputStream stream = null;

         try {

             lastModifiedDates.put(resource.getLocalePath(), resource

                     .getLastModified());

             // Definition must be collected, starting from the base

             // source up to the last localized file.

             stream = resource.getInputStream();

             defsMap = reader.read(stream);

         } catch (FileNotFoundException e) {

             // File not found. continue.

             if (log.isDebugEnabled()) {

                 log.debug("File " + resource.toString() + " not found, continue");

             }

         } catch (IOException e) {

             throw new DefinitionsFactoryException(

                     "I/O error processing configuration.", e);

         } finally {

             try {

                 if (stream != null) {

                     stream.close();

                 }

             } catch (IOException e) {

                 throw new DefinitionsFactoryException(

                         "I/O error closing " + resource.toString(), e);

             }

         }

         return defsMap;

     }

 }