package component;

import javax.annotation.Resource;
import javax.jbi.messaging.DeliveryChannel;
import javax.jbi.messaging.ExchangeStatus;
import javax.jbi.messaging.MessageExchange;
import javax.jbi.messaging.MessagingException;
import javax.jbi.messaging.NormalizedMessage;

import javax.jbi.messaging.InOnly;
import javax.jbi.messaging.InOut;


import javax.xml.transform.TransformerException;

import javax.naming.InitialContext;

import org.apache.servicemix.client.ClientFactory;
import org.apache.servicemix.client.Destination;
import org.apache.servicemix.client.ServiceMixClient;

import org.apache.log4j.Logger;
import org.apache.servicemix.MessageExchangeListener;
import org.apache.servicemix.components.util.ComponentSupport;
import org.apache.servicemix.jbi.jaxp.SourceTransformer;

import org.apache.servicemix.jbi.jaxp.StringSource;


import org.apache.servicemix.JbiConstants;

public class CommunicationManager extends ComponentSupport implements MessageExchangeListener {

	private final static Logger logger = Logger.getLogger(CommunicationManager.class);
//	private SourceTransformer sourceTransformer = new SourceTransformer();
	@Resource
	private DeliveryChannel channel;
	
	private String stringMsg;
	private InOut inOut;
	private int count;
	
	private String key[];
	
	public CommunicationManager(){
		count = 0;
		}
	
	

    public void onMessageExchange(MessageExchange exchange) throws MessagingException {
       try {
       //synchronized(this){
        NormalizedMessage message = getInMessage(exchange);
        
        	stringMsg = new SourceTransformer().toString(message.getContent());
        	
		
    		
        	ServiceMixClient client = createClient();
			if(stringMsg.startsWith("<myMessage>")){
				
			String corrId = (String) exchange.getProperty(JbiConstants.CORRELATION_ID);
			//logger.info("correlation ID : " + corrId);
			int correlationID = Integer.parseInt(corrId);
				
			if(count <= correlationID)
			{
			count ++;
				logger.info("message received : " + stringMsg);
				inOut = (InOut)exchange;
			
				sendToOrchestrators(client, stringMsg);
			}
			}else {
			logger.info("message received : " + stringMsg);	
						exchange.setStatus(ExchangeStatus.DONE);
        				channel.send(exchange);
						
						
						logger.info("...sending response to Target...");
						NormalizedMessage answer = inOut.createMessage();
            			answer.setContent(new StringSource(stringMsg));
            			inOut.setOutMessage(answer);
            			channel.send(inOut);
            			

        				
        				inOut = null;
        			
        }	
        	
     } catch(TransformerException e) {
        	logger.error("error while reading payload", e);
        }   

    }
    
  
    private ServiceMixClient createClient() {
		try {
			ClientFactory factory = (ClientFactory) new InitialContext().lookup(ClientFactory.DEFAULT_JNDI_NAME);
			return factory.createClient();
			
			} catch(Exception e) {
			e.printStackTrace();
			return null;
			}
	}
	

	private void sendToOrchestrators(ServiceMixClient client, String stringMessage){
		try{
			Destination destination = client.createDestination(
			"service:http://myproject.com/components/simpleMulticast");
			InOnly inOnlyExchange = destination.createInOnlyExchange();
			//inOnlyExchange.setProperty(JbiConstants.CORRELATION_ID, "" + correlationId);
			NormalizedMessage inMessage = inOnlyExchange.getInMessage();
			inMessage.setContent(new StringSource(stringMessage));
			logger.info("...CommunicationManager sends to Orchestrators...");
			client.send(inOnlyExchange);
			}catch(MessagingException e){
				logger.info("error while sending message to Orchestrators", e);
				}
		}
	
}