/******************************************************************************
    * AbstractClient.java - Web client base class
    * $Id: AbstractClient.java,v 1.3 2015/05/14 02:58:47 dick Exp $
    * 
    * BuckoVidLib - The BuckoSoft Video Library
    * Copyright(c) 2014 - Dick Balaska
    * 
    * $Log: AbstractClient.java,v $
    * Revision 1.3  2015/05/14 02:58:47  dick
   * Bad form to make RestClientConstants an interface. Instead use public static.
   *
   * Revision 1.2  2014/10/07 02:49:14  dick
   * ConfigManager moves to util, a more public place than the web client.
   *
   * Revision 1.1  2014/10/04 16:17:40  dick
   * Define a web client that can talk to the plex server.
   *
   */
  package com.buckosoft.BuckoVidLib.web.plex.client;
  
  
  import java.lang.reflect.ParameterizedType;
  import java.lang.reflect.Type;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.cxf.Bus;
  import org.apache.cxf.bus.CXFBusFactory;
  import org.apache.cxf.interceptor.LoggingInInterceptor;
  import org.apache.cxf.interceptor.LoggingOutInterceptor;
  import org.apache.cxf.jaxrs.client.ClientConfiguration;
  import org.apache.cxf.jaxrs.client.JAXRSClientFactoryBean;
  import org.apache.cxf.jaxrs.client.WebClient;
  import org.apache.cxf.jaxrs.provider.JAXBElementProvider;
  import org.apache.cxf.transport.http.HTTPConduit;
  import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;
  
  import com.buckosoft.BuckoVidLib.util.ConfigManager;
  
  /**
   *
   * @author Janitor Par
   */
  abstract class AbstractClient<T>  {
  
  	protected List<Object> providers;
  	protected String endpointUrl;
  	protected T serviceProxy;
  
  	private static Bus bus = new CXFBusFactory().createBus();
  
  //	@SuppressWarnings("OverridableMethodCallInConstructor")
  	public AbstractClient(String endpointUrl) {
  		this.endpointUrl = endpointUrl;
  		providers = new ArrayList<Object>();
  //		JacksonJsonProvider jacksonProvider = new JacksonJsonProvider();
  		@SuppressWarnings("rawtypes")
  		JAXBElementProvider<?> p = new JAXBElementProvider();
  //		jacksonProvider.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  //		providers.add(jacksonProvider);
  		providers.add(p);
  //		JAXRSServerFactoryBean sf = new JAXRSServerFactoryBean();
  //        sf.setResourceClasses(MediaContainer.class);
  //        sf.setResourceProvider(MediaContainer.class,
  //                               new SingletonResourceProvider(new MediaContainer()));
  //        sf.setProviders(providers);
  //        sf.create();
  		
  //		setupAdditionalProviders();
  		createServiceProxy();
  	}
  
  	public AbstractClient(String endpointUrl, List<Object> providers) {
  		this.endpointUrl = endpointUrl;
  		this.providers = providers;
  		createServiceProxy();
  	}
  
  	/**
  	 * Override this if you would like to add additional providers (like exception mappers)
  	 * jackson is added by default already.
  	 */
  	protected void setupAdditionalProviders() {
  	}
  
  	public T getWebClient() {
  		return serviceProxy;
  	}
  
  	public void setReceiveTimeout(int timeout) {
  		getHTTPClientPolicy().setReceiveTimeout(timeout);
  	}
  
  	public void setConnectionTimeout(int timeout) {
  		getHTTPClientPolicy().setConnectionTimeout(timeout);
  	}
  
  	protected HTTPClientPolicy getHTTPClientPolicy() {
  		ClientConfiguration config = WebClient.getConfig(serviceProxy);
 		HTTPConduit conduit = (HTTPConduit) config.getConduit();
 		HTTPClientPolicy policy = conduit.getClient();
 		return policy;
 	}
 
 	@SuppressWarnings("unchecked")
 	private Class<T> getTypeParameterClass() {
 		Type type = getClass().getGenericSuperclass();
 		ParameterizedType paramType = (ParameterizedType) type;
 		return (Class<T>) paramType.getActualTypeArguments()[0];
 	}
 
 	private void createServiceProxy() {
 		serviceProxy = create(endpointUrl, getTypeParameterClass(), providers, null);
 		
 		// read property and setup connection and receive timeouts
 		setConnectionTimeout(ConfigManager.getInt(RestClientConstants.CXF_CLIENT_CONNECTION_TIMEOUT_PROP_KEY, RestClientConstants.DEFAULT_CXF_CLIENT_CONNECTION_TIMEOUT));
 		setReceiveTimeout(ConfigManager.getInt(RestClientConstants.CXF_CLIENT_RECEIVE_TIMEOUT_PROP_KEY, RestClientConstants.DEFAULT_CXF_CLIENT_RECEIVE_TIMEOUT));
 		
 		// read property and add logging interceptors if enabled
 		if (ConfigManager.isEnabled(RestClientConstants.CXF_CLIENT_LOGGING_IN_INTERCEPTOR_PROP_KEY)) {
 			WebClient.getConfig(serviceProxy).getInInterceptors().add(new LoggingInInterceptor());
 		}
 		
 //        WebClient.getConfig(serviceProxy).getInInterceptors().add(new RestSingleObjectToArrayInterceptor());
 		if (ConfigManager.isEnabled(RestClientConstants.CXF_CLIENT_LOGGING_OUT_INTERCEPTOR_PROP_KEY)) {
 			WebClient.getConfig(serviceProxy).getOutInterceptors().add(new LoggingOutInterceptor());
 		}
 	}
 	
    /**
      * Creates a proxy
      * @param baseAddress baseAddress
      * @param cls proxy class, if not interface then a CGLIB proxy will be created
      * @param providers list of providers
      * @param configLocation classpath location of the configuration resource
      * @return typed proxy
      */
     public static <T> T create(String baseAddress, Class<T> cls, List<?> providers, String configLocation) {
         JAXRSClientFactoryBean bean = getBean(baseAddress, cls, configLocation);
         bean.setProviders(providers);
         return bean.create(cls);
     }
     
     private static JAXRSClientFactoryBean getBean(String baseAddress, Class<?> cls, String configLocation) {
         JAXRSClientFactoryBean bean = getBean(baseAddress, configLocation);
         bean.setServiceClass(cls);
         return bean;
     }   
     
     private static JAXRSClientFactoryBean getBean(String baseAddress, String configLocation) {
         JAXRSClientFactoryBean bean = new JAXRSClientFactoryBean();
         bean.setBus(bus);
         bean.setAddress(baseAddress);
         return bean;
     }	
 }