/*
    * 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.commons.flatfile;
  
  import java.io.Serializable;
  import java.util.AbstractList;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.collections4.IteratorUtils;
  import org.apache.commons.collections4.Transformer;
  import org.apache.commons.lang3.ArrayUtils;
  import org.apache.commons.lang3.Validate;
  
  /**
   * Basic implementation of NamedEntityCollection.
   * @version $Revision: 1766123 $ $Date: 2016-10-21 15:40:45 -0500 (Fri, 21 Oct 2016) $
   */
  public class EntityMap extends EntityCollectionSupport implements NamedEntityCollection {
  
      private static final long serialVersionUID = 3162898927743996952L;
  
      private static class Child implements Serializable {
  
          /** Serialization version */
          private static final long serialVersionUID = 2347729609002856564L;
  
          private final String name;
          @SuppressWarnings("PMD.UnusedPrivateField") // false positive; this field is used in EntityMap#clone()
          private final Entity entity;
  
          /**
           * Create a new Child instance.
           * @param name of child
           * @param entity child
           */
          public Child(String name, Entity entity) {
              this.name = name;
              if (entity == null) {
                  throw new IllegalArgumentException();
              }
              this.entity = entity;
          }
  
      }
  
      /**
       * Expose the Child list as List<Entity>. This is necessary because we permit nameless children,
       * which we want to account for in a layout but have no need of referencing later.
       */
      private static class ChildrenList extends AbstractList<Entity> implements Serializable {
  
          private static final long serialVersionUID = -954784669450571284L;
  
          private static final Transformer<Child, Entity> CHILD_TO_ENTITY = new Transformer<Child, Entity>() {
  
              public Entity transform(Child input) {
                  return input.entity;
              }
          };
  
          private final List<Child> wrapped;
  
          /**
           * Create a new {@link ChildrenList} wrapping the specified {@link List}.
           * @param wrapped {@link List}
           */
          private ChildrenList(List<Child> wrapped) {
              super();
              this.wrapped = wrapped;
          }
  
          /**
           * {@inheritDoc}
           */
          @Override
          public Entity get(int index) {
              return CHILD_TO_ENTITY.transform(wrapped.get(index));
          }
  
         /**
          * {@inheritDoc}
          */
         @Override
         public Iterator<Entity> iterator() {
             return IteratorUtils.transformedIterator(wrapped.iterator(), CHILD_TO_ENTITY);
         }
 
         @Override
         public int size() {
             return wrapped.size();
         }
 
     }
 
     /** All children */
     private List<Child> children;
 
     /** contains mapped children only */
     private Map<String, Entity> childMap;
 
     private List<Entity> exposeChildrenList;
 
     /**
      * Add a child.
      * @param name if {@code null} filler element
      * @param child non-null child Entity
      */
     public synchronized void add(String name, Entity child) {
         Validate.notNull(child, "child entity is null");
 
         if (children == null) {
             children = new ArrayList<Child>();
             exposeChildrenList = new ChildrenList(children);
             childMap = new LinkedHashMap<String, Entity>();
         }
         if (childMap.containsKey(name)) {
             throw new IllegalArgumentException("cannot add > 1 child entity '" + name + "'");
         }
         if (name != null) {
             childMap.put(name, child);
         }
         children.add(new Child(name, child));
     }
 
     /**
      * Get a map of the children.
      * @return Map<String, Entity>
      */
     public synchronized Map<String, Entity> getChildMap() {
         return childMap == null ? Collections.<String, Entity> emptyMap() : Collections.unmodifiableMap(childMap);
     }
 
     /**
      * {@inheritDoc}
      */
     public synchronized String[] getChildNames() {
         return childMap == null ? ArrayUtils.EMPTY_STRING_ARRAY
             : childMap.keySet().toArray(new String[childMap.size()]);
     }
 
     /**
      * {@inheritDoc}
      */
     public Entity getChild(String name) {
         return getChildMap().get(name);
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean hasChild(String name) {
         return getChildMap().containsKey(name);
     }
 
     /**
      * {@inheritDoc}
      */
     public synchronized Collection<Entity> getChildren() {
         return children == null ? Collections.<Entity> emptyList() : Collections.unmodifiableList(exposeChildrenList);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public synchronized EntityMap clone() {
         EntityMap result = (EntityMap) super.clone();
         result.children = null;
         result.childMap = null;
         result.exposeChildrenList = null;
         if (children != null) {
             for (Child child : children) {
                 result.add(child.name, child.entity.clone());
             }
         }
         return result;
     }
 }