package nl.tudelft.simulation.introspection.fields;
   
   import java.lang.reflect.Field;
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.LinkedHashSet;
   import java.util.List;
   import java.util.Set;
   
  import nl.tudelft.simulation.introspection.DelegateIntrospection;
  import nl.tudelft.simulation.introspection.Introspector;
  import nl.tudelft.simulation.introspection.Property;
  
  /**
   * The IntrospectionField introspector provides a field manipulation implementation of the introspection interfaces. Its
   * behavior adheres to the following:
   * <ul>
   * <li>Properties are discovered by searching for an object's fields (visibility neutral)</li>
   * <li>Property value are manipulated by setting field values (visibility neutral)</li>
   * </ul>
   * <p>
   * Copyright (c) 2002-2025 Delft University of Technology, Jaffalaan 5, 2628 BX Delft, the Netherlands. All rights reserved. See
   * for project information <a href="https://simulation.tudelft.nl/dsol/manual/" target="_blank">DSOL Manual</a>. The DSOL
   * project is distributed under a three-clause BSD-style license, which can be found at
   * <a href="https://simulation.tudelft.nl/dsol/docs/latest/license.html" target="_blank">DSOL License</a>.
   * </p>
   * @author <a href="https://www.linkedin.com/in/peterhmjacobs">Peter Jacobs </a>
   * @author <a href="https://github.com/averbraeck">Alexander Verbraeck</a>
   * @author Niels Lang.
   * @since 1.5
   */
  
  public class FieldIntrospector implements Introspector
  {
      /** useDeepIntrospection. */
      private boolean useDeepIntrospection = true;
  
      /**
       * constructs a new FieldIntrospector.
       */
      public FieldIntrospector()
      {
          this(false);
      }
  
      /**
       * constructs a new FieldIntrospector.
       * @param useDeepIntrospection whether to use deep introspection
       */
      public FieldIntrospector(final boolean useDeepIntrospection)
      {
          this.useDeepIntrospection = useDeepIntrospection;
      }
  
      @Override
      public Property[] getProperties(final Object introspectedObject)
      {
          Object introspected = introspectedObject;
          while (introspected instanceof DelegateIntrospection)
          {
              introspected = ((DelegateIntrospection) introspected).getParentIntrospectionObject();
          }
          Set<Property> props = new LinkedHashSet<Property>();
          try
          {
              Field[] fields = collectFields(introspected.getClass());
              for (int i = 0; i < fields.length; i++)
              {
                  props.add(new FieldProperty(introspected, fields[i]));
              }
          }
          catch (Exception e)
          {
              throw new IllegalArgumentException(this + " - getProperties", e);
          }
          return props.toArray(new Property[props.size()]);
      }
  
      /**
       * Collect the fields for the given class, taking the preference for deep introspection into account.
       * @param clasz the class to use
       * @return Field[] the fields
       */
      private Field[] collectFields(final Class<?> clasz)
      {
          List<Field> fields = new ArrayList<Field>(10);
          this.addFields(fields, clasz, this.useDeepIntrospection);
          return fields.toArray(new Field[fields.size()]);
      }
  
      /**
       * Add fields of 'clasz' to the fieldList. Optionally iterate over the class hierarchy.
       * @param fieldList the fieldList
       * @param clasz the class
       * @param iterate whether to iterate
       */
      private void addFields(final List<Field> fieldList, final Class<?> clasz, final boolean iterate)
      {
          fieldList.addAll(Arrays.asList(clasz.getDeclaredFields()));
         if (iterate && clasz.getSuperclass() != null)
         { addFields(fieldList, clasz.getSuperclass(), iterate); }
     }
 
     @Override
     public Property getProperty(final Object introspectedObject, final String property)
     {
         Object introspected = introspectedObject;
         while (introspected instanceof DelegateIntrospection)
         {
             introspected = ((DelegateIntrospection) introspected).getParentIntrospectionObject();
         }
         try
         {
             Field[] fields = collectFields(introspected.getClass());
             for (int i = 0; i < fields.length; i++)
             {
                 if (fields[i].getName().equals(property))
                 { return new FieldProperty(introspected, fields[i]); }
             }
         }
         catch (Exception e)
         {
             throw new IllegalArgumentException(this + " - getProperty", e);
         }
         throw new IllegalArgumentException("Property '" + property + "' not found for " + introspected);
     }
 
     @Override
     public String[] getPropertyNames(final Object introspectedObject)
     {
         Object introspected = introspectedObject;
         while (introspected instanceof DelegateIntrospection)
         {
             introspected = ((DelegateIntrospection) introspected).getParentIntrospectionObject();
         }
         Set<String> props = new LinkedHashSet<String>();
         try
         {
             Field[] fields = collectFields(introspected.getClass());
             for (int i = 0; i < fields.length; i++)
             {
                 props.add(fields[i].getName());
             }
         }
         catch (Exception e)
         {
             throw new IllegalArgumentException(this + " - getPropertyNames", e);
         }
         return props.toArray(new String[props.size()]);
     }
 }