package com.idss.vulsync.config;

import cn.hutool.core.collection.ListUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author: zc
 * @Date: 2021/11/19 14:06
 */
@Configuration
@Slf4j
public class ElasticSearchConfig {
    private List<HttpHost> httpHosts = new ArrayList<>();
    /**
     * elk集群地址
     */
    @Value("${spring.data.elasticsearch.cluster-hosts}")
    private String hostName;



    /**
     * 用户
     */
    @Value("${spring.data.elasticsearch.userName}")
    private String username;

    /**
     * 密码
     */
    @Value("${spring.data.elasticsearch.password}")
    private String password;

//    /**
//     * 连接池
//     */
//    @Value("${elasticsearch.pool}")
//    private String poolSize;

    public static final RequestOptions COMMON_OPTIONS;
    static {
        RequestOptions.Builder builder=RequestOptions.DEFAULT.toBuilder();
        COMMON_OPTIONS=builder.build();
    }

    /**
     * 防止netty的bug
     * java.lang.IllegalStateException: availableProcessors is already set to [4], rejecting [4]
     */
    @PostConstruct
    void init() {
        System.setProperty("es.set.netty.runtime.available.processors", "false");
    }

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        String[] hosts = hostName.split(",");
        for (String host : hosts) {
            String[] hostStr = host.split(":");
            httpHosts.add(new HttpHost(hostStr[0], Integer.parseInt(hostStr[1]), "http"));
        }
        RestClientBuilder builder = RestClient.builder(httpHosts.toArray(new HttpHost[0]));
        RestHighLevelClient restHighLevelClient=getRestHighLevelClient(builder);
        return restHighLevelClient;
    }

    /**
     * get restHistLevelClient
     *
     * @return
     */
    private RestHighLevelClient getRestHighLevelClient(RestClientBuilder builder) {
        // Callback used the default {@link RequestConfig} being set to the {@link CloseableHttpClient}
        builder.setRequestConfigCallback(requestConfigBuilder -> {
            requestConfigBuilder.setConnectTimeout(1000);
            requestConfigBuilder.setSocketTimeout(30000);
            requestConfigBuilder.setConnectionRequestTimeout(500);
            return requestConfigBuilder;
        });
        // Callback used to customize the {@link CloseableHttpClient} instance used by a {@link RestClient} instance.
        builder.setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.setMaxConnTotal(30);
            httpClientBuilder.setMaxConnPerRoute(10);
            // Callback used the basic credential auth
            if (!StringUtils.isEmpty(username) && !StringUtils.isEmpty(password)) {
                final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
                credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
                httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            }
            return httpClientBuilder;
        });

        return new RestHighLevelClient(builder);
    }

}