package com.mzl.flower.utils;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.*;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Slf4j
public class HttpUtil {

    public static JSONArray doRequestReturnArray(String method, String url, String requestType, Map<String, Object> paramHeader
            , Map<String, Object> paramQuery, Map<String, Object> paramBody, Map<String, Object> paramInput) throws Exception {
        JSONArray result = null;
        HttpRequestBase request = getRequest(method, url, requestType, paramHeader, paramQuery, paramBody, paramInput);

        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpResponse response = httpclient.execute(request);
        String r = handleResponse(response);
        log.info("Http Service Task Result: " + r);
        String[] results = r.split(":", 2);
        if (StrUtil.equals(results[0], String.valueOf(HttpStatus.SC_OK))) {
            String data = results[1];
            if (StrUtil.isNotBlank(data)) {
                result = JSON.parseArray(data);
            }
        }
        httpclient.close();

        return result;
    }

    private static HttpRequestBase getRequest(String method, String url, String requestType, Map<String, Object> paramHeader
            , Map<String, Object> paramQuery, Map<String, Object> paramBody, Map<String, Object> paramInput) throws Exception {
        HttpRequestBase request = null;
        switch (method) {
            case HttpGet.METHOD_NAME:
                request = generateHttpGet(url, paramHeader, paramQuery, paramInput);
                break;
            case HttpPost.METHOD_NAME:
                request = generateHttpPost(url, requestType, paramHeader, paramQuery, paramBody, paramInput);
                break;
            case HttpPut.METHOD_NAME:
                request = generateHttpPut(url, requestType, paramHeader, paramQuery, paramBody, paramInput);
                break;
            case HttpDelete.METHOD_NAME:
                request = generateHttpDelete(url, paramHeader, paramQuery, paramInput);
                break;
            case HttpPatch.METHOD_NAME:
                break;
            default:
                throw new Exception(method + " HTTP method not supported");
        }

        return request;
    }

    public static JSONObject doRequest(String method, String url, String requestType, Map<String, Object> paramHeader
            , Map<String, Object> paramQuery, Map<String, Object> paramBody, Map<String, Object> paramInput) throws Exception {
        JSONObject result = null;
        HttpRequestBase request = getRequest(method, url, requestType, paramHeader, paramQuery, paramBody, paramInput);

        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpResponse response = httpclient.execute(request);
        String r = handleResponse(response);
        log.info("Http Service Task Result: " + r);
        String[] results = r.split(":", 2);
        if (StrUtil.equals(results[0], String.valueOf(HttpStatus.SC_OK))) {
            String data = results[1];
            if (StrUtil.isNotBlank(data)) {
                result = JSON.parseObject(data);
            }
        }
        httpclient.close();

        return result;
    }

    public static String doRequestReturnString(String method, String url, String requestType, Map<String, Object> paramHeader
            , Map<String, Object> paramQuery, Map<String, Object> paramBody, Map<String, Object> paramInput) throws Exception {
        HttpRequestBase request = getRequest(method, url, requestType, paramHeader, paramQuery, paramBody, paramInput);

        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpResponse response = httpclient.execute(request);
        String r = handleResponse(response);
        log.info("Http Service Task Result: " + r);
        String[] results = r.split(":", 2);
        if (StrUtil.equals(results[0], String.valueOf(HttpStatus.SC_OK))) {
            String data = results[1];
            if (StrUtil.isNotBlank(data)) {
                return data;
            }
        }
        httpclient.close();

        return "";
    }

    @SneakyThrows
    private static HttpGet generateHttpGet(String url, Map<String, Object> requestHeaders, Map<String, Object> requestQueries,
                                    Map<String, Object> requestInputParams) {
        HttpGet get = new HttpGet();

        for (Map.Entry<String, Object> entry : requestHeaders.entrySet()) {
            if (entry.getValue() instanceof String) {
                get.addHeader(entry.getKey(), (String) entry.getValue());
            }
        }

        URIBuilder uriBuilder = new URIBuilder(url);
        for (Map.Entry<String, Object> entry : requestQueries.entrySet()) {
            if (entry.getValue() instanceof String) {
                uriBuilder.setParameter(entry.getKey(), (String) entry.getValue());
            }
        }
        for (Map.Entry<String, Object> entry : requestInputParams.entrySet()) {
            if (entry.getValue() instanceof String) {
                uriBuilder.setParameter(entry.getKey(), (String) entry.getValue());
            }
        }
        URI uri = uriBuilder.build();
        get.setURI(uri);
        return get;
    }

    @SneakyThrows
    private static HttpPost generateHttpPost(String url, String requestType,
                                      Map<String, Object> requestHeaders, Map<String, Object> requestQueries,
                                      Map<String, Object> requestBodies, Map<String, Object> requestInputParams) {
        HttpPost post = new HttpPost();

        for (Map.Entry<String, Object> entry : requestHeaders.entrySet()) {
            if (entry.getValue() instanceof String) {
                post.addHeader(entry.getKey(), (String) entry.getValue());
            }
        }

        URIBuilder uriBuilder = new URIBuilder(url);
        if(requestQueries!=null){
            for (Map.Entry<String, Object> entry : requestQueries.entrySet()) {
                if (entry.getValue() instanceof String) {
                    uriBuilder.setParameter(entry.getKey(), (String) entry.getValue());
                }
            }
        }

        requestInputParams.putAll(requestBodies);
        if (StrUtil.equals("json", requestType)) {
            String inputParam = JSON.toJSONString(requestInputParams);
            log.info("Post param: " + inputParam);
            post.setEntity(new StringEntity(inputParam, "UTF-8"));
        }

        if (StrUtil.equals("form", requestType)) {
            List<BasicNameValuePair> pair = new ArrayList<>();
            for (Map.Entry<String, Object> entry : requestInputParams.entrySet()) {
                if (entry.getValue() instanceof String) {
                    pair.add(new BasicNameValuePair(entry.getKey(), (String) entry.getValue()));
                }
            }
            post.setEntity(new UrlEncodedFormEntity(pair));
        }

        URI uri = uriBuilder.build();
        post.setURI(uri);
        return post;
    }

    @SneakyThrows
    private static HttpPut generateHttpPut(String url, String requestType,
                                    Map<String, Object> requestHeaders, Map<String, Object> requestQueries,
                                    Map<String, Object> requestBodies, Map<String, Object> requestInputParams) {
        HttpPut put = new HttpPut();

        for (Map.Entry<String, Object> entry : requestHeaders.entrySet()) {
            if (entry.getValue() instanceof String) {
                put.addHeader(entry.getKey(), (String) entry.getValue());
            }
        }

        URIBuilder uriBuilder = new URIBuilder(url);
        for (Map.Entry<String, Object> entry : requestQueries.entrySet()) {
            if (entry.getValue() instanceof String) {
                uriBuilder.setParameter(entry.getKey(), (String) entry.getValue());
            }
        }

        requestInputParams.putAll(requestBodies);
        if (StrUtil.equals("json", requestType)) {
            String inputParam = JSON.toJSONString(requestInputParams);
            log.info("Post param: " + inputParam);
            put.setEntity(new StringEntity(inputParam, "UTF-8"));
        }

        if (StrUtil.equals("form", requestType)) {
            List<BasicNameValuePair> pair = new ArrayList<>();
            for (Map.Entry<String, Object> entry : requestInputParams.entrySet()) {
                if (entry.getValue() instanceof String) {
                    pair.add(new BasicNameValuePair(entry.getKey(), (String) entry.getValue()));
                }
            }
            put.setEntity(new UrlEncodedFormEntity(pair));
        }

        URI uri = uriBuilder.build();
        put.setURI(uri);
        return put;
    }

    @SneakyThrows
    private static HttpDelete generateHttpDelete(String url, Map<String, Object> requestHeaders, Map<String, Object> requestQueries,
                                          Map<String, Object> requestInputParams) {
        HttpDelete delete = new HttpDelete();

        for (Map.Entry<String, Object> entry : requestHeaders.entrySet()) {
            if (entry.getValue() instanceof String) {
                delete.addHeader(entry.getKey(), (String) entry.getValue());
            }
        }

        URIBuilder uriBuilder = new URIBuilder(url);
        for (Map.Entry<String, Object> entry : requestQueries.entrySet()) {
            if (entry.getValue() instanceof String) {
                uriBuilder.setParameter(entry.getKey(), (String) entry.getValue());
            }
        }
        for (Map.Entry<String, Object> entry : requestInputParams.entrySet()) {
            if (entry.getValue() instanceof String) {
                uriBuilder.setParameter(entry.getKey(), (String) entry.getValue());
            }
        }
        URI uri = uriBuilder.build();
        delete.setURI(uri);
        return delete;
    }

    private static String handleResponse(HttpResponse response) throws IOException {
        final StatusLine statusLine = response.getStatusLine();
        final HttpEntity entity = response.getEntity();
        if (statusLine.getStatusCode() != HttpStatus.SC_OK) {
            EntityUtils.consume(entity);
            return StrUtil.format("{}:{}", statusLine.getStatusCode(), statusLine.getReasonPhrase());
        }
        return StrUtil.format("{}:{}", statusLine.getStatusCode(),
                entity == null ? null : EntityUtils.toString(entity, Consts.UTF_8));
    }

    public static JSONObject processHttp(HttpUriRequest request) {
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        CloseableHttpResponse response = null;

        String result = "";
        try {
            // 由客户端执行请求
            response = httpClient.execute(request);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            StatusLine statusLine = response.getStatusLine();
            log.info("响应状态为:" + statusLine);
            if (statusLine.getStatusCode() == 200 && responseEntity != null) {
                result = EntityUtils.toString(responseEntity);
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            try {
                // 释放资源
                if (httpClient != null) {
                    httpClient.close();
                }
                if (response != null) {
                    response.close();
                }
            } catch (Exception e) {
                log.error(e.getMessage(), e);
            }
        }
        log.info("==============> response: " + result);
        if(StringUtils.isNotEmpty(result)){
            return JSON.parseObject(result);
        }

        return null;
    }
}