/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you 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.apache.synapse.mediators.eip.splitter;

import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.jayway.jsonpath.JsonPath;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMNode;
import org.apache.axiom.soap.SOAPEnvelope;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.context.OperationContext;
import org.apache.synapse.ContinuationState;
import org.apache.synapse.FaultHandler;
import org.apache.synapse.ManagedLifecycle;
import org.apache.synapse.Mediator;
import org.apache.synapse.MessageContext;
import org.apache.synapse.SynapseException;
import org.apache.synapse.SynapseLog;
import org.apache.synapse.aspects.AspectConfiguration;
import org.apache.synapse.aspects.ComponentType;
import org.apache.synapse.aspects.flow.statistics.StatisticIdentityGenerator;
import org.apache.synapse.aspects.flow.statistics.collectors.OpenEventCollector;
import org.apache.synapse.aspects.flow.statistics.collectors.RuntimeStatisticCollector;
import org.apache.synapse.aspects.flow.statistics.data.artifact.ArtifactHolder;
import org.apache.synapse.commons.json.JsonUtil;
import org.apache.synapse.config.xml.SynapsePath;
import org.apache.synapse.continuation.ContinuationStackManager;
import org.apache.synapse.core.SynapseEnvironment;
import org.apache.synapse.core.axis2.Axis2MessageContext;
import org.apache.synapse.endpoints.Endpoint;
import org.apache.synapse.mediators.AbstractMediator;
import org.apache.synapse.mediators.FlowContinuableMediator;
import org.apache.synapse.mediators.base.SequenceMediator;
import org.apache.synapse.mediators.eip.SharedDataHolder;
import org.apache.synapse.mediators.eip.EIPConstants;
import org.apache.synapse.mediators.eip.EIPUtils;
import org.apache.synapse.mediators.eip.Target;
import org.apache.synapse.util.MessageHelper;
import org.apache.synapse.util.xpath.SynapseJsonPath;
import org.apache.synapse.util.xpath.SynapseXPath;
import org.jaxen.JaxenException;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;

/**
 * Splits a message using an XPath expression and creates a new message to hold
 * each resulting element. This is very much similar to the clone mediator, and
 * hands over the newly created messages to a target for processing
 */
public class IterateMediator extends AbstractMediator implements ManagedLifecycle,
                                                                 FlowContinuableMediator {

    /** Continue mediation on the parent message or not? */
    private boolean continueParent = false;

    /**
     * Preserve the payload as a template to create new messages with the selected
     * elements with the api of the parent, or create new message that contain only
     * the selected element as its payload?
     */
    private boolean preservePayload = false;

    /** The Path that will list the elements to be splitted */
    private SynapsePath expression = null;

    /**
     * A Path expression that specifies where the splitted elements should be attached when
     * the payload is being preserved
     */
    private SynapsePath attachPath = null;

    /** The target for the newly splitted messages */
    private Target target = null;

    private String id = null;

    private SynapseEnvironment synapseEnv;

    /**
     * A flag used to check whether attachPath was present in the original synapse configuration
     */
    private boolean isAttachPathPresent;

    /**
     * Splits the message by iterating over the results of the given Path expression
     *
     * @param synCtx - MessageContext to be mediated
     * @return boolean false if need to stop processing of the parent message
     */
    public boolean mediate(MessageContext synCtx) {

        if (synCtx.getEnvironment().isDebuggerEnabled()) {
            if (super.divertMediationRoute(synCtx)) {
                return true;
            }
        }

        SynapseLog synLog = getLog(synCtx);

        if (synLog.isTraceOrDebugEnabled()) {
            synLog.traceOrDebug("Start : Iterate mediator");

            if (synLog.isTraceTraceEnabled()) {
                synLog.traceTrace("Message : " + synCtx.getEnvelope());
            }
        }

        synCtx.setProperty(id != null ? EIPConstants.EIP_SHARED_DATA_HOLDER + "." + id :
                EIPConstants.EIP_SHARED_DATA_HOLDER, new SharedDataHolder());

        try {

            // check whether expression contains jsonpath or xpath and process according to it
            if (expression != null && expression instanceof SynapseJsonPath) {

                // SynapseJSONPath implementation reads the JSON stream and execute the JSON path.
                Object resultValue = expression.evaluate(synCtx);

                //Gson parser to parse the string json objects
                JsonParser parser = new JsonParser();

                //Complete json payload read from the synCtx
                Object rootJSON = parser.parse(
                        JsonUtil.jsonPayloadToString(((Axis2MessageContext) synCtx).getAxis2MessageContext())).
                        toString();

                //delete the iterated json object if the attachPath is different from expression.
                // If both are same, the json object will be replaced eventually, so no need to do it here
                if (!((SynapseJsonPath) expression).getJsonPath().getPath()
                        .equals(((SynapseJsonPath) attachPath).getJsonPath().getPath())) {

                    //parse the json into gson to delete the iterated json array
                    JsonElement rootJsonElement = parser.parse(rootJSON.toString());

                    //Check whether the JSON element expressed by the jsonpath is a valid JsonArray
                    //else throw an exception
                    if (!(EIPUtils.formatJsonPathResponse(JsonPath.parse(rootJsonElement.toString())
                            .read(((SynapseJsonPath) expression).getJsonPath())) instanceof JsonArray)) {
                        handleException("JSON element expressed by the path "
                                + ((SynapseJsonPath) expression).getJsonPathExpression()
                                + " is not a valid JSON array that can be iterated", synCtx);
                    };

                    //replace the expressed jsonElement with an empty array
                    rootJSON = JsonPath.parse(rootJsonElement.toString())
                            .set(((SynapseJsonPath) expression).getJsonPath(), new JsonArray()).jsonString();

                }

                if (resultValue instanceof List) {
                    List list = (List) resultValue;

                    int msgNumber = 0;
                    int msgCount = list.size();

                    for (Object o : list) {
                        MessageContext iteratedMsgCtx
                                = getIteratedMessage(synCtx, msgNumber++, msgCount, rootJSON, o);
                        ContinuationStackManager.
                                addReliantContinuationState(iteratedMsgCtx, 0, getMediatorPosition());
                        if (target.isAsynchronous()) {
                            target.mediate(iteratedMsgCtx);
                        } else {
                            try {
                                /*
                                 * if Iteration is sequential we won't be able to execute correct fault
                                 * handler as data are lost with clone message ending execution. So here we
                                 * copy fault stack of clone message context to original message context
                                 */
                                target.mediate(iteratedMsgCtx);
                            } catch (SynapseException synEx) {
                                copyFaultyIteratedMessage(synCtx, iteratedMsgCtx);
                                throw synEx;
                            } catch (Exception e) {
                                copyFaultyIteratedMessage(synCtx, iteratedMsgCtx);
                                handleException("Exception occurred while executing sequential iteration " +
                                        "in the Iterator Mediator", e, synCtx);
                            }
                        }
                    }
                }

            } else {
                // get a copy of the message for the processing, if the continueParent is set to true
                // this original message can go in further mediations and hence we should not change
                // the original message context
                SOAPEnvelope envelope = MessageHelper.cloneSOAPEnvelope(synCtx.getEnvelope());

                // get the iteration elements and iterate through the list,
                // this call will also detach all the iteration elements
                List splitElements = EIPUtils.getDetachedMatchingElements(envelope, synCtx, (SynapseXPath) expression);

                if (synLog.isTraceOrDebugEnabled()) {
                    synLog.traceOrDebug("Splitting with XPath : " + expression + " resulted in " +
                            splitElements.size() + " elements");
                }

                // if not preservePayload remove all the child elements
                if (!preservePayload && envelope.getBody() != null) {
                    for (Iterator itr = envelope.getBody().getChildren(); itr.hasNext();) {
                        ((OMNode) itr.next()).detach();
                    }
                }

                int msgCount = splitElements.size();
                int msgNumber = 0;

                // iterate through the list
                for (Object o : splitElements) {

                    // for the moment iterator will look for an OMNode as the iteration element
                    if (!(o instanceof OMNode)) {
                        handleException("Error splitting message with XPath : "
                                + expression + " - result not an OMNode", synCtx);
                    }

                    if (synLog.isTraceOrDebugEnabled()) {
                        synLog.traceOrDebug(
                                "Submitting " + (msgNumber+1) + " of " + msgCount +
                                        (target.isAsynchronous() ? " messages for processing in parallel" :
                                                " messages for processing in sequentially"));
                    }

                    MessageContext iteratedMsgCtx =
                            getIteratedMessage(synCtx, msgNumber++, msgCount, envelope, (OMNode) o);
                    ContinuationStackManager.
                            addReliantContinuationState(iteratedMsgCtx, 0, getMediatorPosition());
                    if (target.isAsynchronous()) {
                        target.mediate(iteratedMsgCtx);
                    } else {
                        try {
                            /*
                             * if Iteration is sequential we won't be able to execute correct fault
                             * handler as data are lost with clone message ending execution. So here we
                             * copy fault stack of clone message context to original message context
                             */
                            target.mediate(iteratedMsgCtx);
                        } catch (SynapseException synEx) {
                            copyFaultyIteratedMessage(synCtx, iteratedMsgCtx);
                            throw synEx;
                        } catch (Exception e) {
                            copyFaultyIteratedMessage(synCtx, iteratedMsgCtx);
                            handleException("Exception occurred while executing sequential iteration " +
                                    "in the Iterator Mediator", e, synCtx);
                        }
                    }
                }
            }

        } catch (JaxenException e) {
            handleException("Error evaluating split XPath expression : " + expression, e, synCtx);
        } catch (AxisFault af) {
            handleException("Error creating an iterated copy of the message", af, synCtx);
        } catch (SynapseException synEx) {
            throw synEx;
        } catch (Exception e) {
            handleException("Exception occurred while executing the Iterate Mediator", e, synCtx);
        }

        // if the continuation of the parent message is stopped from here set the RESPONSE_WRITTEN
        // property to SKIP to skip the blank http response
        OperationContext opCtx
            = ((Axis2MessageContext) synCtx).getAxis2MessageContext().getOperationContext();
        if (!continueParent && opCtx != null) {
            opCtx.setProperty(Constants.RESPONSE_WRITTEN,"SKIP");
        }

        synLog.traceOrDebug("End : Iterate mediator");

        // whether to continue mediation on the original message
        return continueParent;
    }

    /**
     * Copy fault stack and properties of the iteratedMsgCtx to synCtx
     *
     * @param synCtx         Original Synapse Message Context
     * @param iteratedMsgCtx cloned Message Context used for the iteration
     */
    private void copyFaultyIteratedMessage(MessageContext synCtx, MessageContext iteratedMsgCtx) {
        synCtx.getFaultStack().clear(); //remove original fault stack
        Stack<FaultHandler> faultStack = iteratedMsgCtx.getFaultStack();

        if (!faultStack.isEmpty()) {
            List<FaultHandler> newFaultStack = new ArrayList<FaultHandler>();
            newFaultStack.addAll(faultStack);
            for (FaultHandler faultHandler : newFaultStack) {
                if (faultHandler != null) {
                    synCtx.pushFaultHandler(faultHandler);
                }
            }
        }
        // copy all the String keyed synapse level properties to the Original synCtx
        for (Object keyObject : iteratedMsgCtx.getPropertyKeySet()) {
            /*
             * There can be properties added while executing the iterated sequential flow and
             * these may be accessed in the fault sequence, so updating string valued properties
             */
            if (keyObject instanceof String) {
                String stringKey = (String) keyObject;
                synCtx.setProperty(stringKey, iteratedMsgCtx.getProperty(stringKey));
            }
        }
    }

    public boolean mediate(MessageContext synCtx,
                           ContinuationState continuationState) {
        SynapseLog synLog = getLog(synCtx);

        if (synLog.isTraceOrDebugEnabled()) {
            synLog.traceOrDebug("Iterate mediator : Mediating from ContinuationState");
        }

        boolean result;
        SequenceMediator branchSequence = target.getSequence();
        boolean isStatisticsEnabled = RuntimeStatisticCollector.isStatisticsEnabled();
        if (!continuationState.hasChild()) {
            result = branchSequence.mediate(synCtx, continuationState.getPosition() + 1);
        } else {
            FlowContinuableMediator mediator =
                    (FlowContinuableMediator) branchSequence.getChild(continuationState.getPosition());

            result = mediator.mediate(synCtx, continuationState.getChildContState());

            if (isStatisticsEnabled) {
                ((Mediator) mediator).reportCloseStatistics(synCtx, null);
            }
        }
        if (isStatisticsEnabled) {
            branchSequence.reportCloseStatistics(synCtx, null);
        }
        return result;
    }

    /**
     * Creates a new message context using the given original message context, the envelope
     *      * and the split result element. This is method is specific for JSON payloads
     * @param synCtx original message context
     * @param msgNumber message number in the iteration
     * @param msgCount total number of messages in the split
     * @param rootJsonObject total number of messages in the split
     * @param node Json object to be attached
     * @return newCtx created by the iteration
     * @throws AxisFault if there is a message creation failure
     * @throws JaxenException if the expression evaluation failure
     */
    private MessageContext getIteratedMessage(MessageContext synCtx, int msgNumber,
                                              int msgCount, Object rootJsonObject, Object node)
            throws AxisFault, JaxenException {

        // clone the message for the mediation in iteration
        MessageContext newCtx = MessageHelper.cloneMessageContext(synCtx);

        //Remove the original jsonstream from the context
        JsonUtil.removeJsonPayload(((Axis2MessageContext) newCtx).getAxis2MessageContext());

        if (id != null) {
            // set the parent correlation details to the cloned MC -
            //                              for the use of aggregation like tasks
            newCtx.setProperty(EIPConstants.AGGREGATE_CORRELATION + "." + id,
                    synCtx.getMessageID());
            // set the messageSequence property for possibal aggreagtions
            newCtx.setProperty(
                    EIPConstants.MESSAGE_SEQUENCE + "." + id,
                    msgNumber + EIPConstants.MESSAGE_SEQUENCE_DELEMITER + msgCount);
        } else {
            newCtx.setProperty(
                    EIPConstants.MESSAGE_SEQUENCE,
                    msgNumber + EIPConstants.MESSAGE_SEQUENCE_DELEMITER + msgCount);
        }
        // Initially set the extracted object as root and send if payload is not preserved
        Object rootObject = node;

        // if payload should be preserved then attach the iteration element to the
        // node specified by the attachPath
        if (preservePayload) {
            rootObject = rootJsonObject;
            if (rootObject != null){
                rootObject = ((SynapseJsonPath) attachPath).replace(rootObject, node);
            } else {
                handleException("Error in attaching the splitted elements :: " +
                        "Unable to get the attach path specified by the expression " +
                        attachPath, synCtx);
            }
        }

        // write the new JSON message to the stream
        JsonUtil.getNewJsonPayload(((Axis2MessageContext) newCtx).getAxis2MessageContext(),
                rootObject.toString(), true, true);

        // Set isServerSide property in the cloned message context
        ((Axis2MessageContext) newCtx).getAxis2MessageContext().setServerSide(
                ((Axis2MessageContext) synCtx).getAxis2MessageContext().isServerSide());


        return newCtx;
    }

    /**
     * Creates a new message context using the given original message context, the envelope
     * and the split result element. This method is specific for xml payloads
     *
     * @param synCtx    - original message context
     * @param msgNumber - message number in the iteration
     * @param msgCount  - total number of messages in the split
     * @param envelope  - envelope to be used in the iteration
     * @param o         - element which participates in the iteration replacement
     * @return newCtx created by the iteration
     * @throws AxisFault if there is a message creation failure
     * @throws JaxenException if the expression evauation failure
     */
    private MessageContext getIteratedMessage(MessageContext synCtx, int msgNumber, int msgCount,
        SOAPEnvelope envelope, OMNode o) throws AxisFault, JaxenException {

        // clone the message context without cloning the SOAP envelope, for the mediation in iteration.
        MessageContext newCtx = MessageHelper.cloneMessageContext(synCtx, false, false);

        if (id != null) {
            // set the parent correlation details to the cloned MC -
            //                              for the use of aggregation like tasks
            newCtx.setProperty(EIPConstants.AGGREGATE_CORRELATION + "." + id,
                    synCtx.getMessageID());
            // set the messageSequence property for possibal aggreagtions
            newCtx.setProperty(
                    EIPConstants.MESSAGE_SEQUENCE + "." + id,
                    msgNumber + EIPConstants.MESSAGE_SEQUENCE_DELEMITER + msgCount);
        } else {
            newCtx.setProperty(
                    EIPConstants.MESSAGE_SEQUENCE,
                    msgNumber + EIPConstants.MESSAGE_SEQUENCE_DELEMITER + msgCount);
        }

        // get a clone of the envelope to be attached
        SOAPEnvelope newEnvelope = MessageHelper.cloneSOAPEnvelope(envelope);

        // if payload should be preserved then attach the iteration element to the
        // node specified by the attachPath
        if (preservePayload) {

            Object attachElem = ((SynapseXPath) attachPath).evaluate(newEnvelope, synCtx);

            if (attachElem != null &&
                attachElem instanceof List && !((List) attachElem).isEmpty()) {
                attachElem = ((List) attachElem).get(0);
            }

            // for the moment attaching element should be an OMElement
            if (attachElem != null && attachElem instanceof OMElement) {
                ((OMElement) attachElem).addChild(o);
            } else {
                handleException("Error in attaching the splitted elements :: " +
                    "Unable to get the attach path specified by the expression " +
                    attachPath, synCtx);
            }

        } else if (newEnvelope.getBody() != null) {
            // if not preserve payload then attach the iteration element to the body
        	if(newEnvelope.getBody().getFirstElement() !=null){
        		newEnvelope.getBody().getFirstElement().detach();
        	}
            newEnvelope.getBody().addChild(o);
        }

        // set the envelope and mediate as specified in the target
        newCtx.setEnvelope(newEnvelope);

        // Set isServerSide property in the cloned message context
        ((Axis2MessageContext) newCtx).getAxis2MessageContext().setServerSide(
                ((Axis2MessageContext) synCtx).getAxis2MessageContext().isServerSide());

        return newCtx;
    }

    ///////////////////////////////////////////////////////////////////////////////////////
    //                        Getters and Setters                                        //
    ///////////////////////////////////////////////////////////////////////////////////////

    public boolean isContinueParent() {
        return continueParent;
    }

    public void setContinueParent(boolean continueParent) {
        this.continueParent = continueParent;
    }

    public boolean isPreservePayload() {
        return preservePayload;
    }

    public void setPreservePayload(boolean preservePayload) {
        this.preservePayload = preservePayload;
    }

    public SynapsePath getExpression() {
        return expression;
    }

    public void setExpression(SynapsePath expression) {
        this.expression = expression;
    }

    public SynapsePath getAttachPath() {
        return attachPath;
    }

    public void setAttachPath(SynapsePath attachPath) {
        this.attachPath = attachPath;
    }

    public Target getTarget() {
        return target;
    }

    public void setTarget(Target target) {
        this.target = target;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public boolean isContentAltering() {
        return true;
    }

    public boolean isAttachPathPresent() {
        return isAttachPathPresent;
    }

    public void setAttachPathPresent(boolean attachPathPresent) {
        isAttachPathPresent = attachPathPresent;
    }

    public void init(SynapseEnvironment se) {

        synapseEnv = se;
        if (target != null) {
            Endpoint endpoint = target.getEndpoint();
            if (endpoint != null) {
                endpoint.init(se);
            }

            ManagedLifecycle seq = target.getSequence();
            if (seq != null) {
                seq.init(se);
            } else if (target.getSequenceRef() != null) {
                SequenceMediator targetSequence =
                        (SequenceMediator) se.getSynapseConfiguration().
                                getSequence(target.getSequenceRef());

                if (targetSequence == null || targetSequence.isDynamic()) {
                    se.addUnavailableArtifactRef(target.getSequenceRef());
                }
            }
        }
    }

    public void destroy() {
        if (target != null) {
            Endpoint endpoint = target.getEndpoint();
            if (endpoint != null && endpoint.isInitialized()) {
                endpoint.destroy();
            }

            ManagedLifecycle seq = target.getSequence();
            if (seq != null) {
                seq.destroy();
            } else if (target.getSequenceRef() != null) {
                SequenceMediator targetSequence =
                        (SequenceMediator) synapseEnv.getSynapseConfiguration().
                                getSequence(target.getSequenceRef());

                if (targetSequence == null || targetSequence.isDynamic()) {
                    synapseEnv.removeUnavailableArtifactRef(target.getSequenceRef());
                }
            }
        }
    }

    @Override
    public Integer reportOpenStatistics(MessageContext messageContext, boolean isContentAltering) {
        return OpenEventCollector.reportFlowSplittingEvent(messageContext, getMediatorName(), ComponentType.MEDIATOR,
                                                           getAspectConfiguration(),
                                                           isContentAltering() || isContentAltering);
    }

    @Override
    public void setComponentStatisticsId(ArtifactHolder holder) {
        if (getAspectConfiguration() == null) {
            configure(new AspectConfiguration(getMediatorName()));
        }
        String mediatorId =
                StatisticIdentityGenerator.getIdForFlowContinuableMediator(getMediatorName(), ComponentType.MEDIATOR, holder);
        getAspectConfiguration().setUniqueId(mediatorId);
        if(target != null){
            target.setStatisticIdForMediators(holder);
        }
        StatisticIdentityGenerator.reportingFlowContinuableEndEvent(mediatorId, ComponentType.MEDIATOR, holder);
    }
}
