package cat.gencat.salut.forms.service.rest.impl;

import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;

import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.ssl.TrustStrategy;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.http.HttpEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.client.support.BasicAuthorizationInterceptor;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import cat.gencat.salut.forms.dto.RESTRequest;
import cat.gencat.salut.forms.service.rest.RESTClientService;

@Service("restService")
@Transactional("txManager")
public class RESTClientServiceImpl implements RESTClientService {

    private static final Logger log = LogManager.getLogger(RESTClientServiceImpl.class);

    public <T> ResponseEntity<?> jsonSecuredRequest(RESTRequest<T> requestInfo) {
        MultiValueMap<String, String> headers = jsonHeaders();
        return securedRestRequest(requestInfo, headers);
    }

    @Override
    public <T> ResponseEntity<?> xmlSecuredRequest(RESTRequest<T> requestInfo) {
        MultiValueMap<String, String> headers = xmlHeaders();
        return securedRestRequest(requestInfo, headers);
    }

    @Override
    public <T> ResponseEntity<?> octetStreamSecuredRequest(RESTRequest<T> requestInfo) {
        MultiValueMap<String, String> headers = octetStreamHeaders();
        return securedRestRequest(requestInfo, headers);
    }

    private <T> ResponseEntity<?> securedRestRequest(RESTRequest<T> requestInfo, MultiValueMap<String, String> headers) {
        String user = requestInfo.getBasicAuthentication()==null?null:requestInfo.getBasicAuthentication().get("user");
        String password = requestInfo.getBasicAuthentication()==null?null:requestInfo.getBasicAuthentication().get("password");

        SSLContext sslContext = null;
        try {
            sslContext = org.apache.http.ssl.SSLContexts.custom().loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] chain, String authType) {
                    return true;
                }
            }).build();
        } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException e) {
            log.error("Error al generar el SSLContext", e);
        }
        SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, new NoopHostnameVerifier());
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build();
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);

        RestTemplate template = new RestTemplate(requestFactory);
        if(user!=null && password!=null){
            template.getInterceptors().add(new BasicAuthorizationInterceptor(user, password));
        }
        template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
        template.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));
        HttpEntity<T> entity = new HttpEntity<>(requestInfo.getPayload(), headers);
        return template.exchange(requestInfo.getEndpoint() + requestInfo.getPath(), requestInfo.getMethod(), entity, requestInfo.getReponseType());
    }

    public <T> void restBasicRequest(RESTRequest<T> requestInfo) {
        String user = requestInfo.getBasicAuthentication().get("user");
        String password = requestInfo.getBasicAuthentication().get("password");
        MultiValueMap<String, String> headers = jsonHeaders();

        CloseableHttpClient httpClient = HttpClients.custom().build();
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);

        RestTemplate template = new RestTemplate(requestFactory);
        template.getInterceptors().add(new BasicAuthorizationInterceptor(user, password));
        template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
        HttpEntity<T> entity = new HttpEntity<>(requestInfo.getPayload(), headers);
        template.exchange(requestInfo.getEndpoint(), requestInfo.getMethod(), entity, requestInfo.getReponseType());
    }

    public <T> void restRequest(RESTRequest<T> requestInfo) {
        MultiValueMap<String, String> headers = jsonHeaders();

        CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);

        RestTemplate template = new RestTemplate(requestFactory);
        template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
        HttpEntity<T> entity = new HttpEntity<>(requestInfo.getPayload(), headers);
        //HttpEntity<String> entity = new HttpEntity<>("{}", headers);
        template.exchange(requestInfo.getEndpoint(), requestInfo.getMethod(), entity, requestInfo.getReponseType());
    }

    public <T> void restSSLRequest(RESTRequest<T> requestInfo) {
        MultiValueMap<String, String> headers = jsonHeaders();

        SSLContext sslContext = null;
        try {
            sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] chain, String authType) {
                    return true;
                }
            }).build();
        } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException e) {
            log.error("Error al generar el SSLContext", e);
        }
        SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, new NoopHostnameVerifier());

        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build();
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);

        RestTemplate template = new RestTemplate(requestFactory);
        template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
        HttpEntity<T> entity = new HttpEntity<>(requestInfo.getPayload(), headers);
        //HttpEntity<String> entity = new HttpEntity<>("{}", headers);
        template.exchange(requestInfo.getEndpoint(), requestInfo.getMethod(), entity, requestInfo.getReponseType());
    }

    private MultiValueMap<String, String> jsonHeaders() {
        MultiValueMap<String, String> headers = new LinkedMultiValueMap<String, String>();
        headers.add("Content-Type", "application/json");
        headers.add("Accept", "application/json, text/plain, */*");
        return headers;
    }

    private MultiValueMap<String, String> xmlHeaders() {
        MultiValueMap<String, String> headers = new LinkedMultiValueMap<String, String>();
        headers.add("Content-Type", "application/xml");
        headers.add("Accept", "application/xml, text/plain, */*");
        return headers;
    }

    private MultiValueMap<String, String> octetStreamHeaders() {
        MultiValueMap<String, String> headers = new LinkedMultiValueMap<String, String>();
        headers.add("Content-Type", "application/octet-stream");
        headers.add("Accept", "application/xml, text/plain, */*");
        return headers;
    }
}