package pl.orange.bpms.server.extension.soap;

import com.google.common.collect.Lists;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.apache.http.client.methods.HttpPost;
import org.kie.server.api.KieServerConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pl.orange.bpms.server.extension.rest.model.ProcessInputData;
import pl.orange.bpms.server.extension.rest.model.ProcessInputDataParameter;
import pl.orange.bpms.server.extension.rest.model.response.ProcessInitializationResult;
import pl.orange.bpms.server.extension.rest.model.response.ProcessOutputData;
import pl.orange.bpms.utils.concurrent.FutureCallbackHandler;
import pl.orange.bpms.utils.excpetions.HttpRequestException;
import pl.orange.bpms.utils.excpetions.HttpResponseException;
import pl.orange.bpms.utils.integration.correlation.hibernate.IntegrationLog;
import pl.orange.bpms.utils.integration.correlation.hibernate.InterfaceName;
import pl.orange.bpms.utils.integration.http.RequestHelper;
import pl.orange.bpms.utils.integration.http.RestServiceHttpResponse;
import pl.orange.bpms.utils.integration.logging.IntegrationLogUtil;

import javax.jws.WebService;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriBuilder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import static javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR;
import static org.apache.commons.lang.StringUtils.isNotEmpty;
import static pl.orange.bpms.server.extension.rest.model.response.ProcessInitializationResult.PROCESS_INITIALIZATION_FAILURE_ID;
import static pl.orange.bpms.utils.integration.http.RequestHelper.checkHttpResponse;
import static pl.orange.bpms.utils.integration.http.RequestHelper.sendHttpRequest;
import static pl.orange.bpms.utils.integration.logging.IntegrationLogUtil.logResponseString;
import static pl.orange.bpms.utils.marshalling.SerializationUtil.deserializeString;
import static pl.orange.bpms.utils.marshalling.SerializationUtil.doSerialization;
import static pl.orange.bpms.utils.rest.RestControllerUtil.RESPONSE_PRODUCES_CODING_POSTFIX;

/**
 * The type Initialize process service.
 */
@WebService(endpointInterface = "pl.orange.bpms.server.extension.soap.InitializeProcess")
public class InitializeProcessService implements InitializeProcess {

    private static final Logger LOGGER = LoggerFactory.getLogger(InitializeProcessService.class);

    private static final String PROCESS_INITIALIZER_URI = UriBuilder.fromPath(System.getProperty(KieServerConstants.KIE_SERVER_LOCATION))
            .path("extension/service/processInitializer/initializeProcess")
            .build().toString();

    private static final Map<String, String> PROCESS_INITIALIZER_HEADER = new HashMap<>();
    private static final InterfaceName INTERFACE_NAME = InterfaceName.INITIALIZE_PROCESS_SOAP;

    static {
        PROCESS_INITIALIZER_HEADER.putAll(RequestHelper.prepareDefaultHeaders());
        PROCESS_INITIALIZER_HEADER.put(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON + RESPONSE_PRODUCES_CODING_POSTFIX);
        PROCESS_INITIALIZER_HEADER.put(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON);
    }

    /**
     * @param category
     * @param type
     * @param subtype
     * @param system
     * @param executionParams
     * @return
     */
    @Override
    public Result initializeProcess(String category, String type, String subtype, String system, List<Param> executionParams) {
        IntegrationLog integrationLog = logIntegration(category, type, subtype, system, executionParams);     //saving external request ASAP without known process id
        final ProcessInputData inputData = prepareProcessInputData(category, type, subtype, system, executionParams);

        Result result = new Result();
        result.setErrorCode(String.valueOf(NumberUtils.INTEGER_ZERO));

        try {
            RestServiceHttpResponse httpResponse = sendHttpRequest(PROCESS_INITIALIZER_URI, PROCESS_INITIALIZER_HEADER,
                    inputData.toString(), new HttpPost(), null);
            checkHttpResponse(httpResponse);

            ProcessInitializationResult processInitializationResult = deserializeString(httpResponse.getResponseBody(), ProcessInitializationResult.class, false);
            logProcessId(integrationLog, processInitializationResult.getProcessInstanceId());
            if (PROCESS_INITIALIZATION_FAILURE_ID.equals(processInitializationResult.getProcessInstanceId())) {
                result.setErrorCode(getStringStatusCode(INTERNAL_SERVER_ERROR));
                result.setErrorDesc("Failed to initialize process. ProcessInitializationResult: " + httpResponse.getResponseBody());
            }

            final String error = getProcessInitializationResultError(processInitializationResult);
            if (isNotEmpty(error)) {
                result.setErrorCode("BPMS-RODO-ERROR-001");
                result.setErrorDesc(error);
            }

        } catch (HttpResponseException | HttpRequestException e) {
            result.setErrorCode(getStringStatusCode(INTERNAL_SERVER_ERROR));
            result.setErrorDesc(e.getMessage());
            LOGGER.error(e.getMessage());
        }
        logProcessResponse(integrationLog, result);
        return result;
    }

    /**
     * @param category
     * @param type
     * @param subtype
     * @param system
     * @param executionParams
     * @return
     */
    private static ProcessInputData prepareProcessInputData(String category, String type, String subtype, String system, List<Param> executionParams) {
        final ProcessInputData pid = new ProcessInputData();
        pid.setCategory(category);
        pid.setType(type);
        pid.setSubtype(subtype);
        pid.setIpi(system);
        pid.setExecutionParams(executionParams.stream()
                .map(param -> new ProcessInputDataParameter(param.getKey(), param.getValue(), "java.lang.String"))
                .collect(Collectors.toList()));
        return pid;
    }

    /**
     * @param requestObject
     * @return
     */
    private static IntegrationLog logIntegration(Object... requestObject) {
        return IntegrationLogUtil.logRequestString(
                doSerialization(requestObject, false, false),
                null, INTERFACE_NAME, null, null, false, false);
    }

    /**
     * @param status
     * @return
     */
    private static String getStringStatusCode(final Response.Status status) {
        return String.valueOf(status.getStatusCode());
    }

    /**
     * @param log
     * @param processId
     */
    private static void logProcessId(IntegrationLog log, Long processId) {
        FutureCallbackHandler.newSingleThreadCallbackHandler(
                () -> logResponseString(null, log, processId, INTERFACE_NAME, null, null, false, false)
        );
    }

    private static void logProcessResponse(IntegrationLog log, Result result) {
        FutureCallbackHandler.newSingleThreadCallbackHandler(
                () -> logResponseString(doSerialization(result, false, false), log,
                        null, INTERFACE_NAME, null, null, false, false)
        );
    }

    private static String getProcessInitializationResultError(final ProcessInitializationResult pir) {
        return Optional.ofNullable(pir.getProcessParameters())
                .orElse(Lists.newArrayList())
                .stream()
                .filter(e -> "errors".equals(e.getKey()))
                .findFirst()
                .map(ProcessOutputData::getValue)
                .map(String::valueOf)
                .orElse(StringUtils.EMPTY);
    }
}