/**

  * Copyright (c) 2008-2011, http://www.snakeyaml.org

  *

  * Licensed 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.yaml.snakeyaml.extensions.compactnotation;

 import java.beans.IntrospectionException;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import org.yaml.snakeyaml.constructor.AbstractConstruct;

 import org.yaml.snakeyaml.constructor.Construct;

 import org.yaml.snakeyaml.constructor.Constructor;

 import org.yaml.snakeyaml.error.YAMLException;

 import org.yaml.snakeyaml.introspector.Property;

 import org.yaml.snakeyaml.nodes.MappingNode;

 import org.yaml.snakeyaml.nodes.Node;

 import org.yaml.snakeyaml.nodes.NodeTuple;

 import org.yaml.snakeyaml.nodes.ScalarNode;

 /**

  * Construct a custom Java instance out of a compact object notation format.

  */

 public class CompactConstructor extends Constructor {

     private static final Pattern FIRST_PATTERN = Pattern.compile("(\\p{Alpha}.*)(\\s*)\\((.*?)\\)");

     private static final Pattern PROPERTY_NAME_PATTERN = Pattern

             .compile("\\s*(\\p{Alpha}\\w*)\\s*=(.+)");

     @Override

     protected Object constructScalar(ScalarNode node) {

         CompactData data = getCompactData(node.getValue());

         if (data != null) {

             return constructCompactFormat(node, data);

         } else {

             return super.constructScalar(node);

         }

     }

     protected Object constructCompactFormat(ScalarNode node, CompactData data) {

         try {

             Object obj = createInstance(node, data);

             Map<String, Object> properties = new HashMap<String, Object>(data.getProperties());

             setProperties(obj, properties);

             return obj;

         } catch (Exception e) {

             throw new YAMLException(e);

         }

     }

     protected Object createInstance(ScalarNode node, CompactData data) throws Exception {

         Class<?> clazz = getClassForName(data.getPrefix());

         Class<?>[] args = new Class[data.getArguments().size()];

         for (int i = 0; i < args.length; i++) {

             // assume all the arguments are Strings

             args[i] = String.class;

         }

         java.lang.reflect.Constructor<?> c = clazz.getDeclaredConstructor(args);

         c.setAccessible(true);

         return c.newInstance(data.getArguments().toArray());

     }

     protected void setProperties(Object bean, Map<String, Object> data) throws Exception {

         if (data == null) {

             throw new NullPointerException("Data for Compact Object Notation cannot be null.");

         }

         for (String key : data.keySet()) {

             Property property = getPropertyUtils().getProperty(bean.getClass(), key);

             try {

                 property.set(bean, data.get(key));

             } catch (IllegalArgumentException e) {

                 throw new YAMLException("Cannot set property='" + key + "' with value='"

                         + data.get(key) + "' (" + data.get(key).getClass() + ") in " + bean);

             }

         }

     }

     public CompactData getCompactData(String scalar) {

         if (!scalar.endsWith(")")) {

             return null;

         }

         if (scalar.indexOf('(') < 0) {

             return null;

         }

         Matcher m = FIRST_PATTERN.matcher(scalar);

         if (m.matches()) {

             String tag = m.group(1).trim();

             String content = m.group(3);

             CompactData data = new CompactData(tag);

             if (content.length() == 0)

                 return data;

             String[] names = content.split("\\s*,\\s*");

             for (int i = 0; i < names.length; i++) {

                 String section = names[i];

                 if (section.indexOf('=') < 0) {

                     data.getArguments().add(section);

                 } else {

                     Matcher sm = PROPERTY_NAME_PATTERN.matcher(section);

                     if (sm.matches()) {

                         String name = sm.group(1);

                         String value = sm.group(2).trim();

                         data.getProperties().put(name, value);

                     } else {

                         return null;

                     }

                 }

             }

             return data;

         }

         return null;

     }

     @Override

     protected Construct getConstructor(Node node) {

         if (node instanceof MappingNode) {

             MappingNode mnode = (MappingNode) node;

             List<NodeTuple> list = mnode.getValue();

             if (list.size() == 1) {

                 NodeTuple tuple = list.get(0);

                 Node key = tuple.getKeyNode();

                 if (key instanceof ScalarNode) {

                     ScalarNode scalar = (ScalarNode) key;

                     CompactData data = getCompactData(scalar.getValue());

                     if (data != null) {

                         return new ConstructCompactObject();

                     }

                 }

             }

         }

         return super.getConstructor(node);

     }

     public class ConstructCompactObject extends AbstractConstruct {

         @SuppressWarnings("unchecked")

         public Object construct(Node node) {

             Map<Object, Object> map = constructMapping((MappingNode) node);

             // Compact Object Notation may contain only one entry

             Map.Entry<Object, Object> entry = map.entrySet().iterator().next();

             Object result = entry.getKey();

             Object value = entry.getValue();

             if (value instanceof Map) {

                 Map<String, Object> properties = (Map<String, Object>) value;

                 try {

                     setProperties(result, properties);

                 } catch (Exception e) {

                     throw new YAMLException(e);

                 }

             } else {

                 // value is a list

                 applySequence(result, (List<?>) value);

             }

             return result;

         }

     }

     protected void applySequence(Object bean, List<?> value) {

         try {

             Property property = getPropertyUtils().getProperty(bean.getClass(),

                     getSequencePropertyName(bean.getClass()));

             property.set(bean, value);

         } catch (Exception e) {

             throw new YAMLException(e);

         }

     }

     /**

      * Provide the name of the property which is used when the entries form a

      * sequence. The property must be a List.

      * 

      * @throws IntrospectionException

      */

     protected String getSequencePropertyName(Class<?> bean) throws IntrospectionException {

         Set<Property> properties = getPropertyUtils().getProperties(bean);

         for (Iterator<Property> iterator = properties.iterator(); iterator.hasNext();) {

             Property property = iterator.next();

             if (!List.class.isAssignableFrom(property.getType())) {

                 iterator.remove();

             }

         }

         if (properties.size() == 0) {

             throw new YAMLException("No list property found in " + bean);

         } else if (properties.size() > 1) {

             throw new YAMLException(

                     "Many list properties found in "

                             + bean

                             + "; Please override getSequencePropertyName() to specify which property to use.");

         }

         return properties.iterator().next().getName();

     }

 }