BeanMappingFactory

package com.github.mygreen.supercsv.builder;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;

import org.supercsv.cellprocessor.ift.CellProcessor;
import org.supercsv.exception.SuperCsvReflectionException;

import com.github.mygreen.supercsv.annotation.CsvBean;
import com.github.mygreen.supercsv.annotation.CsvColumn;
import com.github.mygreen.supercsv.annotation.CsvPartial;
import com.github.mygreen.supercsv.annotation.CsvPostRead;
import com.github.mygreen.supercsv.annotation.CsvPostWrite;
import com.github.mygreen.supercsv.annotation.CsvPreRead;
import com.github.mygreen.supercsv.annotation.CsvPreWrite;
import com.github.mygreen.supercsv.annotation.DefaultGroup;
import com.github.mygreen.supercsv.annotation.conversion.CsvFixedSize;
import com.github.mygreen.supercsv.exception.SuperCsvInvalidAnnotationException;
import com.github.mygreen.supercsv.localization.MessageBuilder;
import com.github.mygreen.supercsv.validation.CsvValidator;

/**
 * BeanからCSVのマッピング情報を作成するクラス。
 *
 * @version 2.5
 * @author T.TSUCHIE
 *
 */
public class BeanMappingFactory {

    private Configurationfiguration.html#Configuration">Configuration configuration = new Configuration();

    /**
     * デフォルトコンストラクタ
     */
    public BeanMappingFactory() {

    }

    /**
     * Beanクラスから、CSVのマッピング情報を作成します。
     *
     * @param <T> Beanのタイプ
     * @param beanType 作成元のBeanクラス。
     * @param groups グループ情報。
     *              アノテーションを指定したグループで切り替える際に指定します。
     *              何も指定しない場合は、デフォルトグループの{@link DefaultGroup}のクラスが指定されたとして処理します。
     * @return CSVのマッピング情報。
     * @throws NullPointerException {@literal beanType == null.}
     * @throws SuperCsvInvalidAnnotationException アノテーションの定義が不正な場合。
     */
    public <T> BeanMapping<T> create(final Class<T> beanType, final Class<?>... groups) {

        Objects.requireNonNull(beanType);

        final BeanMapping<T> beanMapping = new BeanMapping<>(beanType);
        beanMapping.setConfiguration(configuration);

        // アノテーション @CsvBeanの取得
        final CsvBean beanAnno = beanType.getAnnotation(CsvBean.class);
        if(beanAnno == null) {
            throw new SuperCsvInvalidAnnotationException(beanAnno, MessageBuilder.create("anno.notFound")
                        .varWithClass("property", beanType)
                        .varWithAnno("anno", CsvBean.class)
                        .format());
        }

        // ヘッダーの設定情報の組み立て
        buildHeaderMapper(beanMapping, beanAnno);

        // 入力値検証の設定を組み立てます。
        buildValidators(beanMapping, beanAnno, groups);

        // アノテーション @CsvColumn を元にしたカラム情報の組み立て
        buildColumnMappingList(beanMapping, beanType, groups);

        // コールバックメソッドの設定
        buildCallbackMethods(beanMapping, beanType, beanAnno);

        return beanMapping;
    }

    /**
     * ヘッダーのマッピングの処理や設定を組み立てます。
     *
     * @param <T> Beanのタイプ
     * @param beanMapping Beanのマッピング情報
     * @param beanAnno アノテーション{@literal @CsvBean}のインタンス
     */
    protected <T> void buildHeaderMapper(final BeanMapping<T> beanMapping, final CsvBean beanAnno) {

        final HeaderMapper../com/github/mygreen/supercsv/builder/HeaderMapper.html#HeaderMapper">HeaderMapper headerMapper = (HeaderMapper) configuration.getBeanFactory().create(beanAnno.headerMapper());
        beanMapping.setHeaderMapper(headerMapper);

        beanMapping.setHeader(beanAnno.header());
        beanMapping.setValidateHeader(beanAnno.validateHeader());

    }

    /**
     * 入力値検証の設定を組み立てます。
     *
     * @param <T> Beanのタイプ
     * @param beanMapping Beanのマッピング情報
     * @param beanAnno アノテーション{@literal @CsvBean}のインタンス
     * @param groups グループ情報
     */
    @SuppressWarnings({"unchecked"})
    protected <T> void buildValidators(final BeanMapping<T> beanMapping, final CsvBean beanAnno, final Class<?>[] groups) {

        // CsvValidatorの取得
        final List<CsvValidator<T>> validators = Arrays.stream(beanAnno.validators())
                .map(v -> (CsvValidator<T>)configuration.getBeanFactory().create(v))
                .collect(Collectors.toList());
        beanMapping.addAllValidators(validators);

        beanMapping.setSkipValidationOnWrite(configuration.isSkipValidationOnWrite());
        beanMapping.setGroups(groups);

    }

    /**
     * アノテーション{@link CsvColumn}を元に、カラムのマッピング情報を組み立てる。
     *
     * @param <T> Beanのタイプ
     * @param beanMapping Beanのマッピング情報
     * @param beanType  Beanのクラスタイプ
     * @param groups グループ情報
     */
    protected <T> void buildColumnMappingList(final BeanMapping<T> beanMapping, final Class<T> beanType, final Class<?>[] groups) {

        final List<ColumnMapping> columnMappingList = new ArrayList<>();
        for(Field field : beanType.getDeclaredFields()) {

            final CsvColumn columnAnno = field.getAnnotation(CsvColumn.class);
            if(columnAnno != null) {
                columnMappingList.add(createColumnMapping(field, columnAnno, groups));
            }

        }

        // カラムの位置順の並び変えと、位置のチェック
        columnMappingList.sort(null);
        validateColumnAndSupplyPartialColumn(beanType, columnMappingList);
        beanMapping.addAllColumns(columnMappingList);

    }

    /**
     * カラム情報を組み立てる
     *
     * @param field フィールド情報
     * @param columnAnno 設定されているカラムのアノテーション
     * @param groups グループ情報
     * @return 組み立てたカラム
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    protected ColumnMapping createColumnMapping(final Field field, final CsvColumn columnAnno, final Class<?>[] groups) {

        final FieldAccessorldAccessor.html#FieldAccessor">FieldAccessor fieldAccessor = new FieldAccessor(field, configuration.getAnnoationComparator());

        final ColumnMappingumnMapping.html#ColumnMapping">ColumnMapping columnMapping = new ColumnMapping();
        columnMapping.setField(fieldAccessor);
        columnMapping.setNumber(columnAnno.number());

        if(columnAnno.label().isEmpty()) {
            columnMapping.setLabel(field.getName());
        } else {
            columnMapping.setLabel(columnAnno.label());
        }

        // ProcessorBuilderの取得
        ProcessorBuilder builder;
        if(columnAnno.builder().length == 0) {

            builder = configuration.getBuilderResolver().resolve(fieldAccessor.getType());
            if(builder == null) {
                // 不明なタイプの場合
                builder = new GeneralProcessorBuilder();
            }

        } else {
            // 直接Builderクラスが指定されている場合
            try {
                builder = (ProcessorBuilder) configuration.getBeanFactory().create(columnAnno.builder()[0]);

            } catch(Throwable e) {
                throw new SuperCsvReflectionException(
                        String.format("Fail create instance of %s with attribute 'builderClass' of @CsvColumn",
                                columnAnno.builder()[0].getCanonicalName()), e);
            }
        }

        // CellProcessorの作成
        columnMapping.setCellProcessorForReading(
                (CellProcessor)builder.buildForReading(field.getType(), fieldAccessor, configuration, groups).orElse(null));

        columnMapping.setCellProcessorForWriting(
                (CellProcessor)builder.buildForWriting(field.getType(), fieldAccessor, configuration,  groups).orElse(null));

        if(builder instanceof AbstractProcessorBuilder) {
            columnMapping.setFormatter(((AbstractProcessorBuilder)builder).getFormatter(fieldAccessor, configuration));
        }


        // 固定長の情報を取得する
        fieldAccessor.getAnnotation(CsvFixedSize.class).ifPresent(fixedAnno -> {

            FixedSizeColumnProperty fixedSizeProperty = BeanMappingFactoryHelper.createFixedSizeColumnProperty(fixedAnno, getConfiguration());
            columnMapping.setFixedSizeProperty(fixedSizeProperty);

        });

        return columnMapping;

    }

    /**
     * カラム情報の検証と、部分的に読み込む場合のカラム情報を補足する。
     * @param beanType Beanのクラスタイプ
     * @param list カラム番号の昇順に並び変えられたカラム情報。
     */
    protected void validateColumnAndSupplyPartialColumn(final Class<?> beanType, final List<ColumnMapping> list) {

        final Optional<CsvPartial> partialAnno = Optional.ofNullable(beanType.getAnnotation(CsvPartial.class));

        if(list.isEmpty()) {
            throw new SuperCsvInvalidAnnotationException(MessageBuilder.create("anno.notFound")
                    .varWithClass("property", beanType)
                    .varWithAnno("anno", CsvColumn.class)
                    .format());
        }

        // 番号の重複などのチェック
        BeanMappingFactoryHelper.validateDuplicatedColumnNumber(beanType, list);

        // 不足している番号のカラムを補完する。
        BeanMappingFactoryHelper.supplyLackedNumberMappingColumn(beanType, list, partialAnno, new String[0], getConfiguration());

    }

    /**
     * 部分的なカラムの場合の作成
     * @param columnNumber 列番号
     * @param partialAnno アノテーション {@literal @CsvPartial}のインスタンス
     * @return
     */
    protected ColumnMapping createPartialColumnMapping(int columnNumber, final Optional<CsvPartial> partialAnno) {

        final ColumnMappingumnMapping.html#ColumnMapping">ColumnMapping columnMapping = new ColumnMapping();
        columnMapping.setNumber(columnNumber);
        columnMapping.setPartialized(true);

        String label = String.format("column%d", columnNumber);
        if(partialAnno.isPresent()) {
            for(CsvPartial.Header header : partialAnno.get().headers()) {
                if(header.number() == columnNumber) {
                    label = header.label();
                }
            }
        }
        columnMapping.setLabel(label);

        return columnMapping;

    }

    /**
     * コールバック用メソッドの設定を組み立てます。
     *
     * @param <T> Beanのタイプ
     * @param beanMapping Beanのマッピング情報
     * @param beanType Beanのクラスタイプ
     * @param beanAnno {@literal CsvBean}のアノテーションのインスタンス
     */
    protected <T> void buildCallbackMethods(final BeanMapping<T> beanMapping, final Class<T> beanType, final CsvBean beanAnno) {

        // コールバック用のメソッドの取得
        for(Method method : beanType.getDeclaredMethods()) {

            if(method.getAnnotation(CsvPreRead.class) != null) {
                beanMapping.addPreReadMethod(new CallbackMethod(method));
            }

            if(method.getAnnotation(CsvPostRead.class) != null) {
                beanMapping.addPostReadMethod(new CallbackMethod(method));
            }

            if(method.getAnnotation(CsvPreWrite.class) != null) {
                beanMapping.addPreWriteMethod(new CallbackMethod(method));
            }

            if(method.getAnnotation(CsvPostWrite.class) != null) {
                beanMapping.addPostWriteMethod(new CallbackMethod(method));
            }
        }

        // リスナークラスの取得
        final List<Object> listeners = Arrays.stream(beanAnno.listeners())
                .map(l -> configuration.getBeanFactory().create(l))
                .collect(Collectors.toList());
        beanMapping.addAllListeners(listeners);

        for(Object listener : listeners) {
            for(Method method : listener.getClass().getDeclaredMethods()) {
                if(method.getAnnotation(CsvPreRead.class) != null) {
                    beanMapping.addPreReadMethod(new ListenerCallbackMethod(listener, method));
                }

                if(method.getAnnotation(CsvPostRead.class) != null) {
                    beanMapping.addPostReadMethod(new ListenerCallbackMethod(listener, method));
                }

                if(method.getAnnotation(CsvPreWrite.class) != null) {
                    beanMapping.addPreWriteMethod(new ListenerCallbackMethod(listener, method));
                }

                if(method.getAnnotation(CsvPostWrite.class) != null) {
                    beanMapping.addPostWriteMethod(new ListenerCallbackMethod(listener, method));
                }
            }
        }

        beanMapping.getPreReadMethods().sort(null);
        beanMapping.getPostReadMethods().sort(null);
        beanMapping.getPreWriteMethods().sort(null);
        beanMapping.getPostWriteMethods().sort(null);

    }

    /**
     * システム情報を取得します。
     * @return 既存のシステム情報を変更する際に取得します。
     */
    public Configuration getConfiguration() {
        return configuration;
    }

    /**
     * システム情報を取得します。
     * @param configuraton 新しくシステム情報を変更する際に設定します。
     */
    public void setConfiguration(Configuration configuraton) {
        this.configuration = configuraton;
    }

}