package com.zbooksoft.gdmis.config;

import com.ruili.wcp.common.CustomConfigUtil;
import com.ruili.wcp.configsettting.SystemConfig;
import com.ruili.wcp.web.common.LicenseException;
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.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.util.ObjectUtils;

import javax.annotation.PostConstruct;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @Description ES客户端配置
 * @Author fsr
 * @Date 2021/12/20
 **/
@Configuration
@DependsOn(value = {"customConfigUtil"}) // 声明一下并不一定生效
public class RestHighLevelConfig {

    private String host = "127.0.0.1";
    private Integer port = 9200;

    private static final String PROTOCOL = "http"; // 协议
    private static final int CONNECT_TIME_OUT = 1000; // http连接超时 毫秒
    private static final int SOCKET_TIME_OUT = 6000; // sock超时
    private static final int CONNECTION_REQUEST_TIME_OUT = 5000; // 请求超时

    private static final int MAX_CONNECT_NUM = 50;
    private static final int MAX_CONNECT_PER_ROUTE = 50;


    @Autowired
    private CustomConfigUtil customConfigUtil;

    public static void main(String[] args) throws IOException {
        Class<CustomConfigUtil> customConfigUtilClass = CustomConfigUtil.class;
        Class<? extends ClassLoader> aClass = customConfigUtilClass.getClassLoader().getClass();
        InputStream resourceAsStream = aClass.getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        properties.load(resourceAsStream);
        properties.get("jdbc.driver");
        properties.get("jdbc.url");
        properties.get("jdbc.username");
        Object password = properties.get("jdbc.password");
        System.out.println(password);
    }

    private RestHighLevelClient restHighLevelClient;

    @PostConstruct
    public void init() throws LicenseException {
        SystemConfig systemConfig = this.customConfigUtil.getConfigObj(SystemConfig.class);
        if (systemConfig == null) {
            systemConfig = new SystemConfig();
            customConfigUtil.setConfigObj(systemConfig);
        }
        String esHost = systemConfig.getElasticSearchServerHost();
        if (!ObjectUtils.isEmpty(esHost)) {
            this.host = esHost;
        }
        String esPort = systemConfig.getElasticSearchServerPort();
        if (!ObjectUtils.isEmpty(esPort)) {
            this.port = Integer.valueOf(esPort);
        }
        // 设置访问参数
        HttpHost httpHost = new HttpHost(this.host, this.port, PROTOCOL);
        RestClientBuilder clientBuilder = RestClient.builder(httpHost);

        //判断是否要用户密码验证
        if (systemConfig.getElasticSearchRequiresAuthentication()) {
            String esUserName = systemConfig.getElasticSearchUserName();
            String esPassword = systemConfig.getElasticSearchPassword();

            CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
            credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(esUserName, esPassword));
            clientBuilder.setHttpClientConfigCallback(f -> {
                f.setDefaultCredentialsProvider(credentialsProvider)
                        .setMaxConnTotal(MAX_CONNECT_NUM)
                        .setMaxConnPerRoute(MAX_CONNECT_PER_ROUTE);
                f.disableConnectionState();
                return f;
            });
        } else {
            // http连接池设置
            clientBuilder.setHttpClientConfigCallback(builder -> {
                builder.setMaxConnTotal(MAX_CONNECT_NUM).setMaxConnPerRoute(MAX_CONNECT_PER_ROUTE);
                builder.disableConnectionState();
                return builder;
            });
        }

        // 超时设置
        clientBuilder.setRequestConfigCallback(builder -> {
            builder.setConnectTimeout(CONNECT_TIME_OUT)
                    .setSocketTimeout(SOCKET_TIME_OUT)
                    .setConnectionRequestTimeout(CONNECTION_REQUEST_TIME_OUT);
            return builder;
        });

        restHighLevelClient = new RestHighLevelClient(clientBuilder);
    }

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        return restHighLevelClient;
    }

}