package main.java;
import com.grapecity.documents.excel.DataImportOptions;
import com.grapecity.documents.excel.InsufficientSpaceHandling;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;

public class DataImportOptionsBuilder {
    private final List<Function<Object, Object>> _columnsSelectors = new ArrayList<>();
    private boolean _includeColumnsHeader = true;
    private InsufficientSpaceHandling _insufficientSpaceHandling = null;
    private final List<Function<Object, Class<?>>> _itemTypeProviders = new ArrayList<>();

    public <TObject> DataImportOptionsBuilder hasColumnsSelector(
            Class<TObject> canon,
            Consumer<ObjectColumnSelectorBuilder<TObject>> configureSelector) {
        ObjectColumnSelectorBuilder<TObject> builder = new ObjectColumnSelectorBuilder<>(canon);
        configureSelector.accept(builder);
        // The return type is covariant, so it's safe to cast Object[] to Object.
        _columnsSelectors.add((Function<Object, Object>) (Object) builder.build());
        return this;
    }

    public DataImportOptionsBuilder hasColumnsSelector(Function<Object, Boolean> collectionCheck, int... indexes) {
        _columnsSelectors.add(items -> collectionCheck.apply(items) ? indexes : null);
        return this;
    }

    public DataImportOptionsBuilder hasColumnsSelector(Function<Object, Boolean> collectionCheck, String... indexes) {
        _columnsSelectors.add(items -> collectionCheck.apply(items) ? indexes : null);
        return this;
    }

    public DataImportOptionsBuilder excludeColumnsHeader() {
        _includeColumnsHeader = false;
        return this;
    }

    public DataImportOptionsBuilder onInsufficientSpace(InsufficientSpaceHandling handling) {
        _insufficientSpaceHandling = handling;
        return this;
    }

    public DataImportOptionsBuilder hasItemTypeProvider(Consumer<ItemTypeProviderBuilder> configureProvider) {
        ItemTypeProviderBuilder builder = new ItemTypeProviderBuilder();
        configureProvider.accept(builder);
        _itemTypeProviders.add(builder.build());
        return this;
    }

    public DataImportOptions build() {
        DataImportOptions options = new DataImportOptions();

        if (!_columnsSelectors.isEmpty()) {
            options.setColumnsSelector(obj -> _columnsSelectors.stream()
                    .map(selector -> selector.apply(obj))
                    .filter(Objects::nonNull)
                    .findFirst()
                    .orElse(null));
        } else {
            options.setColumnsSelector(null);
        }

        options.setIncludeColumnsHeader(_includeColumnsHeader);
        options.setInsufficientSpaceHandling(_insufficientSpaceHandling);

        if (!_itemTypeProviders.isEmpty()) {
            options.setItemTypeProvider(obj -> _itemTypeProviders.stream()
                    .map(provider -> provider.apply(obj))
                    .filter(Objects::nonNull)
                    .findFirst()
                    .orElse(null));
        } else {
            options.setItemTypeProvider(null);
        }

        return options;
    }
}