/*
    * Copyright (c) 2007, Peter Mika All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    * 
    * - Redistributions of source code must retain the above copyright notice, this
    *   list of conditions and the following disclaimer.
    * - Redistributions in binary form must reproduce the above copyright notice,
   *   this list of conditions and the following disclaimer in the documentation
   *   and/or other materials provided with the distribution. 
   * - Neither the name of the openrdf.org nor the names of its contributors may
   *   be used to endorse or promote products derived from this software without
   *   specific prior written permission.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   * 
   */
  package org.openrdf.elmo.scutter;
  
  /** Utility methods for Elmo
   * @author Peter Mika (pmika@cs.vu.nl)
   */
  
  import info.aduna.collections.iterators.Iterators;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.List;
  
  import javax.servlet.ServletConfig;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  
  import org.apache.commons.httpclient.HttpClient;
  import org.apache.commons.httpclient.HttpException;
  import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
  import org.apache.commons.httpclient.methods.GetMethod;
  import org.apache.commons.httpclient.methods.HeadMethod;
  import org.openrdf.OpenRDFException;
  import org.openrdf.elmo.ElmoManager;
  import org.openrdf.elmo.ElmoManagerFactory;
  import org.openrdf.elmo.ElmoModule;
  import org.openrdf.elmo.RoleMapper;
  import org.openrdf.elmo.sesame.SesameManagerFactory;
  import org.openrdf.model.URI;
  import org.openrdf.repository.Repository;
  import org.openrdf.repository.RepositoryConnection;
  import org.openrdf.repository.RepositoryException;
  import org.openrdf.repository.http.HTTPRepository;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  public class Util {
  
  	//servlet parameter names used for init and config parameters
  	public final static String SERVLET_SERVER_PARAMETER = "server";
  
  	public final static String SERVLET_REPOSITORY_PARAMETER = "repository";
  
  	public final static String SERVLET_USERNAME_PARAMETER = "username";
  
  	public final static String SERVLET_PASSWORD_PARAMETER = "password";
  	
  	public final static String CONTEXT_SERVER_PARAMETER = SERVLET_SERVER_PARAMETER;
  
  	public final static String CONTEXT_REPOSITORY_PARAMETER = SERVLET_REPOSITORY_PARAMETER;
  		
  	public final static String CONTEXT_USERNAME_PARAMETER = SERVLET_USERNAME_PARAMETER;
  
  	public final static String CONTEXT_PASSWORD_PARAMETER = SERVLET_PASSWORD_PARAMETER;
  
  	//request attribute names
  	public final static String REQUEST_REPOSITORY_ATTRIBUTE = "sesame";
  
  	protected static Logger _logger = LoggerFactory.getLogger(Util.class);
  
  	private static HttpClient _httpClient;
  
  	static {
  
  		MultiThreadedHttpConnectionManager mthc = new MultiThreadedHttpConnectionManager();
  		mthc.getParams().setDefaultMaxConnectionsPerHost(50);
  		mthc.getParams().setMaxTotalConnections(150);
  		_httpClient = new HttpClient(mthc);
  	}
 
 	/** Retrieve a document from the given URL using HTTP GET 
 	 * 
 	 * @param url
 	 * @return Document as stream
 	 * @throws HttpException
 	 * @throws IOException
 	 * @see org.apache.commons.httpclient.methods.GetMethod
 	 */
 	public static InputStream getDocumentAsInputStream(String url)
 			throws HttpException, IOException {
 		//Execute a GET method on the URL
 		GetMethod get = new GetMethod(url);
 		get.setFollowRedirects(true);
 		get.addRequestHeader("User-Agent",
 				"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 4.0)");
 		_httpClient.executeMethod(get);
 		return get.getResponseBodyAsStream();
 	}
 
 	/** Retrieve a document from the given URL using HTTP GET. The method  
 	 * getDocumentAsInputStream is preferred over this one, because reading a document
 	 * requires to buffer a document of unknown size.
 	 * 
 	 * @param url
 	 * @return Document as String
 	 * @throws HttpException
 	 * @throws IOException
 	 * @see #getDocumentAsInputStream
 	 * 
 	 */
 	public static String getDocumentAsString(String url) throws HttpException,
 			IOException {
 		String result = "";
 		//Execute a GET method on the URL
 		GetMethod get = new GetMethod(url);
 		get.setFollowRedirects(true);
 		get.addRequestHeader("User-Agent",
 				"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 4.0)");
 		try {
 			_httpClient.executeMethod(get);
 			result = get.getResponseBodyAsString();
 		} finally {
 			get.releaseConnection();
 		}
 		return result;
 	}
 	
 	/** Determine the value for the Content-Length header using a HEAD call
 	 * 
 	 * @param url
 	 * @return
 	 * @throws HttpException
 	 */
 	public static int getContentLength(String url) throws HttpException, IOException {
 		int result = 0;
 		//Execute a GET method on the URL
 		HeadMethod head = new HeadMethod(url);
 		head.setFollowRedirects(true);
 		head.addRequestHeader("User-Agent",
 				"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 4.0)");
 		try {
 			_httpClient.executeMethod(head);
 	        // Retrieve just the Content-Length header value.
 	        String length =
 	            head.getResponseHeader("Content-Length").getValue();
 	        result = Integer.parseInt(length);
 		} catch (NumberFormatException nfe) {
 			//header not found
 		} finally {
 			head.releaseConnection();
 		}
 		return result;
 	}
 	
 	
 	private static Repository getLocalRepository(String name) throws RepositoryException {
 		/*
 		RepositoryManager manager = RepositoryManager.getDefaultInstance();
 		
 		Repository repository = manager.getRepository(name);
 		repository.initialize();
 		
 		return repository;
 		*/
 		throw new RuntimeException("Not implemented");
 	}
 	
 	private static Repository getRemoteRepository(String sesameServer, String repositoryID) throws RepositoryException {
 		Repository repository = new HTTPRepository(sesameServer, repositoryID);
 		repository.initialize();
 		
 		return repository;
 	}
 	
 	public static ElmoManager initManager(Repository repository) {
 		ElmoManagerFactory factory = new SesameManagerFactory(new ElmoModule(), repository);
 		ElmoManager manager = factory.createElmoManager();
 
 		return manager;
 	}
 	
 	/** Initialize a remote Elmo repository using the location and name
 	 * 
 	 * @param repositoryLocation String containing a URL
 	 * @param repositoryName Repository name
 	 * @return Repository
 	 * @throws Exception if parameter is missing, invalid or initilization failed
 	 * @see org.openrdf.elmo.repository.ElmoRepository#getRepository(URL, String)
 	 */
 	public static Repository initRepository(String repositoryLocation,
 			String repositoryName) throws Exception {
 		return initRepository(repositoryLocation, repositoryName, null, null);
 	}
 
 	
 	/**
 	 * Initialize a remote Elmo repository using (optional) username and password.
 	 * Performs some sanity checks on the repository location and name.
 	 *  
 	 * @param repositoryLocation
 	 *            URL of the server
 	 * @param repositoryName
 	 *            Repository name
 	 * @param username
 	 *            Optional username
 	 * @param password
 	 *            Optional password
 	 * @return Repository
 	 * @throws Exception
 	 *             if parameter is missing, invalid or initilization failed
 	 */
 			
 	public static Repository initRepository(String repositoryLocation,
 			String repositoryName, String username, String password)
 			throws Exception {
 		Repository repository = null;
 		
 		//Check parameters
 		if ((repositoryLocation == null || repositoryLocation.equals("")) &&
 			repositoryName != null && !repositoryName.equals("")) {
 			//try getting the repository from the Sesame server in the same JVM
 		
 			
 			repository = getLocalRepository(repositoryName);
 			
 		} else {
 			
 			try {
 				URL repositoryURL = new URL(repositoryLocation);
 			} catch (MalformedURLException mue) {
 				throw new Exception("Repository location contains a malformed URL");
 			}
 			if (repositoryName == null || repositoryName.equals("")) {
 				throw new Exception("Repository name missing");
 			}
 	
 			repository = getRemoteRepository(repositoryLocation, repositoryName);
 			
 		}
 	
 		return repository;
 	}
 	
 	
 
 	/**
 	 * Initialize an Elmo repository from servlet request. First try to find a
 	 * SesameRepository as a request attribute , if fails try to initialize one
 	 * using request parameter. The attribute and init parameter names to
 	 * specified are defined as constants in this class.
 	 * 
 	 * @param request
 	 *            Request with parameters
 	 * @return Repository
 	 * @throws ServletException
 	 *             if parameters are missing or repository failed to initialize
 	 * @see #REQUEST_REPOSITORY_ATTRIBUTE
 	 * @see #SERVLET_SERVER_PARAMETER
 	 * @see #SERVLET_REPOSITORY_PARAMETER
 	 * @see #SERVLET_USERNAME_PARAMETER
 	 * @see #SERVLET_USERNAME_PARAMETER
 	 */
 	public static Repository initRepository(HttpServletRequest request)
 			throws ServletException {
 		String repositoryLocation = null;
 		String repositoryName = null;
 		String userName = null;
 		String password = null;
 		
 		Repository repository = null;
 		//Try first to find an object in the request
 		if (request.getAttribute(REQUEST_REPOSITORY_ATTRIBUTE) != null) {
 			repository = (Repository) request
 					.getAttribute(REQUEST_REPOSITORY_ATTRIBUTE);
 		} else {
 			//SERVER and REPOSITORY
 			repositoryLocation = request.getParameter(SERVLET_SERVER_PARAMETER);
 			repositoryName = request.getParameter(SERVLET_REPOSITORY_PARAMETER);
 
 			if (request.getParameter(SERVLET_USERNAME_PARAMETER) != null
 					&& request.getParameter(SERVLET_PASSWORD_PARAMETER) != null) {
 				//USERNAME and PASSWORD
 				userName = request.getParameter(SERVLET_USERNAME_PARAMETER);
 				password = request.getParameter(SERVLET_PASSWORD_PARAMETER);
 			}
 
 			try {
 				repository = Util.initRepository(repositoryLocation,
 						repositoryName, userName, password);
 			} catch (Exception e) {
 				throw new ServletException("Repository failed to initialize", e);
 			}
 		}
 		return repository;
 	}
 	
 	/**
 	 * Initialize an Elmo repository from servlet initialization parameters and 
 	 * if that fails from the context initialization parameters.
 	 * 
 	 * The init parameter names to specified are defined as constants in this
 	 * class.
 	 * 
 	 * @param config
 	 *            ServletConfig instance
 	 * @return Repository
 	 * @throws ServletException
 	 *             if parameters are missing or repository failed to initialize
 	 * @see #SERVLET_SERVER_PARAMETER
 	 * @see #SERVLET_REPOSITORY_PARAMETER
 	 * @see #SERVLET_USERNAME_PARAMETER
 	 * @see #SERVLET_PASSWORD_PARAMETER
 	 * @see #CONTEXT_SERVER_PARAMETER
 	 * @see #CONTEXT_REPOSITORY_PARAMETER
 	 * @see #CONTEXT_USERNAME_PARAMETER
 	 * @see #CONTEXT_PASSWORD_PARAMETER
 
 	 */
 	public static Repository initRepository(ServletConfig config)
 			throws ServletException {
 		String repositoryLocation = null;
 		String repositoryName = null;
 		String userName = null;
 		String password = null;
 		
 		Repository repository = null;
 			
 		repositoryLocation = config.getInitParameter(SERVLET_SERVER_PARAMETER);
 		repositoryName = config.getInitParameter(SERVLET_REPOSITORY_PARAMETER);
 		
 		if (config.getInitParameter(SERVLET_USERNAME_PARAMETER) != null
 				&& config.getInitParameter(SERVLET_PASSWORD_PARAMETER) != null) {
 			//USERNAME and PASSWORD
 			userName = config.getInitParameter(SERVLET_USERNAME_PARAMETER);
 			password = config.getInitParameter(SERVLET_PASSWORD_PARAMETER);
 		}
 
 		try {
 			repository = Util.initRepository(repositoryLocation, repositoryName,
 					userName, password);
 			return repository;
 		} catch (Exception e) {
 			//ignore
 		}
 		
 		//try context parameters
 		ServletContext context = config.getServletContext();
 		repositoryLocation = context.getInitParameter(CONTEXT_SERVER_PARAMETER);
 		repositoryName = context.getInitParameter(CONTEXT_REPOSITORY_PARAMETER);
 		
 		if (context.getInitParameter(CONTEXT_USERNAME_PARAMETER) != null
 				&& context.getInitParameter(CONTEXT_PASSWORD_PARAMETER) != null) {
 			//USERNAME and PASSWORD
 			userName = context.getInitParameter(CONTEXT_USERNAME_PARAMETER);
 			password = context.getInitParameter(CONTEXT_PASSWORD_PARAMETER);
 		} else {
 			userName = null;
 			password = null;
 		}
 
 		try {
 			repository = Util.initRepository(repositoryLocation, repositoryName,
 					userName, password);
 		} catch (Exception e) {
 			throw new ServletException("Repository failed to initialize", e);
 		}
 		
 		return repository;
 	}
 		
 	
 
 	/**
 	 * Initialize an Elmo repository from either servlet request parameters or
 	 * servlet initialization parameters. First try to find a ElmoRepository
 	 * object in the request. If not present, try to initialize one based on
 	 * request parameters. If this also fails, try to use servlet init
 	 * parameters and lastly the context initialization paratemers. 
 	 * The attribute, request and init parameter names to specified
 	 * are defined as constants in this class.
 	 * 
 	 * @param servlet
 	 *            Servlet instance
 	 * @param request
 	 *            Request with parameters
 	 * @return Repository
 	 * @throws ServletException
 	 *             if parameters are missing or repository failed to initialize
 	 * @see #REQUEST_REPOSITORY_ATTRIBUTE
 	 * @see #SERVLET_SERVER_PARAMETER
 	 * @see #SERVLET_REPOSITORY_PARAMETER
 	 * @see #SERVLET_USERNAME_PARAMETER
 	 * @see #SERVLET_USERNAME_PARAMETER
 	 * @see #CONTEXT_SERVER_PARAMETER
 	 * @see #CONTEXT_REPOSITORY_PARAMETER
 	 * @see #CONTEXT_USERNAME_PARAMETER
 	 * @see #CONTEXT_USERNAME_PARAMETER
 	 */
 	public static Repository initRepository(ServletConfig config,
 			HttpServletRequest request) throws ServletException {
 		Repository repository = null;
 		//first try to initialize a repository from the request parameters
 		try {
 			repository = initRepository(request);
 
 		} catch (ServletException se) {
 			//ignore
 		}
 		//if fails, try the initialization parameters
 		if (repository == null) {
 			repository = initRepository(config);
 		}
 		return repository;
 	}
 
 	public static void copyRepositoryContent(Repository source, Repository target)
 			throws OpenRDFException, IOException {
 		// TODO: is this efficient?
 		RepositoryConnection sourceCon = null;
 		RepositoryConnection targetCon = null;
 	
 		try {
 			sourceCon = source.getConnection();
 			targetCon = target.getConnection();
 			targetCon.add(sourceCon.getStatements(null, null, null, true));
 		} 
 		finally {
 			if (sourceCon != null)
 				sourceCon.close();
 			if (targetCon != null)
 				targetCon.close();
 	
 		}
 	}
 
 	/**
 	 * Find the ontological type (rdfs:Class) for a Java Class
 	 * 
 	 * @param c
 	 * @return URI of the class
 	 */
 	public static URI getType(Class c) {
 		// TODO: simplify?
 		SesameManagerFactory factory = new SesameManagerFactory(
 				new ElmoModule());
 		try {
 			RoleMapper<URI> mapper = factory.getRoleMapper();
 			return mapper.findType(c);
 		} finally {
 			factory.close();
 		}
 	}
 
 	/** Get all instances of type T from a given repository
 	 * 
 	 * @param <T>
 	 * @param rep
 	 * @param cl
 	 * @return
 	 */
 	public static <T extends org.openrdf.concepts.rdfs.Resource> List<T> getAllInstances(ElmoManager manager, Class<T> cl) {
 		//SesameManagerFactory factory = new SesameManagerFactory(rep);
 		//SesameManager manager = factory.createElmoManager();
 		Iterable<T> query = manager.findAll(cl);
 		return Iterators.asList(query.iterator());
 	}
 
 
 }