public class HLRHandler extends AbstractHandler
{
	private static final Logger LOGGER = Logger.getLogger(HLRHandler.class);

	public static String HLR_WSDL_LOCATION = "hlr_wsdl_location";

	public static String HLR_SUCCESS_CODE = "hlr_success_code";
	public static String HLR_TIMEOUT = "hlr_timeout";

	public static Error createSubscriber(final String ip, final String username, final String password, final String path,
			final MessageSource messageSource, final String imsi, final String msisdn, final String key,
			final SubscriberType type, final boolean isBulkProcessing, final long operationId)
	{
		LOGGER.trace("Starting: createSubscriber(" + ip + "," + imsi + "," + msisdn + "," + key + "," + type + ","
				+ isBulkProcessing + "," + operationId + ")");

		Error error = null;

		try
		{
			final WSProvision wsProvision = new WSProvision(new URI("file:" + path
					+ StringUtils.getMessage(messageSource, HLR_WSDL_LOCATION)).toURL(), WSProvision.SERVICE);

			final ObjectFactory objectFactory = new ObjectFactory();
			final DTOEntrada dtoEntrada = objectFactory.createDTOEntrada();

			final String ticket = "my ticket";

			// number of action
			dtoEntrada.setActuacion(objectFactory.createDTOEntradaActuacion("1"));

			// Provisioning mechanism (SINC for synchronous, ASINCE to
			// asynchronous) P.S. works only 'ASINCE'
			dtoEntrada.setTipoConexion(objectFactory.createDTOEntradaTipoConexion("ASINCE"));

			// User Id
			dtoEntrada.setUsuario(objectFactory.createDTOEntradaUsuario("userId"));

			// Number of service
			dtoEntrada.setOoss(objectFactory.createDTOEntradaOoss("ooss"));

			// Priority
			dtoEntrada.setPrioridad(objectFactory.createDTOEntradaPrioridad("1"));

			// Ticket (transaction ID of movement)
			dtoEntrada.setTicket(objectFactory.createDTOEntradaTicket(ticket));

			// ID of system (required for sync)
			// dtoEntrada.setSistema(objectFactory.createDTOEntradaSistema("id of system"));

			// Time To Live (required for sync)
			// dtoEntrada.setTtl(objectFactory.createDTOEntradaTtl("60"));

			// array of parameters and values
			final List<Parametro> parameters = dtoEntrada.getParametros();
			final Parametro param1 = objectFactory.createParametro();
			parameters.add(param1);

			// param1
			param1.setNombre(objectFactory.createParametroNombre("name"));
			param1.setValor(objectFactory.createParametroValor("value"));

			// change IP address of web-service and execute
			final WSProvisionPortType portType = wsProvision.getWSProvisionHttpEndpoint();
			final BindingProvider provider = (BindingProvider) portType;

			final Map<String, Object> maps = provider.getRequestContext();
			maps.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, "http://" + ip);

			portType.enviaComandoPS2(dtoEntrada);

			// waiting for result
			final Exchanger<HLRResponse> exchanger = new Exchanger<HLRResponse>();
			NotificationServiceImpl.addHandler(ticket, exchanger);
			checkHLRResponse(messageSource, exchanger.exchange(new HLRResponse(),
					Long.valueOf(StringUtils.getMessage(messageSource, HLR_TIMEOUT)), TimeUnit.MILLISECONDS));
		}
		catch (Exception e)
		{
			LOGGER.error("Failed provisioning for HLR (createSubscriber): ", e);

			error = createError();
		}

		LOGGER.trace("Ending: createSubscriber()");
		return error;
	}

	private static void checkHLRResponse(final MessageSource messageSource, final HLRResponse response) throws Exception
	{
		if (!response.getStatus().equals(StringUtils.getMessage(messageSource, HLR_SUCCESS_CODE)))
		{
			throw new Exception("HLR error: [ticket: " + response.getTicket() + ", status: " + response.getStatus() + ", error: "
					+ response.getSuberror() + "]");
		}
	}

	private static Error createError()
	{
		return createError(ErrorCodes.HLRError);
	}
}

@javax.jws.WebService(serviceName = "WSNotificacion", portName = "WSNotificacionHttpSoap11Endpoint", targetNamespace = "****", wsdlLocation = "", endpointInterface = "****")
@Service
public class NotificationServiceImpl implements WSNotificacionPortType
{
	private static final Logger LOGGER = Logger.getLogger(NotificationServiceImpl.class);

	private static ConcurrentMap<String, Object> waitingRequests = new ConcurrentHashMap<String, Object>();

	public static void addHandler(final String ticket, final Exchanger<HLRResponse> exchanger)
	{
		waitingRequests.put(ticket, exchanger);
	}

	@Override
	public String notifica(final String ticket, final String status, final String suberror)
	{
		LOGGER.trace("Starting: notifica()");

		LOGGER.debug(ticket);
		LOGGER.debug(status);
		LOGGER.debug(suberror);

		final Iterator<String> iterTickets = waitingRequests.keySet().iterator();
		while (iterTickets.hasNext())
		{
			if (iterTickets.next().equals(ticket))
			{
				@SuppressWarnings("unchecked")
				final Exchanger<HLRResponse> exchanger = (Exchanger<HLRResponse>) waitingRequests.get(ticket);
				try
				{
					exchanger.exchange(new HLRResponse(ticket, status, suberror));
					return "OK";
				}
				catch (InterruptedException e)
				{
					LOGGER.error("HLR notification theard has been interrupted for ticket [" + ticket + "]: ", e);
				}
				finally
				{
					waitingRequests.remove(ticket);
				}
			}
		}

		LOGGER.trace("Ending: notifica()");
		return "FAILED";
	}
}