/*
    Copyright (C) 2008 Grid Systems, S.A.
   
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
   
    This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
  
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
  package com.gridsystems.nextgrid.api.pom;
  
  import java.beans.PropertyDescriptor;
  import java.net.URI;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.xml.namespace.QName;
  
  import nextgrid.api.pom.AbstractProcess;
  import nextgrid.api.pom.ControlProcess;
  import nextgrid.api.pom.Grounding;
  import nextgrid.api.pom.Process;
  import nextgrid.api.pom.Service;
  
  import org.apache.commons.jxpath.DynamicPropertyHandler;
  import org.apache.commons.jxpath.JXPathBeanInfo;
  
  /**
   * Extended BeanInfo meta-data class for JXPath access.
   *
   * @author Rodrigo Ruiz
   */
  public class ProcessImplXBeanInfo implements JXPathBeanInfo,
                                               DynamicPropertyHandler {
  
    /**
     * Process property names.
     */
    private static final String[] PROPERTY_NAMES = {
      "attributes",
      "children",
      "description",
      "grounding",
      "id",
      "inputs",
      "name",
      "outputs",
      "parent",
      "root",
      "selected",
    };
  
    /**
     * Empty array.
     */
    private static final Object[] EMPTY_ARRAY = new Object[0];
  
    /**
     * {@inheritDoc}
     */
    public Class<?> getDynamicPropertyHandlerClass() {
      return ProcessImplXBeanInfo.class;
    }
  
    /**
     * {@inheritDoc}
     */
    public PropertyDescriptor getPropertyDescriptor(String arg0) {
      return null;
    }
  
    /**
     * {@inheritDoc}
     */
    public PropertyDescriptor[] getPropertyDescriptors() {
      return new PropertyDescriptor[0];
    }
  
    /**
     * {@inheritDoc}
     */
    public boolean isAtomic() {
      return false;
    }
  
    /**
     * {@inheritDoc}
     */
    public boolean isDynamic() {
      return true;
    }
 
   /**
    * {@inheritDoc}
    */
   public Object getProperty(Object obj, String propertyName) {
     if (obj instanceof Process) {
       Process p = (Process)obj;
       if ("attributes".equals(propertyName)) {
         Map<QName, String> attribs = p.getAttributes();
         Map<String, String> attributes = new HashMap<String, String>();
         for (Map.Entry<QName, String> entry : attribs.entrySet()) {
           QName key = entry.getKey();
           attributes.put(toString(key), entry.getValue());
         }
         return attributes;
       } else if ("children".equals(propertyName)) {
         return getChildrenOf(p);
       } else if ("description".equals(propertyName)) {
         return p.getDescription();
       } else if ("id".equals(propertyName)) {
         URI id = p.getId();
         return (id == null) ? null : id.toString();
       } else if ("inputs".equals(propertyName)) {
         return p.getInputs();
       } else if ("name".equals(propertyName)) {
         return p.getName();
       } else if ("outputs".equals(propertyName)) {
         return p.getOutputs();
       } else if ("parent".equals(propertyName)) {
         return p.getParent();
       } else if ("root".equals(propertyName)) {
         return p.findRoot();
       }
 
       if (p instanceof AbstractProcess) {
         AbstractProcess ap = (AbstractProcess)p;
 
         if ("candidates".equals(propertyName)) {
           return ap.getCandidates();
         } else if ("selected".equals(propertyName)) {
           return ap.getSelected();
         }
       }
 
       if (p instanceof Service) {
         Service s = (Service)p;
 
         if ("grounding".equals(propertyName)) {
           return s.getGrounding();
         }
       }
     }
 
     return null;
   }
 
   /**
    * {@inheritDoc}
    */
   public String[] getPropertyNames(Object obj) {
     if (obj instanceof Process) {
       String[] copy = new String[PROPERTY_NAMES.length];
       System.arraycopy(PROPERTY_NAMES, 0, copy, 0, PROPERTY_NAMES.length);
       return copy;
     } else {
       return new String[0];
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void setProperty(Object arg0, String arg1, Object arg2) {
     // For now, this is left empty. XPathExpressions should not be used
     // for modifying the process tree
   }
 
   /**
    * Gets an array containing all children objects of the given process.
    *
    * @param p The process
    * @return Its children
    */
   private Object[] getChildrenOf(Process p) {
     if (p instanceof AbstractProcess) {
       Process selected = ((AbstractProcess)p).getSelected();
       return (selected == null) ? EMPTY_ARRAY : new Object[] { selected };
     } else if (p instanceof ControlProcess) {
       return ((ControlProcess)p).getChildren();
     } else if (p instanceof Service) {
       Grounding g = ((Service)p).getGrounding();
       return (g == null) ? EMPTY_ARRAY : new Object[] { g };
     } else {
       return EMPTY_ARRAY;
     }
   }
 
   /**
    * Converts a QName to a string that can be used in an XPath expression.
    *
    * @param qname The QName to convert
    * @return String representation
    */
   private String toString(QName qname) {
     String ns = qname.getNamespaceURI();
     String local = qname.getLocalPart();
     String s = ((ns == null) ? "" : ns) + "_" + local;
     return s.replaceAll("[\\:\\/\\%\\$\\&\\#\\@\\;]", "_");
   }
 
 }