// SPDX-License-Identifier: GPL-3.0-or-later

package es.uvigo.esei.sing.textproc.abstracttppstep;

import static es.uvigo.esei.sing.textproc.abstracttppstep.TppHelper.processAttributes;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Formatter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Predicate;

import javax.json.JsonObject;
import javax.json.stream.JsonGenerator;
import javax.persistence.PersistenceException;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;

import es.uvigo.esei.sing.textproc.entity.ProcessedDocument;
import es.uvigo.esei.sing.textproc.abstracttppstep.xml.definition.EndpointProcessingStepParameter;
import es.uvigo.esei.sing.textproc.step.AbstractProcessingStep;
import es.uvigo.esei.sing.textproc.step.ProcessingException;
import lombok.NonNull;

/**
 * Handles common processing logic to all processing steps that call the Text
 * Processing Python web service for processing documents.
 *
 * @author Alejandro González García
 */
public abstract class AbstractTppProcessingStep extends AbstractProcessingStep {
        private static final String ENDPOINT_PROCESSING_STEP_PARAMETER_NAME = new EndpointProcessingStepParameter().getName();

        private final List<Class<? extends ProcessedDocument>> processedDocumentTypes;
        private final String stepDescriptionFormatString;
        private final JsonResponseAttributeType jsonResponseAttributeType;
        private final ProcessingConsumer<? super JsonGenerator> requestParametersAction;
        private final ProcessingBiConsumer<? super Entry<String, JsonObject>, ? super Map<String, String>> storeProcessedAttributeAction;

        /**
         * Creates a new processing step that processes documents via calls to the Text
         * Processing Python web service.
         *
         * @param validationPredicates          A map with additional parameter
         *                                      validation predicates, specific to the
         *                                      concrete processing step.
         * @param requiredParameters            A set with additional mandatory
         *                                      parameters, specific to this processing
         *                                      step.
         * @param processedDocumentTypes        The processed entity types generated by
         *                                      the particular processing step. At the
         *                                      moment, this must be a list of two
         *                                      processed document types, where the
         *                                      first one is interpreted as the
         *                                      resulting type for titled documents, and
         *                                      the second one is the resulting type for
         *                                      untitled documents. The format of this
         *                                      list may be changed in the future if
         *                                      more unprocessed document types are
         *                                      added.
         * @param stepDescriptionFormatString   A format string (as defined by
         *                                      {@link Formatter}) that will be used for
         *                                      generating a user-friendly step activity
         *                                      description string. It will receive a
         *                                      single string parameter with the name of
         *                                      the unprocessed entity that is being
         *                                      processed.
         * @param jsonResponseAttributeType     The expected JSON type of processed
         *                                      document attributes in the web service
         *                                      response.
         * @param requestParametersAction       The action to execute to populate the
         *                                      request object with parameters, after
         *                                      the documents object.
         * @param storeProcessedAttributeAction An action that receives the JSON
         *                                      document object of the response, and is
         *                                      expected to put its processed form in
         *                                      the provided map.
         * @throws IllegalArgumentException If any parameter is {@code null} or invalid.
         */
        protected AbstractTppProcessingStep(
                final Map<String, Predicate<String>> validationPredicates, final Set<String> requiredParameters,
                @NonNull final List<Class<? extends ProcessedDocument>> processedDocumentTypes,
                @NonNull final String stepDescriptionFormatString, @NonNull final JsonResponseAttributeType jsonResponseAttributeType,
                @NonNull final ProcessingConsumer<? super JsonGenerator> requestParametersAction,
                @NonNull final ProcessingBiConsumer<? super Entry<String, JsonObject>, ? super Map<String, String>> storeProcessedAttributeAction 
        ) {
                super(
                        getActualValidationPredicates(validationPredicates),
                        getActualRequiredParameters(requiredParameters)
                );

                if (processedDocumentTypes.size() != 2) {
                        throw new IllegalArgumentException(
                                "There must be only one result entity type for each type of unprocessed document"
                        );
                }

                try {
                        if (processedDocumentTypes.contains(null)) {
                                throw new IllegalArgumentException("A processed document type can't be null");
                        }
                } catch (final NullPointerException ignored) {}

                this.processedDocumentTypes = Collections.unmodifiableList(new ArrayList<>(processedDocumentTypes));
                this.stepDescriptionFormatString = stepDescriptionFormatString;
                this.jsonResponseAttributeType = jsonResponseAttributeType;
                this.requestParametersAction = requestParametersAction;
                this.storeProcessedAttributeAction = storeProcessedAttributeAction;
        }

        @Override
        protected final void run() throws ProcessingException {
                final Client wsClient = ClientBuilder.newClient();

                try {
                        final WebTarget target = wsClient.target(getParameters().get(ENDPOINT_PROCESSING_STEP_PARAMETER_NAME));

                        // Delete previous results
                        for (final Class<? extends ProcessedDocument> processedDocumentType : processedDocumentTypes) {
                                deleteAllProcessedDocumentsOfType(processedDocumentType);
                        }

                        // Do the actual processing
                        for (int i = 0; i < processedDocumentTypes.size(); ++i) {
                                final String[] unprocessedAttributeNames = unprocessedDocumentsAttributes.get(i);
                                final Class<? extends ProcessedDocument> processedDocumentType = processedDocumentTypes.get(i);

                                forEachDocumentInNativeQuery(
                                        unprocessedDocumentsQuerySuppliers.get(i),
                                        String.format(stepDescriptionFormatString, unprocessedDocumentTypesNames.get(i)),
                                        numberOfUnprocessedEntitiesProviders.get(i).get(),
                                        (final List<String[]> batchAttributes) -> {
                                                // Process entity attributes
                                                final List<Map<String, String>> processedDocs = processAttributes(
                                                        batchAttributes, 1, unprocessedAttributeNames, target,
                                                        requestParametersAction, jsonResponseAttributeType,
                                                        storeProcessedAttributeAction
                                                );
                                                // No benefit in iterating with several threads as order matters
                                                final Iterator<Map<String, String>> processedDocsIter = processedDocs.iterator();

                                                // Persist the resulting processed documents
                                                for (final String[] completeAttributes : batchAttributes) {
                                                        saveProcessedDocument(
                                                                processedDocumentType, Integer.parseInt(completeAttributes[0]),
                                                                processedDocsIter.next() // Same size than attributes
                                                        );
                                                }
                                        },
                                        null
                                );
                        }
                } catch (final IllegalArgumentException | PersistenceException exc) {
                        throw new ProcessingException(DATA_ACCESS_EXCEPTION_MESSAGE, exc);
                } finally {
                        wsClient.close();
                }
        }

        /**
         * Returns a map with the provided validation predicates, plus any validation
         * predicates common to all Text Processing Python processing steps.
         *
         * @param validationPredicates The validation predicates of the specific step.
         * @return The described map.
         * @throws IllegalArgumentException If {@code validationPredicates} is {@code null}.
         */
        private static Map<String, Predicate<String>> getActualValidationPredicates(@NonNull final Map<String, Predicate<String>> validationPredicates) {
                final Map<String, Predicate<String>> commonValidationPredicates = Map.of(
                        ENDPOINT_PROCESSING_STEP_PARAMETER_NAME, (final String value) -> value != null && !value.isBlank()
                );

                final Map<String, Predicate<String>> actualValidationPredicates = new HashMap<>(
                        (int) Math.ceil((commonValidationPredicates.size() + validationPredicates.size()) / 0.75)
                );

                actualValidationPredicates.putAll(commonValidationPredicates);
                actualValidationPredicates.putAll(validationPredicates);

                return actualValidationPredicates;
        }

        /**
         * Returns a set with the provided required parameters, plus any required
         * parameter common to all Text Processing Python processing steps.
         *
         * @param requiredParameters The required parameters for the specific step.
         * @return The described set.
         * @throws IllegalArgumentException If {@code requiredParameters} is
         *                                  {@code null}.
         */
        private static Set<String> getActualRequiredParameters(@NonNull final Set<String> requiredParameters) {
                final Set<String> commonRequiredParameters = Set.of(
                        ENDPOINT_PROCESSING_STEP_PARAMETER_NAME
                );

                final Set<String> actualRequiredParameters = new HashSet<>(
                        (int) Math.ceil((commonRequiredParameters.size() + requiredParameters.size()) / 0.75)
                );

                actualRequiredParameters.addAll(commonRequiredParameters);
                actualRequiredParameters.addAll(requiredParameters);

                return actualRequiredParameters;
        }
}