package com.walker.web;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;

public class TestHttpConcurrency {

    protected final transient Logger logger = LoggerFactory.getLogger(getClass());

//    @Test
    public void testIsPay(){
        RestTemplateConfig config = new RestTemplateConfig();
        config.setKeepAliveDurationSeconds(300);
        config.setMaxIdleConnections(200);
        config.setConnectTimeoutSeconds(2);
        config.setReadTimeoutSeconds(3);
        config.setWriteTimeoutSeconds(3);

        int total = 1200;
        RestTemplate restTemplate = RestTemplateFactory.createRestTemplate(RestTemplateFactory.HttpType.OkHttp, config);
        ExecutorService executorService = Executors.newFixedThreadPool(total/2);

        List<TaskCall> taskCallList = new ArrayList<>(total);
        for(int i=0; i<total; i++){
            taskCallList.add(new TaskCall(restTemplate,i));
        }

        List<Future<Boolean>> result = null;
        long startTime = System.nanoTime();
        try {
            // 并发执行一批任务，阻塞等着所有的任务执行完毕
            result = executorService.invokeAll(taskCallList);
        } catch (InterruptedException e) {
            logger.error("线程池执行中断：" + e.getMessage());
            throw new RuntimeException(e);
        }
        AtomicInteger failedCount = new AtomicInteger(0);
        if(result != null){
            for(Future<Boolean> f : result){
                try {
                    if(!f.get()){
                        failedCount.addAndGet(1);
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (ExecutionException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        logger.info("调用失败：{}", failedCount.get());
        logger.info("线程池调用完成，共执行任务：{}，花费时间：{} 毫秒", total, (System.nanoTime() - startTime)/1000000);

        //执行完毕就关闭线程池(这个是还会等着任务执行完才真正关闭)
        executorService.shutdown();


//        for(int i=0; i<total; i++){
//            executorService.execute(new Runnable() {
//                @Override
//                public void run() {
//                    final int j = 0;
//                    boolean success = doInvokeOnce(restTemplate, j);
//                }
//            });
//        }
//        WaitConsoleInput.waitInput();
        logger.info("----------- end -------------");
    }

    private boolean doInvokeOnce(RestTemplate restTemplate, int i){
        try{
            ResponseEntity response = restTemplate.getForEntity(URL, Map.class);
//        logger.info("data = " + response.getBody());
            return true;
        } catch (Exception ex){
            logger.error("i={}",i);
            return false;
        }
    }

//    private static final String URL = "https://jmy.jinmingyuan.com/train/api/base-server/base/login/isPay";
//    private static final String URL = "http://116.198.40.76/train/api/base-server/base/login/isPay";
    private static final String URL = "http://116.198.40.76/pxzx/train/config/pay";

    private class TaskCall implements Callable<Boolean>{
        private RestTemplate restTemplate;
        private int i;
        public TaskCall(RestTemplate restTemplate, int i){
            this.restTemplate = restTemplate;
            this.i = i;
        }
        @Override
        public Boolean call() throws Exception {
            return doInvokeOnce(restTemplate, i);
        }
    }
//    private RestTemplate acquireRestTemplate(){
//        return RestTemplateBuilder
//                //单位s, 设置连接时间，避免线程过多被阻塞挂起
//                .setConnectTimeout(Duration.ofSeconds(1))
//                .setReadTimeout(Duration.ofSeconds(1))
//                .additionalMessageConverters(new MyMappingJackson2HttpMessageConverter())
//                .requestFactory(() -> {
//                    HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory();
//                    // 连接池
//                    HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
//                    //设置HTTP连接管理器
//                    PoolingHttpClientConnectionManager poolingConnectionManager = new PoolingHttpClientConnectionManager();
//                    poolingConnectionManager.setMaxTotal(500); // 连接池最大连接数
//                    poolingConnectionManager.setDefaultMaxPerRoute(200); // 每个主机的并发
//                    httpClientBuilder.setConnectionManager(poolingConnectionManager);
//                    // 设置 RequestConfig 连接池请求全局配置
//                    // 连接池超时时间 3500ms
//                    RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(3500).build();
//                    httpClientBuilder.setDefaultRequestConfig(requestConfig);
//                    // 设置连接池
//                    clientHttpRequestFactory.setHttpClient(httpClientBuilder.build());
//                    return clientHttpRequestFactory;
//                })
//                .build();
//    }
}