/**
    * Copyright 2005-2011 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    *
   * 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.kuali.rice.krad.web.bind;
  
  import org.kuali.rice.core.web.format.Formatter;
  import org.kuali.rice.krad.uif.field.DataField;
  import org.kuali.rice.krad.web.form.UifFormBase;
  import org.springframework.beans.BeanWrapperImpl;
  import org.springframework.beans.BeansException;
  import org.springframework.beans.InvalidPropertyException;
  import org.springframework.beans.PropertyValue;
  
  import java.beans.PropertyDescriptor;
  import java.beans.PropertyEditor;
  import java.util.HashSet;
  import java.util.Set;
  
  /**
   * This class is a top level BeanWrapper for a UIF View (form).  It will call the
   * view service to find formatters and check if fields are encrypted.
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class UifViewBeanWrapper extends BeanWrapperImpl {
      private static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(UifViewBeanWrapper.class);
  
      // this is a handle to the target object so we don't
      // have to cast so often
      private UifFormBase form;
  
      // this stores all properties this wrapper has already checked
      // with the view so the service isn't called again
      private Set<String> processedProperties;
  
      public UifViewBeanWrapper(Object object) {
          super(object);
  
          form = (UifFormBase) object;
          processedProperties = new HashSet<String>();
      }
  
      protected void callViewService(String propertyName) {
          if (LOG.isDebugEnabled()) {
              LOG.debug("Attempting view service call for property '" + propertyName + "'");
          }
          Class<? extends Formatter> formatterClass = null;
  
          // viewId should be determined in UifAnnotationMethodHandlerAdapter so
          // nothing we can do without one here
          if (form.getView() == null) {
              return;
          }
  
          // check if we already processed this property for this BeanWrapper instance
          if (processedProperties.contains(propertyName)) {
              return;
          }
  
          DataField af = null;
          if (form.getView().getViewIndex() != null) {
              af = form.getView().getViewIndex().getDataFieldByPath(propertyName);
          }
  
          if ((af == null) && (form.getPreviousView() != null) && (form.getPreviousView().getViewIndex() != null)) {
              af = form.getPreviousView().getViewIndex().getDataFieldByPath(propertyName);
          }
  
          boolean requiresEncryption = false;
          if (af != null) {
              if (af.getAttributeSecurity() != null) {
                  if (af.getAttributeSecurity().hasRestrictionThatRemovesValueFromUI()) {
                      requiresEncryption = true;
                  }
              }
  
              Formatter formatter = af.getFormatter();
              if (formatter != null) {
                  formatterClass = formatter.getClass();
              }
          }
  
          // really these should be PropertyEditors after we evaluate how many are
          // needed vs how many spring provides
          if (formatterClass != null) {
              if (LOG.isDebugEnabled()) {
                  LOG.debug("Registering custom editor for property path '" + propertyName + "' and formatter class '" +
                         formatterClass.getName() + "'");
             }
             PropertyEditor customEditor = new UifKnsFormatterPropertyEditor(formatterClass);
             if (requiresEncryption) {
                 if (LOG.isDebugEnabled()) {
                     LOG.debug("Enabling encryption for custom editor '" + propertyName + "' and formatter class '" +
                             formatterClass.getName() + "'");
                 }
                 this.registerCustomEditor(null, propertyName, new UifEncryptionPropertyEditorWrapper(customEditor));
             } else {
                 this.registerCustomEditor(null, propertyName, customEditor);
             }
         } else if (requiresEncryption) {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("No custom formatter for property path '" + propertyName +
                         "' but property does require encryption");
             }
             this.registerCustomEditor(null, propertyName,
                     new UifEncryptionPropertyEditorWrapper(findEditorForPropertyName(propertyName)));
         }
 
         processedProperties.add(propertyName);
     }
 
     protected PropertyEditor findEditorForPropertyName(String propertyName) {
         Class<?> clazz = getPropertyType(propertyName);
         if (LOG.isDebugEnabled()) {
             LOG.debug("Attempting retrieval of property editor using class '" + clazz + "' and property path '" +
                     propertyName + "'");
         }
         PropertyEditor editor = findCustomEditor(clazz, propertyName);
         if (editor == null) {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("No custom property editor found using class '" + clazz + "' and property path '" +
                         propertyName + "'. Attempting to find default property editor class.");
             }
             editor = getDefaultEditor(clazz);
         }
         return editor;
     }
 
     @Override
     public Class<?> getPropertyType(String propertyName) throws BeansException {
         try {
             PropertyDescriptor pd = getPropertyDescriptorInternal(propertyName);
             if (pd != null) {
                 return pd.getPropertyType();
             }
 
             // Maybe an indexed/mapped property...
             Object value = super.getPropertyValue(propertyName);
             if (value != null) {
                 return value.getClass();
             }
 
             // Check to see if there is a custom editor,
             // which might give an indication on the desired target type.
             Class<?> editorType = guessPropertyTypeFromEditors(propertyName);
             if (editorType != null) {
                 return editorType;
             }
         } catch (InvalidPropertyException ex) {
             // Consider as not determinable.
         }
 
         return null;
     }
 
     @Override
     public Object getPropertyValue(String propertyName) throws BeansException {
         callViewService(propertyName);
         return super.getPropertyValue(propertyName);
     }
 
     @Override
     public void setPropertyValue(PropertyValue pv) throws BeansException {
         callViewService(pv.getName());
         super.setPropertyValue(pv);
     }
 
     @Override
     public void setPropertyValue(String propertyName, Object value) throws BeansException {
         callViewService(propertyName);
         super.setPropertyValue(propertyName, value);
     }
 
     @Override
     public void setWrappedInstance(Object object, String nestedPath, Object rootObject) {
         //TODO clear cache?
         form = (UifFormBase) object;
         super.setWrappedInstance(object, nestedPath, rootObject);
     }
 
     @Override
     public void setWrappedInstance(Object object) {
         //TODO clear cache?
         form = (UifFormBase) object;
         super.setWrappedInstance(object);
     }
 }