/*
 * 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.jaxws.sample.asyncdoclit.client;

import java.util.Map;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.TimeoutException;

import javax.xml.ws.BindingProvider;

public class AsyncClient {

    private static final String DOCLITWR_ASYNC_ENDPOINT =
        "http://localhost:6060/axis2/services/AsyncService2.DocLitWrappedPortImplPort";

	private static final int max_isasleep_check = 30;
	
	/**
	 * Auxiliary method used for doiing isAsleep checks. Will perform isAsleep
	 * up to a MAX_ISASLEEP_CHECK number of checks. Will sleep for
	 * SLEEP_ISASLEEP_SEC seconds in between requests. If reaches maximum number
	 * fo retries then will fail the test
	 */
	public static boolean isAsleepCheck(String MESSAGE, AsyncPort port) throws Exception {
		boolean asleep = false;
		int check = 5; //Constants.MAX_ISASLEEP_CHECK;
		String msg = null;

		final long start = System.currentTimeMillis();
		
		System.out.println("AsyncClient.isAsleepCheck(" + MESSAGE + ") Enter");

		do {
			try {
				msg = port.isAsleep();
			} catch (Exception e){
				System.out.println("AsyncClient.isAsleepCheck Exception on isAsleep:" + e);
				throw e;
			}
			
			asleep = (msg != null);

			// fail the test if we ran out of checks
			if ((check--) == 0) {
				System.out.println("AsyncClient.isAsleepCheck=" + asleep
						+ " after " + (/*Constants.MAX_ISASLEEP_CHECK*/ max_isasleep_check - check)
						+ " tries");
				throw new RuntimeException("Server did not receive sleep after several retries");
			}

			// sleep for a bit
			try {
				Thread.sleep(/*Constants.SLEEP_ISASLEEP_SEC*/ 1 * 1000);
			} catch (InterruptedException e) {
				System.out.println("AsyncClient.isAsleepCheck (ignored error) "
						+ e);
			}

		} while (!asleep);

		System.out.println("AsyncClient.isAsleepCheck() asleep=" + asleep + " after "
				+ (/*Constants.MAX_ISASLEEP_CHECK*/ max_isasleep_check - check) + " tries");

		if (asleep) {
			System.out.println("AsyncClient.isAsleepCheck sleeping on:" + msg);
			if (!MESSAGE.equals(msg)) {
				throw new RuntimeException("Sleeping on an incorrect message");
			}
		}

		long mins = (System.currentTimeMillis() - start) / 1000;
		System.out.println("AsyncClient.isAsleepCheck() Exit, time=" + mins + "min");

		return true;
	}

	/**
	 * Auxiliary method used for obtaining a proxy pre-configured with a
	 * specific Executor
	 */
	public static AsyncPort getPort(Executor ex) {
		AsyncService service = new AsyncService();

		if (ex != null) service.setExecutor(ex);

		AsyncPort port = service.getAsyncPort();
		if (port == null) {
			throw new RuntimeException("service.getAsyncPort() is null");
		}

		Map<String, Object> rc = ((BindingProvider) port).getRequestContext();
		rc.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY,
				DOCLITWR_ASYNC_ENDPOINT); //Constants.DOCLITWR_ASYNC_ENDPOINT);

		System.out.println("AsyncClient.getPort() = "
				+ DOCLITWR_ASYNC_ENDPOINT); //Constants.DOCLITWR_ASYNC_ENDPOINT);

		return port;
	}

	/**
	 * Auxiliary method used to wait for a monitor for a certain amount of time
	 * before timing out
	 * 
	 * @param monitor
	 */
	public static void waitBlocking(Future<?> monitor) throws Exception {

		System.out.println("AsyncClient.waitBlocking() Enter");

		// wait for request to complete
		int sec = /*Constants.CLIENT_MAX_SLEEP_SEC*/ max_isasleep_check;
		while (!monitor.isDone() && !monitor.isCancelled()) {
			Thread.sleep(1000);
			sec--;
			if (sec <= 0) break;
		}

		if (sec <= 0) {
			System.out.println("AsyncClient.waitBlocking Exit, timeout after"
					+ /*Constants.CLIENT_MAX_SLEEP_SEC*/ max_isasleep_check + " sec");
			
			throw new TimeoutException(
					"Stopped waiting for Async response after "
							+ /*Constants.CLIENT_MAX_SLEEP_SEC*/ max_isasleep_check + " sec");
		} else {
			System.out.println("AsyncClient.waitBlocking Exit, " + sec
					+ "sec remaining");
		}
	}
}