/*
    * 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.myfaces.extensions.validator.core.storage;
  
  import org.apache.myfaces.extensions.validator.core.ExtValCoreConfiguration;
  import org.apache.myfaces.extensions.validator.internal.UsageInformation;
  import org.apache.myfaces.extensions.validator.internal.ToDo;
  import org.apache.myfaces.extensions.validator.internal.Priority;
  import static org.apache.myfaces.extensions.validator.internal.UsageCategory.INTERNAL;
  import org.apache.myfaces.extensions.validator.core.property.PropertyInformation;
  import org.apache.myfaces.extensions.validator.core.property.PropertyDetails;
  import org.apache.myfaces.extensions.validator.core.property.PropertyInformationKeys;
  import org.apache.myfaces.extensions.validator.core.property.DefaultPropertyInformation;
  import org.apache.myfaces.extensions.validator.core.metadata.MetaDataEntry;
  import org.apache.myfaces.extensions.validator.core.CustomInformation;
  import org.apache.myfaces.extensions.validator.core.ExtValContext;
  import org.apache.myfaces.extensions.validator.util.ClassUtils;
  import org.apache.myfaces.extensions.validator.util.ProxyUtils;
  import org.apache.myfaces.extensions.validator.util.NullValueAwareConcurrentHashMap;
  
  import java.util.Map;
  import java.util.List;
  import java.util.ArrayList;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.CopyOnWriteArrayList;
  import java.util.logging.Logger;
  
  /**
   * @since x.x.3
   */
  @UsageInformation(INTERNAL)
  public class DefaultMetaDataStorage implements MetaDataStorage
  {
      protected final Logger logger = Logger.getLogger(getClass().getName());
  
      private Map<String, Map<String, PropertyInformation>> cachedPropertyInformation =
              new ConcurrentHashMap<String, Map<String, PropertyInformation>>();
  
      private List<MetaDataStorageFilter> metaDataStorageFilters = new CopyOnWriteArrayList<MetaDataStorageFilter>();
      private List<Class<? extends MetaDataStorageFilter>> deniedMetaDataFilters =
              new CopyOnWriteArrayList<Class<? extends MetaDataStorageFilter>>();
  
      public DefaultMetaDataStorage()
      {
          initFilters();
      }
  
      private void initFilters()
      {
          List<String> metaDataStorageFilterClassNames = new ArrayList<String>();
  
          metaDataStorageFilterClassNames
              .add(ExtValCoreConfiguration.get().customMetaDataStorageFilterClassName());
          metaDataStorageFilterClassNames
              .add(ExtValContext.getContext().getInformationProviderBean().get(
                      CustomInformation.META_DATA_STORAGE_FILTER));
  
          MetaDataStorageFilter metaDataStorageFilter;
          for (String validationExceptionInterceptorName : metaDataStorageFilterClassNames)
          {
              metaDataStorageFilter =
                  (MetaDataStorageFilter)ClassUtils.tryToInstantiateClassForName(validationExceptionInterceptorName);
  
              if (metaDataStorageFilter != null)
              {
                  this.metaDataStorageFilters.add(metaDataStorageFilter);
  
                  logAddedFilter(metaDataStorageFilter.getClass());
              }
          }
      }
  
      public void storeMetaDataOf(PropertyInformation propertyInformation)
      {
          invokeFilters(propertyInformation);
  
          PropertyInformation propertyInformationToStore = new DefaultPropertyInformation();
  
          PropertyDetails propertyDetails = propertyInformation
                  .getInformation(PropertyInformationKeys.PROPERTY_DETAILS, PropertyDetails.class);
  
          copyMetaData(propertyInformation, propertyInformationToStore);
  
         getMapForClass(ProxyUtils.getUnproxiedClass(propertyDetails.getBaseObject().getClass()))
                 .put(propertyDetails.getProperty(), propertyInformationToStore);
     }
 
     private void invokeFilters(PropertyInformation propertyInformation)
     {
         for(MetaDataStorageFilter filter : this.metaDataStorageFilters)
         {
             filter.filter(propertyInformation);
         }
     }
 
     public MetaDataEntry[] getMetaData(Class targetClass, String targetProperty)
     {
         PropertyInformation propertyInformation = getMapForClass(targetClass).get(targetProperty);
 
         PropertyInformation clonedPropertyInformation = new DefaultPropertyInformation();
         copyMetaData(propertyInformation, clonedPropertyInformation);
 
         return clonedPropertyInformation.getMetaDataEntries();
     }
 
     public boolean containsMetaDataFor(Class targetClass, String targetProperty)
     {
         return getMapForClass(targetClass).containsKey(targetProperty);
     }
 
     public void registerFilter(MetaDataStorageFilter storageFilter)
     {
         synchronized (this)
         {
             if(!isFilterDenied(storageFilter) && !isFilterAlreadyRegistered(storageFilter))
             {
                 this.metaDataStorageFilters.add(storageFilter);
                 logAddedFilter(storageFilter.getClass());
             }
         }
     }
 
     private boolean isFilterDenied(MetaDataStorageFilter storageFilter)
     {
         return this.deniedMetaDataFilters.contains(getStorageFilterClass(storageFilter));
     }
 
     private boolean isFilterAlreadyRegistered(MetaDataStorageFilter storageFilter)
     {
         for(MetaDataStorageFilter filter : this.metaDataStorageFilters)
         {
             if(filter.getClass().equals(getStorageFilterClass(storageFilter)))
             {
                 return true;
             }
         }
         return false;
     }
 
     public void deregisterFilter(Class<? extends MetaDataStorageFilter> filterClass)
     {
         MetaDataStorageFilter storageFilter = ClassUtils.tryToInstantiateClass(filterClass);
 
         synchronized (this)
         {
             this.metaDataStorageFilters.remove(storageFilter);
         }
 
         logRemovedFilter(storageFilter.getClass());
     }
 
     public void denyFilter(Class<? extends MetaDataStorageFilter> filterClass)
     {
         synchronized (this)
         {
             for(Class<? extends MetaDataStorageFilter> filterId : this.deniedMetaDataFilters)
             {
                 if(filterId.equals(filterClass))
                 {
                     return;
                 }
             }
             this.deniedMetaDataFilters.add(filterClass);
         }
 
         deregisterFilter(filterClass);
     }
 
     @ToDo(Priority.MEDIUM)
     private void copyMetaData(PropertyInformation source, PropertyInformation target)
     {
         MetaDataEntry newMetaDataEntry;
         for(MetaDataEntry metaDataEntry : source.getMetaDataEntries())
         {
             newMetaDataEntry = new MetaDataEntry();
             newMetaDataEntry.setKey(metaDataEntry.getKey());
             newMetaDataEntry.setValue(metaDataEntry.getValue());
 
             target.addMetaDataEntry(newMetaDataEntry);
         }
     }
 
     private void logAddedFilter(Class<? extends MetaDataStorageFilter> filterClass)
     {
         this.logger.info(filterClass.getName() + " added");
     }
 
     private void logRemovedFilter(Class<? extends MetaDataStorageFilter> filterClass)
     {
         this.logger.info(filterClass.getName() + " removed");
     }
 
     private Map<String, PropertyInformation> getMapForClass(Class target)
     {
         String key = ProxyUtils.getClassName(target);
         if(!this.cachedPropertyInformation.containsKey(key))
         {
             this.cachedPropertyInformation.put(key,
                 new NullValueAwareConcurrentHashMap<String, PropertyInformation>(new NullMarkerPropertyInformation()));
         }
         return this.cachedPropertyInformation.get(key);
     }
 
     private static class NullMarkerPropertyInformation implements PropertyInformation
     {
         public boolean containsInformation(String key)
         {
             throw new UnsupportedOperationException();
         }
 
         public Object getInformation(String key)
         {
             throw new UnsupportedOperationException();
         }
 
         public <T> T getInformation(String key, Class<T> targetClass)
         {
             throw new UnsupportedOperationException();
         }
 
         public void setInformation(String key, Object value)
         {
             throw new UnsupportedOperationException();
         }
 
         public MetaDataEntry[] getMetaDataEntries()
         {
             throw new UnsupportedOperationException();
         }
 
         public void addMetaDataEntry(MetaDataEntry metaDataEntry)
         {
             throw new UnsupportedOperationException();
         }
 
         public void resetMetaDataEntries()
         {
             throw new UnsupportedOperationException();
         }
 
         @Override
         public int hashCode()
         {
             return getClass().hashCode();
         }
 
         @Override
         public boolean equals(Object target)
         {
             return target != null && getClass().equals(target.getClass());
         }
     }
 
     private Class<? extends MetaDataStorageFilter> getStorageFilterClass(MetaDataStorageFilter storageFilter)
     {
         return ProxyUtils.getUnproxiedClass(storageFilter.getClass(), MetaDataStorageFilter.class);
     }
 }