/*
 *  Copyright (c) 2005-2008, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
 *
 *  WSO2 Inc. 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.wso2.carbon.mediation.initializer;

import org.apache.synapse.mediators.base.SequenceMediator;
import org.apache.synapse.core.axis2.ProxyService;
import org.apache.synapse.endpoints.AddressEndpoint;
import org.apache.synapse.endpoints.Endpoint;
import org.apache.synapse.config.SynapseConfiguration;
import org.apache.synapse.config.SynapseConfigurationBuilder;
import org.apache.synapse.config.xml.MultiXMLConfigurationSerializer;
import org.apache.synapse.config.xml.XMLConfigurationBuilder;
import org.apache.synapse.config.xml.ProxyServiceFactory;
import org.apache.synapse.config.xml.SequenceMediatorFactory;
import org.apache.synapse.config.xml.endpoints.EndpointFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.impl.builder.StAXOMBuilder;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.AxisFault;
import org.wso2.carbon.mediation.initializer.services.SynapseConfigurationService;
import org.wso2.carbon.mediation.initializer.services.SynapseConfigurationServiceImpl;
import org.wso2.carbon.mediation.initializer.persistence.MediationPersistenceManager;
import junit.framework.TestCase;
import org.wso2.carbon.utils.multitenancy.MultitenantConstants;

import javax.xml.stream.XMLStreamException;
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Map;
import java.util.Properties;

public abstract class MediationPersistenceTest extends TestCase {

    protected String path = System.getProperty("basedir") + File.separator + "target" +
            File.separator + "synapse-config";

    protected SynapseConfigurationService synapseConfigSvc;

    public void setUp() {
        File tmpDir = new File(System.getProperty("basedir") + File.separator + "target" +
                File.separator + "tmp");
        if (!tmpDir.exists()) {
            tmpDir.mkdirs();
        }
        System.setProperty("java.io.tmpdir", tmpDir.getAbsolutePath());
        SynapseConfiguration synapseConfig = SynapseConfigurationBuilder.getDefaultConfiguration();
        synapseConfig.setAxisConfiguration(new AxisConfiguration());
        MultiXMLConfigurationSerializer serializer = new MultiXMLConfigurationSerializer(path);
        serializer.serialize(synapseConfig);
        synapseConfigSvc = new SynapseConfigurationServiceImpl(synapseConfig,
                MultitenantConstants.SUPER_TENANT_ID, null);
        /*getMediationPersistenceManager().init(null, path,
                synapseConfigSvc.getSynapseConfiguration(), 500L);*/
    }
    
    protected SynapseConfiguration getConfigurationFromSynapseXML() {
        try {
            FileInputStream fin = new FileInputStream(path + File.separator + "synapse.xml");
            return XMLConfigurationBuilder.getConfiguration(fin, new Properties());
        } catch (FileNotFoundException e) {
            fail("The synapse.xml file does not exist");
        } catch (XMLStreamException e) {
            fail("Error parsing the synapse.xml");
        }
        return null;
    }

    protected void tearDown() throws Exception {
        getMediationPersistenceManager().destroy();
    }

    protected void assertEquals(SequenceMediator expected, SequenceMediator actual) {

        if (expected != null && actual != null) {
            if (expected.getName() == null) {
                assertNull(actual.getName());
            } else {
                assertEquals(expected.getName(), actual.getName());
            }

            assertEquals(expected.getList().size(), actual.getList().size());
            for (int i = 0; i < expected.getList().size(); i++) {
                assertEquals(expected.getChild(i).getClass(), actual.getChild(i).getClass());
            }
            return;

        } else if (expected == null) {
            assertNull(actual);
            return;

        }
        fail("Sequences do not match");
    }

    protected void assertEquals(Endpoint expected, Endpoint actual) {
        if (expected != null && actual != null) {
            if (expected.getName() == null) {
                assertNull(actual.getName());
            } else {
                assertEquals(expected.getName(), actual.getName());
            }

            if (expected instanceof AddressEndpoint && actual instanceof AddressEndpoint) {
                AddressEndpoint original = (AddressEndpoint) expected;
                AddressEndpoint copy = (AddressEndpoint) actual;
                assertEquals(original.getDefinition().getAddress(), copy.getDefinition().getAddress());
                return;
            }

            // TODO: Implement support for comparing other types of endpoints
            // TODO: For the moment we can live with only address endpoints

        } else if (expected == null) {
            assertNull(actual);
            return;
        }
        fail("Endpoints do not match");
    }

    protected void assertEquals(ProxyService expected, ProxyService actual) {
        if (expected != null && actual != null) {
            assertEquals(expected.getName(), actual.getName());
            assertEquals(expected.getTargetInLineInSequence(), actual.getTargetInLineInSequence());
            assertEquals(expected.getTargetInLineOutSequence(), actual.getTargetInLineOutSequence());
            assertEquals(expected.getTargetInLineFaultSequence(), actual.getTargetInLineFaultSequence());
            assertEquals(expected.getTargetInLineEndpoint(), actual.getTargetInLineEndpoint());
            Map<String,Object> params = expected.getParameterMap();
            if (params != null) {
                assertEquals(params.size(), actual.getParameterMap().size());
                for (String key : params.keySet()) {
                    assertEquals(params.get(key), actual.getParameterMap().get(key));
                }
            } else {
                assertNull(actual.getParameterMap());
            }
            return;

        } else if (expected == null) {
            assertNull(actual);
            return;
        }

        fail("Proxy services do not match");
    }

    protected void hold() {
        try {
            Thread.sleep(2500);
        } catch (InterruptedException ignore) {

        }
    }

    protected OMElement parse(InputStream in) {
        try {
            StAXOMBuilder builder = new StAXOMBuilder(in);
            return builder.getDocumentElement();
        } catch (XMLStreamException e) {
            fail("Error while parsing the XML from the input stream");
            return null;
        }
    }

    protected Endpoint createEndpoint(InputStream in) {
        return EndpointFactory.getEndpointFromElement(parse(in), false, new Properties());
    }

    protected SequenceMediator createSequence(InputStream in) {
        SequenceMediatorFactory factory = new SequenceMediatorFactory();
        return (SequenceMediator) factory.createMediator(parse(in), new Properties());
    }

    protected ProxyService createProxy(InputStream in) {
        return ProxyServiceFactory.createProxy(parse(in), new Properties());
    }

    /**
     * Helper method to get the persistence manger
     * @return persistence manager for this configuration context
     */
    protected MediationPersistenceManager getMediationPersistenceManager() {
        Parameter p = synapseConfigSvc.getSynapseConfiguration().
                getAxisConfiguration().getParameter(
                ServiceBusConstants.PERSISTENCE_MANAGER);
        if (p != null) {
            return (MediationPersistenceManager) p.getValue();
        } else {
            MediationPersistenceManager persistenceManager =
                    new MediationPersistenceManager(path,
                            synapseConfigSvc.getSynapseConfiguration(), 100, "synapse-config");

            try {
                synapseConfigSvc.getSynapseConfiguration().getAxisConfiguration().addParameter(
                    new Parameter(ServiceBusConstants.PERSISTENCE_MANAGER, persistenceManager));
            } catch (AxisFault ignored) { }

            return persistenceManager;
        }
    }

}
