/*
 * 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.axis2.engine;

import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMFactory;
import org.apache.axis2.AxisFault;
import org.apache.axis2.client.ServiceClient;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.engine.util.FaultThrowingService;
import org.apache.axis2.handlers.AbstractHandler;
import org.apache.axis2.integration.LocalTestCase;
import org.apache.axis2.integration.TestingUtils;
import org.apache.axis2.phaseresolver.PhaseMetadata;

import javax.xml.namespace.QName;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class HandlerExecutionTest extends LocalTestCase {
    private static ArrayList testResults;
    private AxisService testService;
    private AxisService testFailingService;
    private QName failingServiceName = new QName("FaultThrowingService");
    private QName failingOperationName = new QName("echoWithFault");
    private static TestHandler middleGlobalInHandler;
    private TestHandler firstOperationInHandler;
    private TestHandler middleOperationInHandler;
    private TestHandler middleOperationOutHandler;

    private void registerOperationLevelHandlers(AxisOperation operation) {
        ArrayList operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setRemainingPhasesInFlow(operationSpecificPhases);
        ArrayList phaseList = operation.getRemainingPhasesInFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                operationSpecificPhase.addHandler(firstOperationInHandler);
                operationSpecificPhase.addHandler(middleOperationInHandler);
                operationSpecificPhase.addHandler(new TestHandler("In6"));
            }
        }

        operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setPhasesOutFlow(operationSpecificPhases);
        phaseList = operation.getPhasesOutFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                operationSpecificPhase.addHandler(new TestHandler("Out1"));
                operationSpecificPhase.addHandler(middleOperationOutHandler);
                operationSpecificPhase.addHandler(new TestHandler("Out3"));
            }
        }

    }

    protected void setUp() throws Exception {
    	super.setUp();
        testResults = new ArrayList();

            List globalInPhases =
                    serverConfig.getAxisConfiguration().getInFlowPhases();
            for (int i = 0; i < globalInPhases.size(); i++) {
                Phase globalInPhase = (Phase)globalInPhases.get(i);
                if (PhaseMetadata.PHASE_PRE_DISPATCH.equals(globalInPhase.getPhaseName())) {
                    globalInPhase.addHandler(new TestHandler("In1"));
                    middleGlobalInHandler = new TestHandler("In2");
                    globalInPhase.addHandler(middleGlobalInHandler);
                    globalInPhase.addHandler(new TestHandler("In3"));
                }
            }
        firstOperationInHandler = new TestHandler("In4");
        middleOperationInHandler = new TestHandler("In5");
        middleOperationOutHandler = new TestHandler("Out2");

        testService = deployClassAsService(Echo.SERVICE_NAME, Echo.class);
        registerOperationLevelHandlers(testService.getOperation(new QName(Echo.ECHO_OM_ELEMENT_OP_NAME)));

        testFailingService = deployClassAsService(failingServiceName.getLocalPart(), FaultThrowingService.class);
        registerOperationLevelHandlers(testFailingService.getOperation(failingOperationName));

    }

    private ServiceClient createClient() throws Exception {
    	return getClient(Echo.SERVICE_NAME, Echo.ECHO_OM_ELEMENT_OP_NAME);
    }

    private void executeClient() throws Exception {
        OMElement payload = TestingUtils.createDummyOMElement();
        OMElement result = createClient().sendReceive(payload);

        TestingUtils.compareWithCreatedOMElement(result);
    }

    public void testSuccessfulInvocation() throws Exception {
        System.out.println("Starting testSuccessfulInvocation");

        OMElement payload = TestingUtils.createDummyOMElement();
        ServiceClient sender = createClient();

        AxisOperation operation =
                sender.getAxisService().getOperation(ServiceClient.ANON_OUT_IN_OP);
        ArrayList operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setRemainingPhasesInFlow(operationSpecificPhases);
        ArrayList phaseList = operation.getRemainingPhasesInFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                operationSpecificPhase.addHandler(new TestHandler("CIn1"));
                operationSpecificPhase.addHandler(new TestHandler("CIn2"));
                operationSpecificPhase.addHandler(new TestHandler("CIn3"));
            }
        }

        operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setPhasesOutFlow(operationSpecificPhases);
        phaseList = operation.getPhasesOutFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                operationSpecificPhase.addHandler(new TestHandler("COut1"));
                operationSpecificPhase.addHandler(new TestHandler("COut2"));
                operationSpecificPhase.addHandler(new TestHandler("COut3"));
            }
        }

        OMElement result = sender.sendReceive(payload);

        TestingUtils.compareWithCreatedOMElement(result);

        List expectedExecutionState = Arrays.asList(new String[] { "COut1", "COut2", "COut3", "In1",
                "In2", "In3", "In4", "In5", "In6", "Out1", "Out2", "Out3", "FCOut3", "FCOut2",
                "FCOut1", "FCIn6", "FCIn5", "FCIn4", "FCIn3", "FCIn2", "FCIn1", "FCCOut3",
                "FCCOut2", "FCCOut1", "CIn1", "CIn2", "CIn3", "FCCIn3", "FCCIn2", "FCCIn1" });
        assertEquals(expectedExecutionState, testResults);
    }

    public void testServersideFailureInService() throws Exception {
        System.out.println("Starting testServersideFailureInService");

        OMFactory omFactory = OMAbstractFactory.getOMFactory();
        OMElement payload = omFactory.createOMElement("EchoOMElement", null);
        payload.setText(FaultThrowingService.THROW_FAULT_AS_AXIS_FAULT);

        ServiceClient sender = getClient(failingServiceName.getLocalPart(), failingOperationName.getLocalPart());
        sender.getOptions().setExceptionToBeThrownOnSOAPFault(true);
        
        AxisOperation operation =
                sender.getAxisService().getOperation(ServiceClient.ANON_OUT_IN_OP);
        ArrayList operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setRemainingPhasesInFlow(operationSpecificPhases);
        ArrayList phaseList = operation.getRemainingPhasesInFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                operationSpecificPhase.addHandler(new TestHandler("CIn1"));
                operationSpecificPhase.addHandler(new TestHandler("CIn2"));
                operationSpecificPhase.addHandler(new TestHandler("CIn3"));
            }
        }

        operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setPhasesOutFlow(operationSpecificPhases);
        phaseList = operation.getPhasesOutFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                operationSpecificPhase.addHandler(new TestHandler("COut1"));
                operationSpecificPhase.addHandler(new TestHandler("COut2"));
                operationSpecificPhase.addHandler(new TestHandler("COut3"));
            }
        }
        try{
        	sender.sendReceive(payload);
        	fail("Expecting exception to be thrown.");
        }catch(AxisFault af){
        	assertEquals("TestFault", af.getFaultCode().getLocalPart());
        	assertTrue(af.getReason().indexOf("FaultReason") > -1);
        }
        //This odd pattern of CIn FCCIn CIn FCCIn is caused by the InOutAxisOperation always executing the inflow phases, even if there was a fault (and then executing the infaulflow)
        List expectedExecutionState = Arrays.asList(new String[] { "COut1", "COut2", "COut3", "In1",
                "In2", "In3", "In4", "In5", "In6", "FCIn6", "FCIn5", "FCIn4", "FCIn3", "FCIn2",
                "FCIn1", "FCCOut3", "FCCOut2", "FCCOut1", "CIn1", "CIn2", "CIn3", "FCCIn3",
                "FCCIn2", "FCCIn1", "CIn1", "CIn2", "CIn3", "FCCIn3", "FCCIn2", "FCCIn1" });
        //TODO : Need to fix the this test case
//    assertEquals(expectedExecutionState, testResults);
    }

    public void testServersideHandlerFailureInInboundOperationSpecificPhase() throws Exception {
        System.out.println("Starting testServersideHandlerFailureInInboundOperationSpecificPhase");

        middleOperationInHandler.shouldFail(true);
        try {
            executeClient();
            fail("An expected handler failure did not occur");
        }
        catch (AxisFault e) {
        }
        List expectedExecutionState = Arrays.asList(new String[] { "In1", "In2", "In3", "In4",
                "kaboom", "FCIn4", "FCIn3", "FCIn2", "FCIn1" });
        assertEquals(expectedExecutionState, testResults);
        middleOperationInHandler.shouldFail(false);
    }

    public void testServersideHandlerFailureInInboundOperationSpecificPhaseWithFirstHandler()
            throws Exception {
        System.out.println("Starting testServersideHandlerFailureInOutboundPhaseWithFirstHandler");
        firstOperationInHandler.shouldFail(true);
        try {
            executeClient();
            fail("An expected handler failure did not occur");
        }
        catch (AxisFault e) {
        }
        List expectedExecutionState = Arrays.asList(
                new String[] { "In1", "In2", "In3", "kaboom", "FCIn3", "FCIn2", "FCIn1" });
        assertEquals(expectedExecutionState, testResults);
        firstOperationInHandler.shouldFail(false);
    }

    public void testServersideHandlerFailureInInboundGlobalPhase() throws Exception {
        System.out.println("Starting testServersideHandlerFailureInGlobalPhase");

        middleGlobalInHandler.shouldFail(true);
        try {
            executeClient();
            fail("An expected handler failure did not occur");
        }
        catch (AxisFault e) {
        }
        List expectedExecutionState = Arrays.asList(new String[] {"In1", "kaboom","FCIn1"});
        assertEquals(expectedExecutionState, testResults);
        middleGlobalInHandler.shouldFail(false);
    }

    public void testServersideHandlerFailureInOutboundPhase() throws Exception {
        System.out.println("Starting testServersideHandlerFailureInOutboundPhase");

        middleOperationOutHandler.shouldFail(true);
        try {
            executeClient();
            fail("An expected handler failure did not occur");
        }
        catch (AxisFault e) {
        }
        List expectedExecutionState = Arrays.asList(new String[] { "In1", "In2", "In3", "In4",
                "In5", "In6", "Out1", "kaboom", "FCOut1", "FCIn6", "FCIn5", "FCIn4", "FCIn3",
                "FCIn2", "FCIn1" });
        assertEquals(expectedExecutionState, testResults);
        middleOperationOutHandler.shouldFail(false);
    }

    public void testClientsideHandlerFailureInOutboundPhaseWithFirstHandler() throws Exception {
        System.out.println("Starting testClientsideHandlerFailureInOutboundPhaseWithFirstHandler");

        OMElement payload = TestingUtils.createDummyOMElement();
        ServiceClient sender = createClient();

        AxisOperation operation =
                sender.getAxisService().getOperation(ServiceClient.ANON_OUT_IN_OP);
        ArrayList operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setPhasesOutFlow(operationSpecificPhases);
        ArrayList phaseList = operation.getPhasesOutFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                //phase1.addHandler(new TestHandler("COut1"));
                TestHandler clientOutboundHandler = new TestHandler("COut1");
                clientOutboundHandler.shouldFail(true);
                operationSpecificPhase.addHandler(clientOutboundHandler);
                //phase1.addHandler(clientOutboundHandler);
            }
        }

        try {
            OMElement result = sender.sendReceive(payload);
            fail("An expected handler failure did not occur");
        }
        catch (AxisFault e) {
        }
        List expectedExecutionState = Arrays.asList(new String[] { "kaboom" });
        assertEquals(expectedExecutionState, testResults);
    }

    public void testClientsideHandlerFailureInOutboundPhase() throws Exception {
        System.out.println("Starting testClientsideHandlerFailureInOutboundPhase");

        OMElement payload = TestingUtils.createDummyOMElement();
        ServiceClient sender = createClient();

        AxisOperation operation =
                sender.getAxisService().getOperation(ServiceClient.ANON_OUT_IN_OP);
        ArrayList operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setPhasesOutFlow(operationSpecificPhases);
        ArrayList phaseList = operation.getPhasesOutFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                operationSpecificPhase.addHandler(new TestHandler("COut1"));
                TestHandler clientOutboundHandler = new TestHandler("COut2");
                clientOutboundHandler.shouldFail(true);
                operationSpecificPhase.addHandler(clientOutboundHandler);
                operationSpecificPhase.addHandler(new TestHandler("COut3"));
            }
        }

        try {
            OMElement result = sender.sendReceive(payload);
            fail("An expected handler failure did not occur");
        }
        catch (AxisFault e) {
        }
        List expectedExecutionState = Arrays.asList(new String[] { "COut1", "kaboom", "FCCOut1" });
        assertEquals(expectedExecutionState, testResults);

    }

    public void testClientsideHandlerFailureInInboundOperationSpecificPhase() throws Exception {
        System.out.println("Starting testClientsideHandlerFailureInInboundOperationSpecific");

        OMElement payload = TestingUtils.createDummyOMElement();
        ServiceClient sender = createClient();

        AxisOperation operation =
                sender.getAxisService().getOperation(ServiceClient.ANON_OUT_IN_OP);
        ArrayList operationSpecificPhases = new ArrayList();
        operationSpecificPhases.add(new Phase(PhaseMetadata.PHASE_POLICY_DETERMINATION));
        operation.setRemainingPhasesInFlow(operationSpecificPhases);
        ArrayList phaseList = operation.getRemainingPhasesInFlow();
        for (int i = 0; i < phaseList.size(); i++) {
            Phase operationSpecificPhase = (Phase)phaseList.get(i);
            if (PhaseMetadata.PHASE_POLICY_DETERMINATION
                    .equals(operationSpecificPhase.getPhaseName())) {
                operationSpecificPhase.addHandler(new TestHandler("CIn1"));
                TestHandler clientOutboundHandler = new TestHandler("CIn2");
                clientOutboundHandler.shouldFail(true);
                operationSpecificPhase.addHandler(clientOutboundHandler);
                operationSpecificPhase.addHandler(new TestHandler("CIn3"));
            }
        }

        try {
            OMElement result = sender.sendReceive(payload);
            fail("An expected handler failure did not occur");
        }
        catch (AxisFault e) {
        }

        List expectedExecutionState = Arrays.asList(new String[] { "In1", "In2", "In3", "In4",
                "In5", "In6", "Out1", "Out2", "Out3", "FCOut3", "FCOut2", "FCOut1", "FCIn6",
                "FCIn5", "FCIn4", "FCIn3", "FCIn2", "FCIn1", "CIn1", "kaboom", "FCCIn1" });
        assertEquals(expectedExecutionState, testResults);
    }

    private class TestHandler extends AbstractHandler {
        private String handlerName;
        private boolean shouldFail;
        private boolean shouldPause;

        public TestHandler(String handlerName) {
            this.handlerName = handlerName;
        }

        public void shouldFail(boolean fail) {
            this.shouldFail = fail;
        }

        public void shouldPause(boolean pause) {
            this.shouldPause = pause;
        }

        public InvocationResponse invoke(MessageContext msgContext) throws AxisFault {
            System.out.println("TestHandler " + handlerName + " invoked");
            if (shouldFail) {
                testResults.add("kaboom");
                System.out.println("Handler went kaboom");
                throw new AxisFault("Handler failed");
            }
            testResults.add(handlerName);
            return InvocationResponse.CONTINUE;
        }

        public void flowComplete(MessageContext msgContext) {
            System.out.println("TestHandler " + handlerName + " called for flowComplete()");
            testResults.add("FC" + handlerName);
        }
    }
}