/**
 * Copyright 2017 ZTE Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.onap.workflow.common;

import java.io.IOException;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.onap.workflow.externalservice.entity.activitientitiy.ActivitiStartProcessRequest;
import org.onap.workflow.tools.Constants;
import org.onap.workflow.tools.HttpDeleteWithBody;
import org.onap.workflow.tools.RequestParameters;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.gson.Gson;

public class RestClient {
  private static final String HTTP = "http";
  private static final Logger logger = LoggerFactory.getLogger(RestClient.class);

  private static boolean isTest = false;

  public enum HttpMethod {
    GET, POST, PUT, DELETE
  }

  /**
   * 
   * @param method
   * @param ip
   * @param port
   * @param url
   * @param body
   * @return
   * @throws ClientProtocolException
   * @throws IOException
   */
  public static RestResponse executeHttp(HttpMethod method, String ip, Integer port, String url,
      HttpEntity body) throws IOException {
    if (isTest) {
      return new RestResponse();
    }

    logger.info("deployfile method send");
    CloseableHttpClient httpclient = HttpClients.createDefault();
    HttpResponse httpResponse = null;
    RestResponse result = new RestResponse();
    try {
      if (ip == null) {
        ip = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrIp();
      }
      if (port == null) {
        port = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrPort();
      }
      HttpHost target = new HttpHost(ip, port, HTTP);
      HttpRequest request = getRequest(method, url, body);
      logger.info("deployfile method send ip" + ip);
      if(null != request)
	request.addHeader(Constants.AUTHORIZATION, ToolUtil.getHeader());

      httpResponse = httpclient.execute(target, request);
      HttpEntity entity = httpResponse.getEntity();
      logger.info("deployfile method send");
      if (entity != null && httpResponse.getStatusLine() != null) {
        result.setStatusCode(httpResponse.getStatusLine().getStatusCode());
        logger.info("reply status code deploy" + httpResponse.getStatusLine().getStatusCode());
        result.setResult(EntityUtils.toString(entity));
      }
    } catch (IOException e) {
      logger.warn("Close httpclient failed.", e);
    } finally {
      closeHttpClient(httpclient);
    }
    return result;
  }

  public static boolean closeHttpClient(CloseableHttpClient httpclient) {
    if (httpclient != null) {
      try {
        httpclient.close();
        return true;
      } catch (IOException e) {
        logger.warn("Close httpclient failed.", e);
        return false;
      }
    }
    return true;
  }

  public static HttpRequest getRequest(HttpMethod method, String url, HttpEntity body) {
    HttpRequest request = null;
    switch (method) {
      case GET:
        request = new HttpGet(url);
        break;
      case POST:
        request = new HttpPost(url);
        ((HttpPost) request).setEntity(body);
        break;
      case PUT:
        request = new HttpPut(url);
        ((HttpPut) request).setEntity(body);
        break;
      case DELETE:
        request = new HttpDelete(url);
        break;
      default:
        break;
    }
    return request;
  }

  /**
   * 
   * @param ip
   * @param port
   * @param url
   * @param requestBody
   * @return
   * @throws ClientProtocolException
   * @throws IOException
   */
  public static RestResponse post(String ip, int port, String url, HttpEntity requestBody)
      throws IOException {
    return executeHttp(HttpMethod.POST, ip, port, url, requestBody);
  }



  /**
   * 
   * @param method
   * @param ip
   * @param port
   * @param url
   * @param body
   * @return
   * @throws ClientProtocolException
   * @throws IOException
   */
  public static RestResponse executeHttpDeleteDeploy(HttpMethod method, String ip, Integer port,
      String url) throws IOException {
    if (isTest) {
      return new RestResponse();
    }
    if (ip == null) {
      ip = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrIp();
    }
    if (port == null) {
      port = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrPort();
    }
    RestResponse result = new RestResponse();
    try(CloseableHttpClient httpClient = HttpClients.createDefault()){
      // "http://localhost:8080/activiti-rest/service/repository/deployments/167501"
    /*  String deleteUrl =
          Constants.HTTP_HEADER + ip + Constants.COLON + port + url + "?cascade=true";*/
      String deleteUrl = Constants.HTTP_HEADER + ip + Constants.COLON + port + url + "?cascade=true";
      HttpDeleteWithBody httpDeteTest = new HttpDeleteWithBody(deleteUrl);
      Gson gson = new Gson();
      RequestParameters reqPa = new RequestParameters();
      reqPa.setCasCade(true);
      String jsonStr = gson.toJson(reqPa, RequestParameters.class);
      StringEntity requestEntity = new StringEntity(jsonStr, "UTF-8");
      requestEntity.setContentEncoding("UTF-8");
      httpDeteTest.setHeader("Content-type", "application/json");
      httpDeteTest.setHeader(Constants.AUTHORIZATION, ToolUtil.getHeader());
      httpDeteTest.setEntity(new StringEntity(jsonStr));
      // returnValue = httpClient.execute(httpDeteTest, responseHandler); // 调接口获取返回值时，必须用此方法
      CloseableHttpResponse httpResonse = httpClient.execute(httpDeteTest);
      if (httpResonse != null && httpResonse.getStatusLine() != null) {
        int statusCode = httpResonse.getStatusLine().getStatusCode();
        result.setStatusCode(statusCode);
      }
      // result.setResult(EntityUtils.toString(httpResonse.getEntity()));
    } catch (Exception e) {
	logger.error("executeHttpDeleteDeploy ",e);
    } 
    return result;
  }

  /**
   * 
   * @param method
   * @param ip
   * @param port
   * @param url
   * @param body
   * @return
   * @throws ClientProtocolException
   * @throws IOException
   */
  public static RestResponse executeHttpStartIntance(HttpMethod method, String ip, Integer port,
      String url, ActivitiStartProcessRequest object) throws IOException {
    if (isTest) {
      return new RestResponse();
    }
    String returnValue = "";
    RestResponse result = new RestResponse();
    ResponseHandler<String> responseHandler = new BasicResponseHandler();
    try (
      CloseableHttpClient httpClient = HttpClients.createDefault()){
      if (ip == null) {
        ip = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrIp();
      }
      if (port == null) {
        port = Config.getWorkflowAppConfig().getMsbClientConfig().getMsbSvrPort();
      }
      HttpPost httpPost = new HttpPost(Constants.HTTP_HEADER + ip + ":" + port + url);
      Gson gson = new Gson();
      String jsonStr = gson.toJson(object, ActivitiStartProcessRequest.class);
      StringEntity requestEntity = new StringEntity(jsonStr, "utf-8");
      requestEntity.setContentEncoding("UTF-8");
      httpPost.setHeader("Content-type", "application/json");
      httpPost.setHeader(Constants.AUTHORIZATION, ToolUtil.getHeader());
      httpPost.setEntity(requestEntity);
//      returnValue = httpClient.execute(httpPost, responseHandler); // 调接口获取返回值时，必须用此方法
      CloseableHttpResponse httpResonse = httpClient.execute(httpPost);
      if (httpResonse != null && httpResonse.getStatusLine() != null) {
        int statusCode = httpResonse.getStatusLine().getStatusCode();
        returnValue = EntityUtils.toString(httpResonse.getEntity(), "UTF-8");
        result.setStatusCode(statusCode);
        result.setResult(returnValue);
      }
    } catch (Exception e) {
	logger.error("executeHttpStartIntance :",e);
    }
    

    return result;
  }

  /**
   * 
   * @param ip
   * @param port
   * @param url
   * @param requestBody
   * @return
   * @throws ClientProtocolException
   * @throws IOException
   */
  public static RestResponse post(String ip, Integer port, String url,
      ActivitiStartProcessRequest requestBody) throws IOException {
    return executeHttpStartIntance(HttpMethod.POST, ip, port, url, requestBody);
  }

  /**
   * 
   * @param ip
   * @param port
   * @param url
   * @param requestBody
   * @return
   * @throws ClientProtocolException
   * @throws IOException
   */
  public static RestResponse post(String ip, Integer port, String url)
      throws IOException {
    return executeHttpDeleteDeploy(HttpMethod.DELETE, ip, port, url);
  }

  public static boolean getIsTest(){
	return isTest;
  }

  public static void setIsTest(boolean arg){
	isTest = arg;
  }

}