/*

  * Copyright 2007 The Kuali Foundation Licensed under the Educational Community

  * License, Version 1.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/ecl1.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.uif.util;

 import org.apache.commons.lang.StringUtils;

 import org.kuali.rice.krad.uif.container.View;

 import org.kuali.rice.krad.uif.core.BindingInfo;

 import org.kuali.rice.krad.uif.field.AttributeField;

 import java.util.Collection;

 import java.util.Map;

 /**

  * Provides methods for getting property values, types, and paths within the

  * context of a <code>View</code>

  * 

  * <p>

  * The view provides a special map named 'abstractTypeClasses' that indicates

  * concrete classes that should be used in place of abstract property types that

  * are encountered on the object graph. This classes takes into account that map

  * while dealing with properties. e.g. suppose we have propertyPath

  * 'document.name' on the form, with the type of the document property set to

  * the interface Document. Using class introspection we would get back the

  * interface type for document and this would not be able to get the property

  * type for name. Using the view map, we can replace document with a concrete

  * class and then use it to get the name property

  * </p>

  * 

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class ViewModelUtils {

     public static Class<?> getPropertyType(View view, String propertyPath) {

         Class<?> propertyType = null;

         if (StringUtils.isBlank(propertyPath)) {

             return propertyType;

         }

         // in case of partial match, holds the class that matched and the

         // property so we can get by reflection

         Class<?> modelClass = view.getFormClass();

         String modelProperty = propertyPath;

         int bestMatchLength = 0;

         // removed collection indexes from path for matching

         String flattenedPropertyPath = propertyPath.replaceAll("\\[.+\\]", "");

         // check if property path matches one of the modelClass entries

         Map<String, Class<?>> modelClasses = view.getAbstractTypeClasses();

         for (String path : modelClasses.keySet()) {

             // full match

             if (StringUtils.equals(path, flattenedPropertyPath)) {

                 propertyType = modelClasses.get(path);

                 break;

             }

             // partial match

             if (flattenedPropertyPath.startsWith(path) && (path.length() > bestMatchLength)) {

                 bestMatchLength = path.length();

                 modelClass = modelClasses.get(path);

                 modelProperty = StringUtils.removeStart(flattenedPropertyPath, path);

                 modelProperty = StringUtils.removeStart(modelProperty, ".");

             }

         }

         // if full match not found, get type based on reflection

         if (propertyType == null) {

             propertyType = ObjectPropertyUtils.getPropertyType(modelClass, modelProperty);

         }

         return propertyType;

     }

     public static String getParentObjectPath(AttributeField field) {

         String parentObjectPath = "";

         String objectPath = field.getBindingInfo().getBindingObjectPath();

         String propertyPrefix = field.getBindingInfo().getBindByNamePrefix();

         if (!field.getBindingInfo().isBindToForm() && StringUtils.isNotBlank(objectPath)) {

             parentObjectPath = objectPath;

         }

         if (StringUtils.isNotBlank(propertyPrefix)) {

             if (StringUtils.isNotBlank(parentObjectPath)) {

                 parentObjectPath += ".";

             }

             parentObjectPath += propertyPrefix;

         }

         return parentObjectPath;

     }

     public static Class<?> getParentObjectClassForMetadata(View view, AttributeField field) {

         String parentObjectPath = getParentObjectPath(field);

         return getPropertyType(view, parentObjectPath);

     }

     public static Object getParentObjectForMetadata(View view, Object model, AttributeField field) {

         // default to model as parent

         Object parentObject = model;

         String parentObjectPath = getParentObjectPath(field);

         if (StringUtils.isNotBlank(parentObjectPath)) {

             parentObject = ObjectPropertyUtils.getPropertyValue(model, parentObjectPath);

             // attempt to create new instance if parent is null or is a

             // collection or map

             if ((parentObject == null) || Collection.class.isAssignableFrom(parentObject.getClass())

                     || Map.class.isAssignableFrom(parentObject.getClass())) {

                 try {

                     Class<?> parentObjectClass = getPropertyType(view, parentObjectPath);

                     parentObject = parentObjectClass.newInstance();

                 }

                 catch (InstantiationException e) {

                     // swallow exception and let null be returned

                 }

                 catch (IllegalAccessException e) {

                     // swallow exception and let null be returned

                 }

             }

         }

         return parentObject;

     }

     public static Object getValue(View view, Object model, String propertyName, BindingInfo bindingInfo){

         Object value = null;

         if(bindingInfo == null && StringUtils.isNotBlank(propertyName)){

             if(StringUtils.isNotBlank(view.getDefaultBindingObjectPath())){

                 value = ObjectPropertyUtils.getPropertyValue(model, view.getDefaultBindingObjectPath() + "." + propertyName);

             }

             else{

                 value = ObjectPropertyUtils.getPropertyValue(model, propertyName);

             }

         }

         else if(bindingInfo != null){

             if(StringUtils.isNotBlank(bindingInfo.getBindingPath()) && !bindingInfo.getBindingPath().equals("null")){

                 value = ObjectPropertyUtils.getPropertyValue(model, bindingInfo.getBindingPath());

             }

         }

         return value;

     }

 }