package com.opencsv.bean;
   
   import com.opencsv.CSVReader;
   import com.opencsv.ICSVParser;
   import com.opencsv.exceptions.CsvRequiredFieldEmptyException;
   import org.apache.commons.collections4.ListValuedMap;
   import org.apache.commons.lang3.ArrayUtils;
   
   import java.io.IOException;
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Field;
  import java.util.*;
  
  /**
   * Allows for the mapping of columns with their positions. Using this strategy
   * without annotations ({@link com.opencsv.bean.CsvBindByPosition} or
   * {@link com.opencsv.bean.CsvCustomBindByPosition}) requires all the columns
   * to be present in the CSV file and for them to be in a particular order. Using
   * annotations allows one to specify arbitrary zero-based column numbers for
   * each bean member variable to be filled. Also this strategy requires that the
   * file does NOT have a header. That said, the main use of this strategy is
   * files that do not have headers.
   *
   * @param <T> Type of object that is being processed.
   */
  public class ColumnPositionMappingStrategy<T> extends AbstractMappingStrategy<String, Integer, ComplexFieldMapEntry<String, Integer, T>, T> {
  
      /**
       * Whether the user has programmatically set the map from column positions
       * to field names.
       */
      private boolean columnsExplicitlySet = false;
  
      /**
       * The map from column position to {@link BeanField}.
       */
      private FieldMapByPosition<T> fieldMap;
  
      /**
       * Holds a {@link java.util.Comparator} to sort columns on writing.
       */
      private Comparator<Integer> writeOrder;
  
      /**
       * Used to store a mapping from presumed input column index to desired
       * output column index, as determined by applying {@link #writeOrder}.
       */
      private Integer[] columnIndexForWriting = null;
  
      /**
       * Default constructor. Considered stable.
       * @see ColumnPositionMappingStrategyBuilder
       */
      public ColumnPositionMappingStrategy() {
      }
  
      /**
       * There is no header per se for this mapping strategy, but this method
       * checks the first line to determine how many fields are present and
       * adjusts its field map accordingly.
       */
      // The rest of the Javadoc is inherited
      @Override
      public void captureHeader(CSVReader reader) throws IOException {
          // Validation
          if (type == null) {
              throw new IllegalStateException(ResourceBundle
                      .getBundle(ICSVParser.DEFAULT_BUNDLE_NAME, errorLocale)
                      .getString("type.unset"));
          }
  
          String[] firstLine = ArrayUtils.nullToEmpty(reader.peek());
          fieldMap.setMaxIndex(firstLine.length - 1);
          if (!columnsExplicitlySet) {
              headerIndex.clear();
              for (FieldMapByPositionEntry<T> entry : fieldMap) {
                  Field f = entry.getField().getField();
                  if (f.getAnnotation(CsvCustomBindByPosition.class) != null
                          || f.getAnnotation(CsvBindAndSplitByPosition.class) != null
                          || f.getAnnotation(CsvBindAndJoinByPosition.class) != null
                          || f.getAnnotation(CsvBindByPosition.class) != null) {
                      headerIndex.put(entry.getPosition(), f.getName().toUpperCase().trim());
                  }
              }
          }
      }
  
      /**
       * @return {@inheritDoc} For this mapping strategy, it's simply
       * {@code index} wrapped as an {@link java.lang.Integer}.
       */
      // The rest of the Javadoc is inherited
      @Override
      protected Integer chooseMultivaluedFieldIndexFromHeaderIndex(int index) {
          return Integer.valueOf(index);
      }
  
      @Override
      protected BeanField<T, Integer> findField(int col) {
         // If we have a mapping for changing the order of the columns on
         // writing, be sure to use it.
         if (columnIndexForWriting != null) {
             return col < columnIndexForWriting.length ? fieldMap.get(columnIndexForWriting[col]) : null;
         }
         return fieldMap.get(col);
     }
 
     /**
      * This method returns an empty array.
      * The column position mapping strategy assumes that there is no header, and
      * thus it also does not write one, accordingly.
      *
      * @return An empty array
      */
     // The rest of the Javadoc is inherited
     @Override
     public String[] generateHeader(T bean) throws CsvRequiredFieldEmptyException {
         String[] h = super.generateHeader(bean);
         columnIndexForWriting = new Integer[h.length];
         Arrays.setAll(columnIndexForWriting, i -> i);
 
         // Create the mapping for input column index to output column index.
         Arrays.sort(columnIndexForWriting, writeOrder);
         return ArrayUtils.EMPTY_STRING_ARRAY;
     }
 
     /**
      * Gets a column name.
      *
      * @param col Position of the column.
      * @return Column name or null if col &gt; number of mappings.
      */
     @Override
     public String getColumnName(int col) {
         return headerIndex.getByPosition(col);
     }
 
     /**
      * Retrieves the column mappings.
      *
      * @return String array with the column mappings.
      */
     public String[] getColumnMapping() {
         return headerIndex.getHeaderIndex();
     }
 
     /**
      * Setter for the column mapping.
      * This mapping is for reading. Use of this method in conjunction with
      * writing is undefined.
      *
      * @param columnMapping Column names to be mapped.
      */
     public void setColumnMapping(String... columnMapping) {
         if (columnMapping != null) {
             headerIndex.initializeHeaderIndex(columnMapping);
         } else {
             headerIndex.clear();
         }
         columnsExplicitlySet = true;
         if(getType() != null) {
             loadFieldMap(); // In case setType() was called first.
         }
     }
 
     /**
      * Register a binding between a bean field and a custom converter.
      *
      * @param annotation The annotation attached to the bean field
      * @param localType The class/type in which the field resides
      * @param localField The bean field
      */
     private void registerCustomBinding(CsvCustomBindByPosition annotation, Class<?> localType, Field localField) {
         @SuppressWarnings("unchecked")
         Class<? extends AbstractBeanField<T, Integer>> converter = (Class<? extends AbstractBeanField<T, Integer>>)annotation.converter();
         BeanField<T, Integer> bean = instantiateCustomConverter(converter);
         bean.setType(localType);
         bean.setField(localField);
         bean.setRequired(annotation.required());
         fieldMap.put(annotation.position(), bean);
     }
 
     /**
      * Register a binding between a bean field and a collection converter that
      * splits input into multiple values.
      *
      * @param annotation The annotation attached to the bean field
      * @param localType The class/type in which the field resides
      * @param localField The bean field
      */
     private void registerSplitBinding(CsvBindAndSplitByPosition annotation, Class<?> localType, Field localField) {
         String fieldLocale = annotation.locale();
         String fieldWriteLocale = annotation.writeLocaleEqualsReadLocale()
                 ? fieldLocale
                 : annotation.writeLocale();
         Class<?> elementType = annotation.elementType();
         CsvConverter converter = determineConverter(localField, elementType,
                 fieldLocale, fieldWriteLocale, annotation.converter());
         fieldMap.put(annotation.position(), new BeanFieldSplit<>(
                 localType, localField, annotation.required(), errorLocale, converter,
                 annotation.splitOn(), annotation.writeDelimiter(),
                 annotation.collectionType(), elementType, annotation.capture(),
                 annotation.format()));
     }
 
     /**
      * Register a binding between a bean field and a multi-valued converter
      * that joins values from multiple columns.
      *
      * @param annotation The annotation attached to the bean field
      * @param localType The class/type in which the field resides
      * @param localField The bean field
      */
     private void registerJoinBinding(CsvBindAndJoinByPosition annotation, Class<?> localType, Field localField) {
         String fieldLocale = annotation.locale();
         String fieldWriteLocale = annotation.writeLocaleEqualsReadLocale()
                 ? fieldLocale
                 : annotation.writeLocale();
         CsvConverter converter = determineConverter(localField, annotation.elementType(),
                 fieldLocale, fieldWriteLocale, annotation.converter());
         fieldMap.putComplex(annotation.position(), new BeanFieldJoinIntegerIndex<>(
                 localType, localField, annotation.required(), errorLocale, converter,
                 annotation.mapType(), annotation.capture(), annotation.format()));
     }
 
     /**
      * Register a binding between a bean field and a simple converter.
      *
      * @param annotation The annotation attached to the bean field
      * @param localType The class/type in which the field resides
      * @param localField The bean field
      */
     private void registerBinding(CsvBindByPosition annotation, Class<?> localType, Field localField) {
         String fieldLocale = annotation.locale();
         String fieldWriteLocale = annotation.writeLocaleEqualsReadLocale()
                 ? fieldLocale
                 : annotation.writeLocale();
         CsvConverter converter = determineConverter(localField, localField.getType(), fieldLocale, fieldWriteLocale, null);
         fieldMap.put(annotation.position(), new BeanFieldSingleValue<>(
                 localType, localField, annotation.required(), errorLocale,
                 converter, annotation.capture(), annotation.format()));
     }
 
     /**
      * Creates a map of annotated fields in the bean to be processed.
      * <p>This method is called by {@link #loadFieldMap()} when at least one
      * relevant annotation is found on a member variable.</p>
      */
     @Override
     protected void loadAnnotatedFieldMap(ListValuedMap<Class<?>, Field> fields) {
         for (Map.Entry<Class<?>, Field> classAndField : fields.entries()) {
             Class<?> localType = classAndField.getKey();
             Field localField = classAndField.getValue();
 
             // Custom converters always have precedence.
             if (localField.isAnnotationPresent(CsvCustomBindByPosition.class)
                     || localField.isAnnotationPresent(CsvCustomBindByPositions.class)) {
                 CsvCustomBindByPosition annotation = selectAnnotationForProfile(
                         localField.getAnnotationsByType(CsvCustomBindByPosition.class),
                         CsvCustomBindByPosition::profiles);
                 if (annotation != null) {
                     registerCustomBinding(annotation, localType, localField);
                 }
             }
 
             // Then check for a collection
             else if (localField.isAnnotationPresent(CsvBindAndSplitByPosition.class)
                     || localField.isAnnotationPresent(CsvBindAndSplitByPositions.class)) {
                 CsvBindAndSplitByPosition annotation = selectAnnotationForProfile(
                         localField.getAnnotationsByType(CsvBindAndSplitByPosition.class),
                         CsvBindAndSplitByPosition::profiles);
                 if (annotation != null) {
                     registerSplitBinding(annotation, localType, localField);
                 }
             }
 
             // Then check for a multi-column annotation
             else if (localField.isAnnotationPresent(CsvBindAndJoinByPosition.class)
                     || localField.isAnnotationPresent(CsvBindAndJoinByPositions.class)) {
                 CsvBindAndJoinByPosition annotation = selectAnnotationForProfile(
                         localField.getAnnotationsByType(CsvBindAndJoinByPosition.class),
                         CsvBindAndJoinByPosition::profiles);
                 if (annotation != null) {
                     registerJoinBinding(annotation, localType, localField);
                 }
             }
 
             // Then it must be a bind by position.
             else {
                 CsvBindByPosition annotation = selectAnnotationForProfile(
                         localField.getAnnotationsByType(CsvBindByPosition.class),
                         CsvBindByPosition::profiles);
                 if (annotation != null) {
                     registerBinding(annotation, localType, localField);
                 }
             }
         }
     }
 
     @Override
     protected void loadUnadornedFieldMap(ListValuedMap<Class<?>, Field> fields) {
         for(Map.Entry<Class<?>, Field> classAndField : fields.entries()) {
             Class<?> localType = classAndField.getKey();
             Field localField = classAndField.getValue();
             CsvConverter converter = determineConverter(localField, localField.getType(), null, null, null);
             int[] indices = headerIndex.getByName(localField.getName());
             if(indices.length != 0) {
                 fieldMap.put(indices[0], new BeanFieldSingleValue<>(
                         localType, localField, false, errorLocale, converter, null, null));
             }
         }
     }
 
     /**
      * Returns a set of the annotations that are used for binding in this
      * mapping strategy.
      * <p>In this mapping strategy, those are currently:<ul>
      *     <li>{@link CsvBindByPosition}</li>
      *     <li>{@link CsvCustomBindByPosition}</li>
      *     <li>{@link CsvBindAndJoinByPosition}</li>
      *     <li>{@link CsvBindAndSplitByPosition}</li>
      * </ul></p>
      */
     @Override
     protected Set<Class<? extends Annotation>> getBindingAnnotations() {
         // With Java 9 this can be done more easily with Set.of()
         return new HashSet<>(Arrays.asList(
                 CsvBindByPositions.class,
                 CsvCustomBindByPositions.class,
                 CsvBindAndJoinByPositions.class,
                 CsvBindAndSplitByPositions.class,
                 CsvBindByPosition.class,
                 CsvCustomBindByPosition.class,
                 CsvBindAndJoinByPosition.class,
                 CsvBindAndSplitByPosition.class));
     }
 
     @Override
     protected void initializeFieldMap() {
         fieldMap = new FieldMapByPosition<>(errorLocale);
         fieldMap.setColumnOrderOnWrite(writeOrder);
     }
 
     @Override
     protected void verifyLineLength(int numberOfFields) throws CsvRequiredFieldEmptyException {
         if (!headerIndex.isEmpty()) {
             BeanField<T, Integer> f;
             StringBuilder sb = null;
             for (int i = numberOfFields; i <= headerIndex.findMaxIndex(); i++) {
                 f = findField(i);
                 if (f != null && f.isRequired()) {
                     if (sb == null) {
                         sb = new StringBuilder(ResourceBundle.getBundle(ICSVParser.DEFAULT_BUNDLE_NAME, errorLocale).getString("multiple.required.field.empty"));
                     }
                     sb.append(' ');
                     sb.append(f.getField().getName());
                 }
             }
             if (sb != null) {
                 throw new CsvRequiredFieldEmptyException(type, sb.toString());
             }
         }
     }
 
     /**
      * Returns the column position for the given column number.
      * Yes, they're the same thing. For this mapping strategy, it's a simple
      * conversion from an integer to a string.
      */
     // The rest of the Javadoc is inherited
     @Override
     public String findHeader(int col) {
         return Integer.toString(col);
     }
 
     @Override
     protected FieldMap<String, Integer, ? extends ComplexFieldMapEntry<String, Integer, T>, T> getFieldMap() {
         return fieldMap;
     }
 
     /**
      * Sets the {@link java.util.Comparator} to be used to sort columns when
      * writing beans to a CSV file.
      * Behavior of this method when used on a mapping strategy intended for
      * reading data from a CSV source is not defined.
      *
      * @param writeOrder The {@link java.util.Comparator} to use. May be
      *                   {@code null}, in which case the natural ordering is used.
      * @since 4.3
      */
     public void setColumnOrderOnWrite(Comparator<Integer> writeOrder) {
         this.writeOrder = writeOrder;
         if (fieldMap != null) {
             fieldMap.setColumnOrderOnWrite(this.writeOrder);
         }
     }
 }