/*
 *  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.transport.testkit;

import static org.apache.axis2.transport.testkit.AdapterUtils.adapt;

import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import org.apache.axis2.transport.testkit.channel.AsyncChannel;
import org.apache.axis2.transport.testkit.channel.RequestResponseChannel;
import org.apache.axis2.transport.testkit.client.AsyncTestClient;
import org.apache.axis2.transport.testkit.client.RequestResponseTestClient;
import org.apache.axis2.transport.testkit.endpoint.AsyncEndpoint;
import org.apache.axis2.transport.testkit.endpoint.InOutEndpoint;
import org.apache.axis2.transport.testkit.endpoint.TestEndpoint;
import org.apache.axis2.transport.testkit.message.AxisMessage;
import org.apache.axis2.transport.testkit.message.MessageDecoder;
import org.apache.axis2.transport.testkit.message.MessageEncoder;
import org.apache.axis2.transport.testkit.message.RESTMessage;
import org.apache.axis2.transport.testkit.message.XMLMessage;
import org.apache.axis2.transport.testkit.message.RESTMessage.Parameter;
import org.apache.axis2.transport.testkit.tests.async.BinaryTestCase;
import org.apache.axis2.transport.testkit.tests.async.LargeSOAPAsyncMessageTestCase;
import org.apache.axis2.transport.testkit.tests.async.RESTTestCase;
import org.apache.axis2.transport.testkit.tests.async.SwATestCase;
import org.apache.axis2.transport.testkit.tests.async.TextPlainTestCase;
import org.apache.axis2.transport.testkit.tests.async.XMLAsyncMessageTestCase;
import org.apache.axis2.transport.testkit.tests.echo.XMLRequestResponseMessageTestCase;
import org.osgi.framework.InvalidSyntaxException;

public class TransportTestSuiteBuilder {
    static class ResourceRelation<T> {
        private final T primaryResource;
        private final Object[] relatedResources;
        
        public ResourceRelation(T primaryResource, Object... relatedResources) {
            this.primaryResource = primaryResource;
            this.relatedResources = relatedResources;
        }

        public T getPrimaryResource() {
            return primaryResource;
        }

        public Object[] getRelatedResources() {
            return relatedResources;
        }
    }
    
    static class ResourceList<T> implements Iterable<ResourceRelation<T>> {
        private final List<ResourceRelation<T>> list = new LinkedList<ResourceRelation<T>>();
        
        public void add(T primaryResource, Object... relatedResources) {
            list.add(new ResourceRelation<T>(primaryResource, relatedResources));
        }

        public Iterator<ResourceRelation<T>> iterator() {
            return list.iterator();
        }
    }
    
    public static final String testString = "\u00e0 peine arriv\u00e9s nous entr\u00e2mes dans sa chambre";
    
    public static final MessageTestData ASCII_TEST_DATA = new MessageTestData("ASCII", "test string", "us-ascii");
    public static final MessageTestData UTF8_TEST_DATA = new MessageTestData("UTF8", testString, "UTF-8");
    public static final MessageTestData LATIN1_TEST_DATA = new MessageTestData("Latin1", testString, "ISO-8859-1");
    
    private static final MessageTestData[] messageTestData = new MessageTestData[] {
        ASCII_TEST_DATA,
        UTF8_TEST_DATA,
        LATIN1_TEST_DATA,
    };
    
    private static final RESTMessage restTestMessage1 = new RESTMessage(new Parameter[] {
        new Parameter("param1", "value1"),
        new Parameter("param2", "value2"),
    });
    
    private static final RESTMessage restTestMessage2 = new RESTMessage(new Parameter[] {
            new Parameter("param", "value1"),
            new Parameter("param", "value2"),
        });
    
    private final ManagedTestSuite suite;
    
    private final List<Object[]> environments = new LinkedList<Object[]>();
    
    private final ResourceList<AsyncChannel> asyncChannels = new ResourceList<AsyncChannel>();
    
    private final ResourceList<AsyncTestClient<byte[]>> byteAsyncClients = new ResourceList<AsyncTestClient<byte[]>>();
    private final ResourceList<AsyncTestClient<XMLMessage>> xmlAsyncClients = new ResourceList<AsyncTestClient<XMLMessage>>();
    private final ResourceList<AsyncTestClient<RESTMessage>> restAsyncClients = new ResourceList<AsyncTestClient<RESTMessage>>();
    private final ResourceList<AsyncTestClient<String>> stringAsyncClients = new ResourceList<AsyncTestClient<String>>();
    
    private final ResourceList<AsyncEndpoint<byte[]>> byteAsyncEndpoints = new ResourceList<AsyncEndpoint<byte[]>>();
    private final ResourceList<AsyncEndpoint<XMLMessage>> xmlAsyncEndpoints = new ResourceList<AsyncEndpoint<XMLMessage>>();
    private final ResourceList<AsyncEndpoint<RESTMessage>> restAsyncEndpoints = new ResourceList<AsyncEndpoint<RESTMessage>>();
    private final ResourceList<AsyncEndpoint<String>> stringAsyncEndpoints = new ResourceList<AsyncEndpoint<String>>();
    
    private final ResourceList<RequestResponseChannel> requestResponseChannels = new ResourceList<RequestResponseChannel>();
    
    private final ResourceList<RequestResponseTestClient<XMLMessage,XMLMessage>> xmlRequestResponseClients = new ResourceList<RequestResponseTestClient<XMLMessage,XMLMessage>>();
    
    private final ResourceList<InOutEndpoint> echoEndpoints = new ResourceList<InOutEndpoint>();
    
    public TransportTestSuiteBuilder(ManagedTestSuite suite) {
        this.suite = suite;
        try {
            // We only want tests with client and/or endpoint based on Axis
            suite.addExclude("(&(client=*)(endpoint=*)(!(|(client=axis)(endpoint=axis))))");
        } catch (InvalidSyntaxException ex) {
            throw new Error(ex);
        }
    }
    
    public void addEnvironment(Object... resources) {
        environments.add(resources);
    }
    
    public void addAsyncChannel(AsyncChannel channel, Object... relatedResources) {
        asyncChannels.add(channel, relatedResources);
    }
    
    public void addAxisAsyncTestClient(AsyncTestClient<AxisMessage> client, Object... relatedResources) {
        byteAsyncClients.add(adapt(client, MessageEncoder.BINARY_WRAPPER), relatedResources);
        xmlAsyncClients.add(adapt(client, MessageEncoder.XML_TO_AXIS), relatedResources);
        stringAsyncClients.add(adapt(client, MessageEncoder.TEXT_WRAPPER), relatedResources);
    }
    
    public void addByteArrayAsyncTestClient(AsyncTestClient<byte[]> client, Object... relatedResources) {
        byteAsyncClients.add(client, relatedResources);
        xmlAsyncClients.add(adapt(client, MessageEncoder.XML_TO_BYTE), relatedResources);
        stringAsyncClients.add(adapt(client, MessageEncoder.STRING_TO_BYTE), relatedResources);
    }
    
    public void addRESTAsyncTestClient(AsyncTestClient<RESTMessage> client, Object... relatedResources) {
        restAsyncClients.add(client, relatedResources);
    }
    
    public void addStringAsyncTestClient(AsyncTestClient<String> client, Object... relatedResources) {
        xmlAsyncClients.add(adapt(client, MessageEncoder.XML_TO_STRING), relatedResources);
        stringAsyncClients.add(client, relatedResources);
    }
    
    public void addAxisAsyncEndpoint(AsyncEndpoint<AxisMessage> endpoint, Object... relatedResources) {
        byteAsyncEndpoints.add(adapt(endpoint, MessageDecoder.AXIS_TO_BYTE), relatedResources);
        xmlAsyncEndpoints.add(adapt(endpoint, MessageDecoder.AXIS_TO_XML), relatedResources);
        restAsyncEndpoints.add(adapt(endpoint, MessageDecoder.AXIS_TO_REST), relatedResources);
        stringAsyncEndpoints.add(adapt(endpoint, MessageDecoder.AXIS_TO_STRING), relatedResources);
    }
    
    public void addByteArrayAsyncEndpoint(AsyncEndpoint<byte[]> endpoint, Object... relatedResources) {
        byteAsyncEndpoints.add(endpoint, relatedResources);
        xmlAsyncEndpoints.add(adapt(endpoint, MessageDecoder.BYTE_TO_XML), relatedResources);
        stringAsyncEndpoints.add(adapt(endpoint, MessageDecoder.BYTE_TO_STRING), relatedResources);
    }
    
    public void addRESTAsyncEndpoint(AsyncEndpoint<RESTMessage> endpoint, Object... relatedResources) {
        restAsyncEndpoints.add(endpoint, relatedResources);
    }
    
    public void addRequestResponseChannel(RequestResponseChannel channel, Object... relatedResources) {
        requestResponseChannels.add(channel, relatedResources);
    }
    
    public void addAxisRequestResponseTestClient(RequestResponseTestClient<AxisMessage,AxisMessage> client, Object... relatedResources) {
        xmlRequestResponseClients.add(adapt(client, MessageEncoder.XML_TO_AXIS, MessageDecoder.AXIS_TO_XML), relatedResources);
    }
    
    public void addByteArrayRequestResponseTestClient(RequestResponseTestClient<byte[],byte[]> client, Object... relatedResources) {
        xmlRequestResponseClients.add(adapt(client, MessageEncoder.XML_TO_BYTE, MessageDecoder.BYTE_TO_XML), relatedResources);
    }
    
    public void addStringRequestResponseTestClient(RequestResponseTestClient<String,String> client, Object... relatedResources) {
        xmlRequestResponseClients.add(adapt(client, MessageEncoder.XML_TO_STRING, MessageDecoder.STRING_TO_XML), relatedResources);
    }
    
    public void addEchoEndpoint(InOutEndpoint endpoint, Object... relatedResources) {
        echoEndpoints.add(endpoint, relatedResources);
    }
    
    private Object[] merge(Object[] environment, ResourceRelation<?>... resourceRelations) {
        Set<Object> resources = new LinkedHashSet<Object>();
        resources.addAll(Arrays.asList(environment));
        for (ResourceRelation<?> resourceRelation : resourceRelations) {
            resources.addAll(Arrays.asList(resourceRelation.getRelatedResources()));
        }
        return resources.toArray();
    }
    
    private void build(Object[] env) {
        for (ResourceRelation<AsyncChannel> channel : asyncChannels) {
            for (ResourceRelation<AsyncTestClient<XMLMessage>> client : xmlAsyncClients) {
                for (ResourceRelation<AsyncEndpoint<XMLMessage>> endpoint : xmlAsyncEndpoints) {
                    Object[] resources = merge(env, channel, client, endpoint);
                    for (MessageTestData data : messageTestData) {
                        for (XMLMessage.Type type : XMLMessage.Type.values()) {
                            if (type != XMLMessage.Type.SWA) {
                                suite.addTest(new XMLAsyncMessageTestCase(channel.getPrimaryResource(), client.getPrimaryResource(), endpoint.getPrimaryResource(), type, data, resources));
                            }
                        }
                    }
                    suite.addTest(new SwATestCase(channel.getPrimaryResource(), client.getPrimaryResource(), endpoint.getPrimaryResource(), resources));
                    // Regression test for SYNAPSE-423:
                    suite.addTest(new LargeSOAPAsyncMessageTestCase(channel.getPrimaryResource(), client.getPrimaryResource(), endpoint.getPrimaryResource(), resources));
                }
            }
            for (ResourceRelation<AsyncTestClient<String>> client : stringAsyncClients) {
                for (ResourceRelation<AsyncEndpoint<String>> endpoint : stringAsyncEndpoints) {
                    Object[] resources = merge(env, channel, client, endpoint);
                    for (MessageTestData data : messageTestData) {
                        suite.addTest(new TextPlainTestCase(channel.getPrimaryResource(), client.getPrimaryResource(), endpoint.getPrimaryResource(), data, resources));
                    }
                }
            }
            for (ResourceRelation<AsyncTestClient<byte[]>> client : byteAsyncClients) {
                for (ResourceRelation<AsyncEndpoint<byte[]>> endpoint : byteAsyncEndpoints) {
                    Object[] resources = merge(env, channel, client, endpoint);
                    suite.addTest(new BinaryTestCase(channel.getPrimaryResource(), client.getPrimaryResource(), endpoint.getPrimaryResource(), resources));
                }
            }
            for (ResourceRelation<AsyncTestClient<RESTMessage>> client : restAsyncClients) {
                for (ResourceRelation<AsyncEndpoint<RESTMessage>> endpoint : restAsyncEndpoints) {
                    Object[] resources = merge(env, channel, client, endpoint);
                    suite.addTest(new RESTTestCase(channel.getPrimaryResource(), client.getPrimaryResource(), endpoint.getPrimaryResource(), restTestMessage1, resources));
                    // TODO: regression test for SYNAPSE-431
//                    addTest(new RESTTestCase(env, channel, client, endpoint, restTestMessage2));
                }
            }
        }
        for (ResourceRelation<RequestResponseChannel> channel : requestResponseChannels) {
            for (ResourceRelation<RequestResponseTestClient<XMLMessage,XMLMessage>> client : xmlRequestResponseClients) {
                for (ResourceRelation<InOutEndpoint> endpoint : echoEndpoints) {
                    Object[] resources = merge(env, channel, client, endpoint);
                    for (MessageTestData data : messageTestData) {
                        for (XMLMessage.Type type : XMLMessage.Type.values()) {
                            if (type != XMLMessage.Type.SWA) {
                                suite.addTest(new XMLRequestResponseMessageTestCase(channel.getPrimaryResource(), client.getPrimaryResource(), endpoint.getPrimaryResource(), type, data, resources));
                            }
                        }
                    }
                }
            }
        }
    }
    
    public void build() {
        if (environments.isEmpty()) {
            build(new Object[0]);
        } else {
            for (Object[] env : environments) {
                build(env);
            }
        }
    }
}
