package jboss.ws;

import static org.junit.Assert.assertEquals;

import java.io.File;
import java.io.FileInputStream;
import java.util.concurrent.Future;

import javax.xml.soap.MessageFactory;
import javax.xml.soap.SOAPMessage;
import javax.xml.ws.AsyncHandler;
import javax.xml.ws.Dispatch;
import javax.xml.ws.Response;
import javax.xml.ws.Service;

import jboss.ws.hello.client.Hello;
import jboss.ws.hello.client.HelloService;
import jboss.ws.hello.client.Person;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.frontend.ClientProxy;
import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.junit.Before;
import org.junit.Test;

public class HelloWorldTest {
    private Client client = null;;
    private Hello port = null;
    private HelloService service = null;

    @Before
    public void setUp() {
        service = new HelloService();
        port = service.getHelloPort();
        client = ClientProxy.getClient(port);
        client.getInInterceptors().add(new LoggingInInterceptor());
        client.getOutInterceptors().add(new LoggingOutInterceptor());
    }

    @Test
    public void testHelloWSWithDispatchAPI() throws Exception {
        FileInputStream input = new FileInputStream(new File(
                "src/test/resources/outbound.xml"));
        MessageFactory factory = MessageFactory.newInstance();
        SOAPMessage request = factory.createMessage(null, input);
        Dispatch<SOAPMessage> dispatch = service
                .createDispatch(HelloService.HelloPort, SOAPMessage.class,
                        Service.Mode.MESSAGE);

        // Synchronous, Message-Oriented.
        SOAPMessage msg = dispatch.invoke(request);
        String result = msg.getSOAPBody().getTextContent();
        String expected = "Hello David . F by JBoss 6 WS with CXF implementation.";
        assertEquals(expected, result);

        // Asynchronous, Polling, Message-Oriented
        Response<SOAPMessage> response = dispatch.invokeAsync(request);
        while (!response.isDone()) {
            System.out
                    .println("waiting for the response from hello web service......");
            Thread.sleep(1000);
        }
        msg = response.get();
        result = msg.getSOAPBody().getTextContent();
        assertEquals(expected, result);

        // Asynchronous , Callback, Message-Oriented

        Future<?> future = dispatch.invokeAsync(request,
                new AsyncHandler<SOAPMessage>() {
                    public void handleResponse(Response<SOAPMessage> response) {
                        try {
                            assertEquals(
                                    "Hello David . F by JBoss 6 WS with CXF implementation.",
                                    response.get().getSOAPBody().getTextContent());
                        } catch (Exception e) {

                        }
                    }
                });
    }

    @Test
    public void testSayHello() throws Exception {

        Person person = new Person();
        person.setFirstName("David");
        person.setLastName("F");
        Object[] returnedObjects = client.invoke("sayHello",
                new Object[] { person });
        String expected = "Hello David . F by JBoss 6 WS with CXF implementation.";
        String result = (String) returnedObjects[0];
        assertEquals(expected, result);
    }

}