/*
 * 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.tuscany.sca.binding.erlang.testing;

import static org.junit.Assert.assertEquals;

import java.io.IOException;

import org.apache.tuscany.sca.binding.erlang.impl.TypeMismatchException;
import org.apache.tuscany.sca.host.embedded.SCADomain;
import org.junit.BeforeClass;
import org.junit.Test;

import com.ericsson.otp.erlang.OtpErlangAtom;
import com.ericsson.otp.erlang.OtpErlangDouble;
import com.ericsson.otp.erlang.OtpErlangList;
import com.ericsson.otp.erlang.OtpErlangLong;
import com.ericsson.otp.erlang.OtpErlangString;
import com.ericsson.otp.erlang.OtpErlangTuple;
import com.ericsson.otp.erlang.OtpMbox;
import com.ericsson.otp.erlang.OtpNode;

public class ReferenceServiceTestCase {

    private static MboxInterface mboxReference;
    private static ServiceTestComponent moduleReference;
    private static OtpNode node;
    private static OtpMbox mbox;

    @BeforeClass
    public static void init() throws IOException {
        SCADomain domain = SCADomain.newInstance("ErlangReference.composite");
        SCADomain.newInstance("ErlangService.composite");
        ReferenceTestComponentImpl component = domain.getService(ReferenceTestComponentImpl.class, "ReferenceTest");
        mboxReference = component.getMboxReference();
        moduleReference = component.getModuleReference();
        node = new OtpNode("MboxServer");
        mbox = node.createMbox("sendArgs");
    }

    @Test
    public void testStrings() throws Exception {
        String strArg = "Test message";
        String strResult = "OK";
        MboxListener mboxListener = new MboxListener(mbox, strResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        String testResult = mboxReference.sendArgs(strArg);
        assertEquals(strArg, ((OtpErlangString)mboxListener.getMsg().getMsg()).stringValue());
        assertEquals(strResult, testResult);
    }

    @Test
    public void testBooleans() throws Exception {
        boolean booleanArg = true;
        boolean booleanResult = false;
        MboxListener mboxListener = new MboxListener(mbox, booleanResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        boolean testResult = mboxReference.sendArgs(booleanArg);
        assertEquals(booleanArg, ((OtpErlangAtom)mboxListener.getMsg().getMsg()).booleanValue());
        assertEquals(booleanResult, testResult);
    }

    @Test
    public void testFloats() throws Exception {
        float floatArg = 1.0f;
        float floatResult = 2.0f;
        MboxListener mboxListener = new MboxListener(mbox, floatResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        float testResult = mboxReference.sendArgs(floatArg);
        assertEquals(floatArg, ((OtpErlangDouble)mboxListener.getMsg().getMsg()).doubleValue(), 0);
        assertEquals(floatResult, testResult, 0);
    }

    @Test
    public void testDoubles() throws Exception {
        double doubleArg = 1.0f;
        double doubleResult = 2.0f;
        MboxListener mboxListener = new MboxListener(mbox, doubleResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        double testResult = mboxReference.sendArgs(doubleArg);
        assertEquals(doubleArg, ((OtpErlangDouble)mboxListener.getMsg().getMsg()).doubleValue(), 0);
        assertEquals(doubleResult, testResult, 0);
    }

    @Test
    public void testLongs() throws Exception {
        long longArg = 1;
        long longResult = 2;
        MboxListener mboxListener = new MboxListener(mbox, longResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        long testResult = mboxReference.sendArgs(longArg);
        assertEquals(longArg, ((OtpErlangLong)mboxListener.getMsg().getMsg()).longValue(), 0);
        assertEquals(longResult, testResult, 0);
    }

    @Test
    public void testInts() throws Exception {
        int intArg = 1;
        int intResult = 2;
        MboxListener mboxListener = new MboxListener(mbox, intResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        int testResult = mboxReference.sendArgs(intArg);
        assertEquals(intArg, ((OtpErlangLong)mboxListener.getMsg().getMsg()).intValue(), 0);
        assertEquals(intResult, testResult, 0);
    }

    @Test
    public void testChars() throws Exception {
        char charArg = 1;
        char charResult = 2;
        MboxListener mboxListener = new MboxListener(mbox, charResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        char testResult = mboxReference.sendArgs(charArg);
        assertEquals(charArg, ((OtpErlangLong)mboxListener.getMsg().getMsg()).charValue(), 0);
        assertEquals(charResult, testResult, 0);
    }

    @Test
    public void testShorts() throws Exception {
        short shortArg = 1;
        short shortResult = 2;
        MboxListener mboxListener = new MboxListener(mbox, shortResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        short testResult = mboxReference.sendArgs(shortArg);
        assertEquals(shortArg, ((OtpErlangLong)mboxListener.getMsg().getMsg()).shortValue(), 0);
        assertEquals(shortResult, testResult, 0);
    }

    @Test
    public void testBytes() throws Exception {
        byte byteArg = 1;
        byte byteResult = 2;
        MboxListener mboxListener = new MboxListener(mbox, byteResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        byte testResult = mboxReference.sendArgs(byteArg);
        assertEquals(byteArg, ((OtpErlangLong)mboxListener.getMsg().getMsg()).byteValue(), 0);
        assertEquals(byteResult, testResult, 0);
    }

    @Test
    public void testMultipleArguments() throws Exception {
        MboxListener mboxListener = new MboxListener(mbox, true);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        String testString = "TupleString";
        int testInt = 10;
        mboxReference.sendArgs(testInt, testString);
        assertEquals(testInt, ((OtpErlangLong)((OtpErlangTuple)mboxListener.getMsg().getMsg()).elementAt(0))
            .longValue());
        assertEquals(testString, ((OtpErlangString)((OtpErlangTuple)mboxListener.getMsg().getMsg()).elementAt(1))
            .stringValue());
    }

    @Test
    public void testTuples() throws Exception {
        StructuredTuple tupleResult = new StructuredTuple();
        tupleResult.arg1.arg1 = 1;
        tupleResult.arg1.arg2 = "Tuple inside tuple";
        tupleResult.arg2 = "Tuple!";
        tupleResult.arg3 = true;
        MboxListener mboxListener = new MboxListener(mbox, tupleResult);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        StructuredTuple testArg = new StructuredTuple();
        testArg.arg2 = "Arg2a";
        testArg.arg3 = true;
        testArg.arg1.arg1 = 10;
        testArg.arg1.arg2 = "Arg2b";
        StructuredTuple testResult = mboxReference.sendArgs(testArg);
        assertEquals(tupleResult, testResult);
        OtpErlangTuple received = (OtpErlangTuple)mboxListener.getMsg().getMsg();
        assertEquals(testArg.arg1.arg1, ((OtpErlangLong)((OtpErlangTuple)received.elementAt(0)).elementAt(0))
            .longValue());
        assertEquals(testArg.arg1.arg2, ((OtpErlangString)((OtpErlangTuple)received.elementAt(0)).elementAt(1))
            .stringValue());
        assertEquals(testArg.arg2, ((OtpErlangString)received.elementAt(1)).stringValue());
        assertEquals(testArg.arg3, ((OtpErlangAtom)received.elementAt(2)).booleanValue());
    }

    @Test
    public void testLists() throws Exception {
        String[] testArg = new String[] {"One", "Two", "Three"};
        MboxListener mboxListener = new MboxListener(mbox, testArg);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        String[] testResult = mboxReference.sendArgs(testArg);
        assertEquals(testArg.length, testResult.length);
        for (int i = 0; i < testArg.length; i++) {
            assertEquals(testArg[i], testResult[i]);
        }
        OtpErlangList received = (OtpErlangList)mboxListener.getMsg().getMsg();
        assertEquals(testArg.length, received.arity());
        for (int i = 0; i < testArg.length; i++) {
            assertEquals(testArg[i], ((OtpErlangString)received.elementAt(i)).stringValue());
        }
    }

    @Test
    public void testMultiDimLists() throws Exception {
        String[][] testArg = new String[][] { {"One", "Two"}, {"Three", "Four", "Five"}, {"Six"}};
        MboxListener mboxListener = new MboxListener(mbox, testArg);
        Thread mboxThread = new Thread(mboxListener);
        mboxThread.start();
        String[][] testResult = mboxReference.sendArgs(testArg);
        assertEquals(testArg.length, testResult.length);
        for (int i = 0; i < testArg.length; i++) {
            for (int j = 0; j < testArg[i].length; j++) {
                assertEquals(testArg[i][j], testResult[i][j]);
            }
        }
        OtpErlangList received = (OtpErlangList)mboxListener.getMsg().getMsg();
        assertEquals(testArg.length, received.arity());
        for (int i = 0; i < testArg.length; i++) {
            for (int j = 0; j < testArg[i].length; j++) {
                assertEquals(testArg[i][j], (((OtpErlangString)((OtpErlangList)received.elementAt(i)).elementAt(j))
                    .stringValue()));
            }
        }
    }

    @Test
    public void typeMismatch() throws Exception {
        try {
            StructuredTuple arg = new StructuredTuple();
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            String[] arg = new String[] {"test"};
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            long arg = 1;
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            int arg = 1;
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            short arg = 1;
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            char arg = 1;
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            byte arg = 1;
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            double arg = 1;
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            float arg = 1;
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            String arg = "1";
            MboxListener mboxListener = new MboxListener(mbox, true);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }

        try {
            boolean arg = true;
            MboxListener mboxListener = new MboxListener(mbox, 1);
            Thread mboxThread = new Thread(mboxListener);
            mboxThread.start();
            mboxReference.sendArgs(arg);
        } catch (Exception e) {
            assertEquals(TypeMismatchException.class, e.getClass());
            System.out.println(e.getMessage());
        }
    }

    @Test
    public void testRPC() throws Exception {
        String[] result = moduleReference.sayHellos();
        assertEquals(2, result.length);
        assertEquals("1", result[0]);
        assertEquals("2", result[1]);
    }

    @Test
    public void testRPCWithArgs() throws Exception {
        String arg1 = "One";
        String arg2 = "Two";
        String testResult = moduleReference.sayHello(arg1, arg2);
        assertEquals("Hello " + arg1 + " " + arg2, testResult);
    }
    
    @Test
    public void testRPCWithComplexArgs() throws Exception {
        StructuredTuple arg = new StructuredTuple();
        arg.arg1.arg2 = "Not empty";
        arg.arg2 = "Not empty";
        StructuredTuple testResult = moduleReference.passComplexArgs(arg, new String[]{"some", "array"});
        assertEquals(arg, testResult);
    }

}