/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed 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 samples.echo ;

import org.apache.axis.AxisFault;
import org.apache.axis.client.Stub;
import org.apache.axis.types.HexBinary;
import org.apache.axis.types.NegativeInteger;
import org.apache.axis.types.NonNegativeInteger;
import org.apache.axis.types.NonPositiveInteger;
import org.apache.axis.types.NormalizedString;
import org.apache.axis.types.PositiveInteger;
import org.apache.axis.types.Token;
import org.apache.axis.types.UnsignedByte;
import org.apache.axis.types.UnsignedInt;
import org.apache.axis.types.UnsignedLong;
import org.apache.axis.types.UnsignedShort;
import org.apache.axis.utils.JavaUtils;
import org.apache.axis.utils.Options;

import javax.xml.rpc.holders.FloatHolder;
import javax.xml.rpc.holders.IntHolder;
import javax.xml.rpc.holders.StringHolder;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;


/**
 * Test Client for the echo interop service.  See the main entrypoint
 * for more details on usage.
 *
 * @author Sam Ruby <rubys@us.ibm.com>
 * Modified to use WSDL2Java generated stubs and artifacts by
 * @author Rich Scheuerle <scheu@us.ibm.com>
 */
public abstract class TestClient {

    private static InteropTestPortType binding = null;

    /**
     * When testMode is true, we throw exceptions up to the caller
     * instead of recording them and continuing.
     */
    private boolean testMode = false;

    public TestClient() {
    }

    /**
     * Constructor which sets testMode
     */
    public TestClient(boolean testMode) {
        this.testMode = testMode;
    }

    /**
     * Determine if two objects are equal.  Handles nulls and recursively
     * verifies arrays are equal.  Accepts dates within a tolerance of
     * 999 milliseconds.
     */
    protected boolean equals(Object obj1, Object obj2) {
       if (obj1 == null || obj2 == null) return (obj1 == obj2);
       if (obj1.equals(obj2)) return true;

       // For comparison purposes, get the array of bytes representing
        // the HexBinary object.
       if (obj1 instanceof HexBinary) {
           obj1 = ((HexBinary) obj1).getBytes();
       }
       if (obj2 instanceof HexBinary) {
           obj2 = ((HexBinary) obj2).getBytes();
       }

       if (obj1 instanceof Calendar && obj2 instanceof Calendar) {
           if (Math.abs(((Calendar)obj1).getTime().getTime() - ((Calendar)obj2).getTime().getTime()) < 1000) {
               return true;
           }
       }

       if ((obj1 instanceof Map) && (obj2 instanceof Map)) {
           Map map1 = (Map)obj1;
           Map map2 = (Map)obj2;
           Set keys1 = map1.keySet();
           Set keys2 = map2.keySet();
           if (!(keys1.equals(keys2))) return false;

           // Check map1 is a subset of map2.
           Iterator i = keys1.iterator();
           while (i.hasNext()) {
               Object key = i.next();
               if (!equals(map1.get(key), map2.get(key)))
                   return false;
           }

           // Check map2 is a subset of map1.
           Iterator j = keys2.iterator();
           while (j.hasNext()) {
               Object key = j.next();
               if (!equals(map1.get(key), map2.get(key)))
                   return false;
           }
           return true;
       }

       if (obj1 instanceof List)
         obj1 = JavaUtils.convert(obj1, Object[].class);
       if (obj2 instanceof List)
         obj2 = JavaUtils.convert(obj2, Object[].class);

       if (!obj2.getClass().isArray()) return false;
       if (!obj1.getClass().isArray()) return false;
       if (Array.getLength(obj1) != Array.getLength(obj2)) return false;
       for (int i=0; i<Array.getLength(obj1); i++)
           if (!equals(Array.get(obj1,i),Array.get(obj2,i))) return false;
       return true;
    }

    /**
     * Set up the call object.
     */
    public void setURL(String url)
        throws AxisFault
    {
        try {
            binding = new InteropTestServiceLocator().
                getecho(new java.net.URL(url));

            // safety first
            ((InteropTestSoapBindingStub)binding).setTimeout(60000);
            ((InteropTestSoapBindingStub)binding).setMaintainSession(true);
        } catch (Exception exp) {
            throw AxisFault.makeFault(exp);
        }
    }

    void setUser(String user) {
        ((Stub)binding).setUsername(user);
    }

    void setPassword(String password) {
        ((Stub)binding).setPassword(password);        
    }

    /**
     * Execute all tests.
     */
    public void executeAll() throws Exception {
        execute2A();
        execute2B();
        executeAxisXSD();
    }

    /**
     * Test custom mapping of xsd types not standardized:  xsd:token and
     * xsd:normalizedString.
     */
    public void executeAxisXSD() throws Exception {
        Object output = null;

        // Test xsd:token
        Token tInput = new Token("abccdefg");
        try {
            output = binding.echoToken(tInput);
            verify("echoToken", tInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoToken", tInput, e);
            } else {
                throw e;
            }
        }

        // Test xsd:normalizedString
        NormalizedString nsInput = new NormalizedString("abccdefg");
        try {
            output = binding.echoNormalizedString(nsInput);
            verify("echoNormalizedString", nsInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoNormalizedString", nsInput, e);
            } else {
                throw e;
            }
        }

        // Test xsd:unsignedLong
        UnsignedLong ulInput = new UnsignedLong(100);
        try {
            output = binding.echoUnsignedLong(ulInput);
            verify("echoUnsignedLong", ulInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoUnsignedLong", ulInput, e);
            } else {
                throw e;
            }
        }

        // Test xsd:unsignedInt
        UnsignedInt uiInput = new UnsignedInt(101);
        try {
            output = binding.echoUnsignedInt(uiInput);
            verify("echoUnsignedInt", uiInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoUnsignedInt", uiInput, e);
            } else {
                throw e;
            }
        }

        // Test xsd:unsignedShort
        UnsignedShort usInput = new UnsignedShort(102);
        try {
            output = binding.echoUnsignedShort(usInput);
            verify("echoUnsignedShort", usInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoUnsignedShort", usInput, e);
            } else {
                throw e;
            }
        }

        // Test xsd:unsignedByte
        UnsignedByte ubInput = new UnsignedByte(103);
        try {
            output = binding.echoUnsignedByte(ubInput);
            verify("echoUnsignedByte", ubInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoUnsignedByte", ubInput, e);
            } else {
                throw e;
            }
        }

        // Test xsd:nonNegativeInteger
        NonNegativeInteger nniInput = new NonNegativeInteger("12345678901234567890");
        try {
            output = binding.echoNonNegativeInteger(nniInput);
            verify("echoNonNegativeInteger", nniInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoNonNegativeInteger", nniInput, e);
            } else {
                throw e;
            }
        }

        // Test xsd:positiveInteger
        PositiveInteger piInput = new PositiveInteger("12345678901234567890");
        try {
            output = binding.echoPositiveInteger(piInput);
            verify("echoPositiveInteger", piInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoPositiveInteger", piInput, e);
            } else {
                throw e;
            }
        }

        // Test xsd:nonPositiveInteger
        NonPositiveInteger npiInput = new NonPositiveInteger("-12345678901234567890");
        try {
            output = binding.echoNonPositiveInteger(npiInput);
            verify("echoNonPositiveInteger", npiInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoNonPositiveInteger", npiInput, e);
            } else {
                throw e;
            }
        }
        
        // Test xsd:negativeInteger
        NegativeInteger niInput = new NegativeInteger("-12345678901234567890");
        try {
            output = binding.echoNegativeInteger(niInput);
            verify("echoNegativeInteger", niInput, output);
        } catch (Exception e) {
            if (!testMode) {
                verify("echoNegativeInteger", niInput, e);
            } else {
                throw e;
            }
        }

    }

    /**
     * Execute the 2A tests
     */
    public void execute2A() throws Exception {
        // execute the tests
        Object output = null;

        {
            String input = "abccdefg";
            try {
                output = binding.echoString(input);
                verify("echoString", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoString", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            String[] input = new String[] {"abc", "def"};
            try {
                output = binding.echoStringArray(input);
                verify("echoStringArray", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoStringArray", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            Integer input = new Integer(42);
            try {
                output = new Integer( binding.echoInteger(input.intValue()));
                verify("echoInteger", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoInteger", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            int[] input = new int[] {42};
            try {
                output = binding.echoIntegerArray(input);
                verify("echoIntegerArray", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoIntegerArray", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            Float input = new Float(3.7F);
            try {
                output = new Float(binding.echoFloat(input.floatValue()));
                verify("echoFloat", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoFloat", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            float[] input = new float[] {3.7F, 7F};
            try {
                output = binding.echoFloatArray(input);
                verify("echoFloatArray", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoFloatArray", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            SOAPStruct input = new SOAPStruct();
            input.setVarInt(5);
            input.setVarString("Hello");
            input.setVarFloat(103F);
            try {
                output = binding.echoStruct(input);
                verify("echoStruct", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoStruct", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            SOAPStruct[] input = new SOAPStruct[] {
                new SOAPStruct(),
                new SOAPStruct(),
                new SOAPStruct()};
            input[0].setVarInt(1);
            input[0].setVarString("one");
            input[0].setVarFloat(1.1F);
            input[1].setVarInt(2);
            input[1].setVarString("two");
            input[1].setVarFloat(2.2F);
            input[2].setVarInt(3);
            input[2].setVarString("three");
            input[2].setVarFloat(3.3F);

            try {
                output = binding.echoStructArray(input);
                verify("echoStructArray", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoStructArray", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            try {
                binding.echoVoid();
                verify("echoVoid", null, null);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoVoid", null, e);
                } else {
                    throw e;
                }
            }
        }

        {
            byte[] input = "Base64".getBytes();
            try {
                output = binding.echoBase64(input);
                verify("echoBase64", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoBase64", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            HexBinary input = new HexBinary("3344");
            try {
                output = binding.echoHexBinary(input.getBytes());
                verify("echoHexBinary", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoHexBinary", input, e);
                } else {
                    throw e;
                }
            }
        }
        Calendar inputDate = Calendar.getInstance();
        inputDate.setTimeZone(TimeZone.getTimeZone("GMT"));
        inputDate.setTime(new Date());
        {
            try {
                output = binding.echoDate(inputDate);
                verify("echoDate", inputDate, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoDate", inputDate, e);
                } else {
                    throw e;
                }
            }
        }

        {
            BigDecimal input = new BigDecimal("3.14159");
            try {
                output = binding.echoDecimal(input);
                verify("echoDecimal", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoDecimal", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            Boolean input = Boolean.TRUE;
            try {
                output = new Boolean( binding.echoBoolean(input.booleanValue()));
                verify("echoBoolean", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoBoolean", input, e);
                } else {
                    throw e;
                }
            }
        }

        HashMap map = new HashMap();
        map.put(new Integer(5), "String Value");
        map.put("String Key", inputDate);
        {
            HashMap input = map;
            try {
                output = binding.echoMap(input);
                verify("echoMap", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoMap", input, e);
                } else {
                    throw e;
                }
            }
        }

        HashMap map2 = new HashMap();
        map2.put("this is the second map", new Boolean(true));
        map2.put("test", new Float(411));
        {
            HashMap[] input = new HashMap [] {map, map2 };
            try {
                output = binding.echoMapArray(input);
                verify("echoMapArray", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoMapArray", input, e);
                } else {
                    throw e;
                }
            }
        }
    }

    /**
     * Execute the 2B tests
     */
    public void execute2B() throws Exception {
        // execute the tests
        Object output = null;
        {
            SOAPStruct input = new SOAPStruct();
            input.setVarInt(5);
            input.setVarString("Hello");
            input.setVarFloat(103F);
            try {
                StringHolder outputString = new StringHolder();
                IntHolder outputInteger = new IntHolder();
                FloatHolder outputFloat = new FloatHolder();
                binding.echoStructAsSimpleTypes(input, outputString,
                                                 outputInteger, outputFloat);
                output = new SOAPStruct();
                ((SOAPStruct)output).setVarInt(outputInteger.value);
                ((SOAPStruct)output).setVarString(outputString.value);
                ((SOAPStruct)output).setVarFloat(outputFloat.value);
                verify("echoStructAsSimpleTypes",
                       input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoStructAsSimpleTypes", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            SOAPStruct input = new SOAPStruct();
            input.setVarInt(5);
            input.setVarString("Hello");
            input.setVarFloat(103F);
            try {
                output = binding.echoSimpleTypesAsStruct(
                   input.getVarString(), input.getVarInt(), input.getVarFloat());
                verify("echoSimpleTypesAsStruct",
                       input,
                       output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoSimpleTypesAsStruct", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            String[][] input = new String[2][2];
            input[0][0] = "00";
            input[0][1] = "01";
            input[1][0] = "10";
            input[1][1] = "11";
            try {
                output = binding.echo2DStringArray(input);
                verify("echo2DStringArray",
                       input,
                       output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echo2DStringArray", input, e);
                } else {
                    throw e;
                }
            }
        }

        {
            SOAPStruct inputS =new SOAPStruct();
            inputS.setVarInt(5);
            inputS.setVarString("Hello");
            inputS.setVarFloat(103F);
            SOAPStructStruct input = new SOAPStructStruct();
            input.setVarString("AXIS");
            input.setVarInt(1);
            input.setVarFloat(3F);
            input.setVarStruct(inputS);
            try {
                output = binding.echoNestedStruct(input);
                verify("echoNestedStruct", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoNestedStruct", input, e);
                } else {
                    throw e;
                }
            }
        }
        {
            SOAPArrayStruct input = new SOAPArrayStruct();
            input.setVarString("AXIS");
            input.setVarInt(1);
            input.setVarFloat(3F);
            input.setVarArray(new String[] {"one", "two", "three"});
            try {
                output = binding.echoNestedArray(input);
                verify("echoNestedArray", input, output);
            } catch (Exception e) {
                if (!testMode) {
                    verify("echoNestedArray", input, e);
                } else {
                    throw e;
                }
            }
        }
    }

    /**
     * Verify that the object sent was, indeed, the one you got back.
     * Subclasses are sent to override this with their own output.
     */
    protected abstract void verify(String method, Object sent, Object gotBack);

    /**
     * Main entry point.  Tests a variety of echo methods and reports
     * on their results.
     *
     * Arguments are of the form:
     *   -h localhost -p 8080 -s /soap/servlet/rpcrouter
     * -h indicats the host
     */
    public static void main(String args[]) throws Exception {
        Options opts = new Options(args);

        boolean testPerformance = opts.isFlagSet('k') > 0;
        boolean allTests = opts.isFlagSet('A') > 0;
        boolean onlyB    = opts.isFlagSet('b') > 0;
        boolean testMode = opts.isFlagSet('t') > 0;

        // set up tests so that the results are sent to System.out
        TestClient client;

        if (testPerformance) {
            client = new TestClient(testMode) {
               public void verify(String method, Object sent, Object gotBack) {
               }
            };
        } else {
            client = new TestClient(testMode) {
            public void verify(String method, Object sent, Object gotBack) {
                String message;
                if (this.equals(sent, gotBack)) {
                    message = "OK";
                } else {
                    if (gotBack instanceof Exception) {
                        if (gotBack instanceof AxisFault) {
                            message = "Fault: " +
                                ((AxisFault)gotBack).getFaultString();
                        } else {
                            StringWriter sw = new StringWriter();
                            PrintWriter pw = new PrintWriter(sw);
                            message = "Exception: ";
                            ((Exception)gotBack).printStackTrace(pw);
                            message += sw.getBuffer().toString();
                        }
                    } else {
                        message = "Fail:" + gotBack + " expected " + sent;
                    }
                }
                // Line up the output
                String tab = "";
                int l = method.length();
                while (l < 25) {
                    tab += " ";
                    l++;
                }
                System.out.println(method + tab + " " + message);
            }
        };
        }

        // set up the call object
        client.setURL(opts.getURL());
        client.setUser(opts.getUser());
        client.setPassword(opts.getPassword());

        if (testPerformance) {
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 10; i++) {
                if (allTests) {
                    client.executeAll();
                } else if (onlyB) {
                    client.execute2B();
                } else {
                    client.execute2A();
                }
            }
            long stopTime = System.currentTimeMillis();
            System.out.println("That took " + (stopTime - startTime) + " milliseconds");
        } else {
            if (allTests) {
                client.executeAll();
            } else if (onlyB) {
                client.execute2B();
            } else {
                client.execute2A();
            }
        }
    }
}