import org.opensearch.common.xcontent.json.JsonXContent;
import org.opensearch.core.xcontent.XContentBuilder;
import org.opensearch.index.IndexNotFoundException;

public class SuggestSettings {
    private static final Logger logger = LogManager.getLogger(SuggestSettings.class);

    protected final String settingsId;

    protected final Client client;

    protected final String settingsIndexName;

import org.codelibs.fess.suggest.normalizer.Normalizer;
import org.codelibs.fess.suggest.settings.SuggestSettings;
import org.codelibs.fess.suggest.settings.SuggestSettingsBuilder;
import org.codelibs.fess.suggest.util.SuggestUtil;
import org.opensearch.client.Client;

public class SuggesterBuilder {

    protected SuggestSettings settings;
    protected SuggestSettingsBuilder settingsBuilder;

        });
    }

    public SuggestIndexer indexer() {
        return createDefaultIndexer();
    }

    public static SuggesterBuilder builder() {
        return new SuggesterBuilder();
    }

    // getter
    public SuggestSettings settings() {
        return suggestSettings;
    }

        final ReadingConverterChain chain = new ReadingConverterChain();
        chain.addConverter(new KatakanaToAlphabetConverter());
        return chain;
    }

    public static Normalizer createDefaultNormalizer(final Client client, final SuggestSettings settings) {
        final NormalizerChain normalizerChain = new NormalizerChain();

    protected final long totalDocNum;

    public ESSourceReader(final Client client, final SuggestSettings settings, final String indexName) {
        this.client = client;
        this.settings = settings;
        this.indexName = indexName;
        supportedFields = settings.array().get(SuggestSettings.DefaultKeys.SUPPORTED_FIELDS);
        totalDocNum = getTotal();
    }

    @Override

    protected final Client client;
    protected final AnalyzerSettings analyzerSettings;
    private final SuggestSettings settings;

    public AnalyzerNormalizer(final Client client, final SuggestSettings settings) {
        this.client = client;
        this.settings = settings;
        analyzerSettings = settings.analyzer();
    }

    @Override

            final SuggestSettings settings, final ExecutorService threadPool) {
        this.client = client;
        this.index = index;

        supportedFields = settings.array().get(SuggestSettings.DefaultKeys.SUPPORTED_FIELDS);
        badWords = settings.badword().get(true);
        tagFieldNames = settings.getAsString(SuggestSettings.DefaultKeys.TAG_FIELD_NAME, StringUtil.EMPTY).split(",");

    protected final Client client;
    private final SuggestSettings settings;
    protected final AnalyzerSettings analyzerSettings;

    protected final Transliterator transliterator = Transliterator.getInstance("Hiragana-Katakana");

    public AnalyzerConverter(final Client client, final SuggestSettings settings) {
        this.client = client;
        this.settings = settings;

        }
        try {
            suggester.settings().array().delete(SuggestSettings.DefaultKeys.SUPPORTED_FIELDS);
            split(fessConfig.getSuggestFieldIndexContents(), ",").of(stream -> stream.filter(StringUtil::isNotBlank).forEach(field -> {
                try {
                    suggester.settings().array().add(SuggestSettings.DefaultKeys.SUPPORTED_FIELDS, field);
                } catch (final SuggestSettingsException e) {

    public static final String DOC_TYPE_NAME = "_doc";

    protected final Client client;
    protected final String analyzerSettingsIndexName;
    private final SuggestSettings settings;

    protected static Map<String, Set<String>> analyzerMap = new ConcurrentHashMap<>();
    protected static Map<String, Map<String, FieldAnalyzerMapping>> fieldAnalyzerMappingMap = new ConcurrentHashMap<>();