/*
    * 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.dsl;
  
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.collections4.Transformer;
  import org.apache.commons.flatfile.DynamicField;
  import org.apache.commons.flatfile.Entity;
  import org.apache.commons.flatfile.EntityFactory;
  import org.apache.commons.flatfile.Field;
  import org.apache.commons.flatfile.util.ApplyOptions;
  import org.apache.commons.lang3.ObjectUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.commons.pool.BasePoolableObjectFactory;
  import org.apache.commons.pool.ObjectPool;
  import org.apache.commons.pool.impl.StackObjectPool;
  
  import antlr.TokenBuffer;
  import antlr.collections.AST;
  
  /**
   * Entity factory; provides access to named entities parsed from one or more description files.
   * @version $Revision: 1766123 $ $Date: 2016-10-21 15:40:45 -0500 (Fri, 21 Oct 2016) $
   */
  public class ParserEntityFactory implements EntityFactory {
  
      /** Field option constant */
      public static final String OPTION_FIELD = "field";
      /** DynamicField option constant */
      public static final String OPTION_DYNAMIC_FIELD = "dynamicField";
  
      private static final Log LOG = LogFactory.getLog(ParserEntityFactory.class);
      private static final EntityNameStrategy DEFAULT_NAME_STRATEGY = new DefaultEntityNameStrategy();
  
      private class EntityHolder {
  
          private final EntityDefinition definition;
          private Entity prototype;
  
          /**
           * Create a new EntityHolder instance.
           * @param definition base
           */
          EntityHolder(EntityDefinition definition) {
              this.definition = definition;
          }
  
          /**
           * Get the prototypical entity from this {@link EntityHolder}.
           * @return Entity
           */
          Entity getPrototype() {
              synchronized (this) {
                  if (prototype == null) {
                      prototype = doWithPooledTreeParser(new Transformer<EntityTreeParser, Entity>() {
  
                          public Entity transform(EntityTreeParser input) {
                              return input.createEntity(definition);
                          }
                      });
                  }
              }
              return prototype;
          }
      }
  
      private EntityNameStrategy entityNameStrategy;
      private Map<String, EntityHolder> entityMap;
      private final Map<String, Map<String, ?>> defaultOptionMaps = new HashMap<String, Map<String, ?>>();
      private boolean checked;
      private InputStream[] sources;
      private EntityFactory parent;
  
      private final ObjectPool<EntityTreeParser> treeParserPool =
          new StackObjectPool<EntityTreeParser>(new BasePoolableObjectFactory<EntityTreeParser>() {
  
              @Override
              public EntityTreeParser makeObject() throws Exception {
                  EntityTreeParser result = new EntityTreeParser();
                  result.setEntityFactory(ParserEntityFactory.this);
                 return result;
             }
         }, 1);
 
     /**
      * Create a new ParserEntityFactory.
      */
     public ParserEntityFactory() {
     }
 
     /**
      * Create a new ParserEntityFactory.
      * @param source to read
      */
     public ParserEntityFactory(InputStream source) {
         setSource(source);
     }
 
     /**
      * Create a new ParserEntityFactory.
      * @param sources to read
      */
     public ParserEntityFactory(InputStream[] sources) {
         setSources(sources);
     }
 
     /**
      * {@inheritDoc}
      */
     public final Entity getEntity(Object cue) {
         EntityHolder holder = getEntityMap().get(getEntityNameStrategy().getEntityName(cue));
         if (holder != null) {
             return holder.getPrototype().clone();
         }
         return getParent() == null ? null : getParent().getEntity(cue);
     }
 
     /**
      * Validate all defined entities.
      */
     public final synchronized void validate() {
         if (checked) {
             return;
         }
         for (String name : getEntityMap().keySet()) {
             getEntity(name);
         }
     }
 
     /**
      * Get the entityNameStrategy.
      * @return EntityNameStrategy.
      */
     public synchronized EntityNameStrategy getEntityNameStrategy() {
         return entityNameStrategy == null ? DEFAULT_NAME_STRATEGY : entityNameStrategy;
     }
 
     /**
      * Set the entityNameStrategy.
      * @param entityNameStrategy The EntityNameStrategy entityNameStrategy to set.
      */
     public synchronized void setEntityNameStrategy(EntityNameStrategy entityNameStrategy) {
         this.entityNameStrategy = entityNameStrategy;
     }
 
     /**
      * Get the InputStream[] sources.
      * @return InputStream[]
      */
     public InputStream[] getSources() {
         return sources;
     }
 
     /**
      * Set the InputStream[] sources.
      * @param sources InputStream[]
      */
     public void setSources(InputStream[] sources) {
         this.sources = sources;
     }
 
     /**
      * Convenience setter for a single InputStream source.
      * @param source to set
      */
     public void setSource(InputStream source) {
         setSources(new InputStream[] { source });
     }
 
     /**
      * Get the parent.
      * @return EntityFactory
      */
     public EntityFactory getParent() {
         return parent;
     }
 
     /**
      * Set the parent.
      * @param parent EntityFactory
      */
     public void setParent(EntityFactory parent) {
         this.parent = parent;
     }
 
     /**
      * Add an EntityDefinition
      * @param name to associate
      * @param def to add
      */
     void add(String name, EntityDefinition def) {
         entityMap.put(name, new EntityHolder(def));
     }
 
     /**
      * Set the default options for a given entity "type".
      * @param type String key
      * @param options option Map
      */
     void setDefaultOptions(String type, Map<String, ? extends Object> options) {
         Map<String, ? extends Object> old = defaultOptionMaps.put(type, options);
         if (!ObjectUtils.equals(old, options)) {
             LOG.warn("Overriding " + type + " options");
         }
     }
 
     /**
      * Get the default option map for a given entity "type".
      * @param type String key
      * @return option Map
      */
     Map<String, ? extends Object> getDefaultOptions(String type) {
         return defaultOptionMaps.get(type);
     }
 
     /**
      * Create a Field of a particular length, applying default options.
      * @param length of field
      * @return Field
      */
     Field createField(int length) {
         return applyDefaultOptions(new Field(length), OPTION_FIELD);
     }
 
     /**
      * Create a dynamic field, applying default options.
      * @return DynamicField
      */
     DynamicField createDynamicField() {
         return applyDefaultOptions(new DynamicField(), OPTION_DYNAMIC_FIELD);
     }
 
     /**
      * Create a field of a particular value, applying default options.
      * @param value of the field.
      * @return Field
      */
     Field createField(byte[] value) {
         return applyDefaultOptions(new Field(value), OPTION_FIELD);
     }
 
     /**
      * Apply the default options of the specified type to the specified Entity.
      * @param <E> Entity subtype
      * @param e E
      * @param type associated field type
      * @return e
      */
     private <E extends Entity> E applyDefaultOptions(E e, String type) {
         Map<String, ? extends Object> m = defaultOptionMaps.get(type);
         return m == null ? e : ApplyOptions.apply(e, m);
     }
 
     /**
      * Return our entity map, initializing if necessary.
      * @return Map<String, EntityProxy> - value may be an EntityDefinition or an Entity.
      */
     private synchronized Map<String, EntityHolder> getEntityMap() {
         if (entityMap == null) {
             entityMap = new HashMap<String, EntityHolder>();
             try {
                 EntityParser p = null;
                 final ArrayList<AST> trees = new ArrayList<AST>();
                 InputStream[] is = getSources();
                 for (InputStream element : is) {
                     TokenBuffer tb = new TokenBuffer(new EntityLexer(element));
                     if (p == null) {
                         p = new EntityParser(tb);
                     } else {
                         p.setTokenBuffer(tb);
                     }
                     p.parse();
                     trees.add(p.getAST());
                 }
                 doWithPooledTreeParser(new Transformer<EntityTreeParser, Void>() {
 
                     public Void transform(EntityTreeParser input) {
                         for (AST ast : trees) {
                             try {
                                 input.load(ast);
                             } catch (Exception e) {
                                 throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
                             }
                         }
                         return null;
                     }
                 });
             } catch (Exception e) {
                 throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
             }
         }
         return entityMap;
     }
 
     /**
      * Perform some function against a borrowed {@link EntityTreeParser} instance from the pool.
      * @param xform function
      * @param <T> expected result type of {@code xform}
      * @return result from invoking {@code xform.transform(entityTreeParser)}
      */
     private <T> T doWithPooledTreeParser(Transformer<EntityTreeParser, T> xform) {
         EntityTreeParser entityTreeParser;
         try {
             entityTreeParser = treeParserPool.borrowObject();
         } catch (Exception e) {
             throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
         }
         T result = xform.transform(entityTreeParser);
         try {
             treeParserPool.returnObject(entityTreeParser);
         } catch (Exception e) {
             LOG.error("Error returning EntityTreeParser to pool", e);
         }
         return result;
     }
 }