/*
    * 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.smusher;
  
  /** Utility methods for Elmo
   * @author Peter Mika (pmika@cs.vu.nl)
   */
  
  import info.aduna.collections.iterators.Iterators;
  
  import java.io.IOException;
  import java.io.UnsupportedEncodingException;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  import java.util.Enumeration;
  import java.util.Hashtable;
  import java.util.List;
  
  import javax.servlet.ServletConfig;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  
  import org.openrdf.OpenRDFException;
  import org.openrdf.elmo.ElmoManager;
  import org.openrdf.elmo.ElmoManagerFactory;
  import org.openrdf.elmo.ElmoModule;
  import org.openrdf.elmo.ElmoQuery;
  import org.openrdf.elmo.sesame.SesameManager;
  import org.openrdf.elmo.sesame.SesameManagerFactory;
  import org.openrdf.model.Literal;
  import org.openrdf.model.Statement;
  import org.openrdf.model.URI;
  import org.openrdf.model.impl.LiteralImpl;
  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 {
  
  	//Similarity threshold for matching names
  	public final static double SIMILARITY_THRESHOLD = 0.85;
  
  	private final static int NGRAM_SIZE = 2;
  
  	  
  	//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 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 SesameManager initManager(Repository repository) {
 		ElmoManagerFactory factory = new SesameManagerFactory(new ElmoModule(), repository);
 		ElmoManager manager = factory.createElmoManager();
 
 		return (SesameManager) 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;
 	}
 
 	private static class Gram {
 		String gram;
 
 		int occurences;
 
 		String str;
 
 		public Gram(String inGram, String inString) {
 			gram = inGram;
 			str = inString;
 			occurences = 0;
 			int ng = gram.length();
 			int len = str.length();
 			for (int i = 0; i <= (len - ng); i++) {
 				String gr = str.substring(i, i + ng);
 				if (gram.equalsIgnoreCase(gr)) {
 					occurences++;
 				}
 			}
 		}
 	}
 
 	//ngram size shouldn't be less than 2 and more than 9
 	public static double compare(String str1, String str2, int ng) {
 		if (ng < 2) {
 			ng = 2;
 		}
 		if (ng > 9) {
 			ng = 9;
 		}
 		char blank = ' ';
 		char underline = '_';
 		str1 = str1.replace(blank, underline);
 		str2 = str2.replace(blank, underline);
 
 		Hashtable<String, Gram> gramList1 = new Hashtable<String, Gram>();
 		int len = str1.length();
 		for (int i = 0; i <= (len - ng); i++) {
 			String gr = str1.substring(i, i + ng);
 			Gram gram = new Gram(gr, str1);
 			if (gram.occurences > 0) {
 				gramList1.put(gram.gram, gram);
 			}
 		}
 		Hashtable<String, Gram> gramList2 = new Hashtable<String, Gram>();
 		len = str2.length();
 		for (int i = 0; i <= (len - ng); i++) {
 			String gr = str2.substring(i, i + ng);
 			Gram gram = new Gram(gr, str2);
 			if (gram.occurences > 0) {
 				gramList2.put(gram.gram, gram);
 			}
 		}
 		double difference = 0;
 		double sum = 0;
 		Hashtable<String, Gram> diffGrams = new Hashtable<String, Gram>();
 
 		Enumeration keys1 = gramList1.keys();
 		while (keys1.hasMoreElements()) {
 			String key = (String) keys1.nextElement();
 			Gram g = (Gram) gramList1.get(key);
 			double plus = (g.occurences);
 			double squarePlus = Math.pow(plus, 2);
 			sum = sum + squarePlus;
 			if (gramList2.containsKey(key)) {
 				Gram gr2 = (Gram) gramList2.get(key);
 				double minus = (g.occurences - gr2.occurences);
 				double square = Math.pow(minus, 2);
 				difference = difference + square;
 			} else {
 				double square = Math.pow(g.occurences, 2);
 				difference = difference + square;
 			}
 		}
 		Enumeration keys2 = gramList2.keys();
 		while (keys2.hasMoreElements()) {
 			String key = (String) keys2.nextElement();
 			Gram gr2 = (Gram) gramList2.get(key);
 			if (gramList1.containsKey(key)) {
 			} else {
 				diffGrams.put(key, gr2);
 			}
 		}
 		Enumeration diffKeys = diffGrams.keys();
 		while (diffKeys.hasMoreElements()) {
 			String key = (String) diffKeys.nextElement();
 			Gram diffGram = (Gram) diffGrams.get(key);
 			double square = Math.pow(diffGram.occurences, 2);
 			difference = difference + square;
 			double squarePlus = Math.pow(diffGram.occurences, 2);
 			sum = sum + squarePlus;
 		}
 
 		int totalLength = str1.length() - ng + 1 + diffGrams.size();
 		double threshold = 2.486 + 0.025 * totalLength;
 		difference = Math.sqrt(difference);
 		//sum is not used any more
 		//sum = Math.sqrt(sum);
 
 		//Alternatively:
 		double similarity = 0;
 		if (difference < threshold) {
 			similarity = 0.8 + ((threshold - difference) / (5 * threshold));
 		} else if (difference > threshold) {
 			similarity = 0.8 - (((difference - threshold) * 4) / ((1 + difference - threshold) * 5));
 		} else {
 			similarity = 0.8;
 		}
 
 		return similarity;
 	}
 	
 	
 	
 	/** Invert names of the from "van Harmelen, Frank", i.e. with comma. 
 	 * 
 	 * @param name Name
 	 * @return Name in its regular form or unchanged if no comma is found
 	 */
 	public static String invertName(String name) {
 		int delim = name.indexOf(',');
         if (delim != -1) {
             return name.substring(delim + 1, name.length()).trim() + ' ' +
 			       name.substring(0, delim).trim();
         } else {
             return name;
         }
 	}
 	
 
 	/** Extract the first name from a full name
 	 * 
 	 * @param name Name
 	 * @return First name
 	 */
 	public static String getFirstName(String name) {
 		//if there is a comma then first name is last
 		if (name.indexOf(',') != -1) {
 			name = invertName(name);
 		} 
 		int delim = name.indexOf(" ");
 		if (delim < 0) {
 			//no space -> name is a firstname
 			delim = name.length();
 		}
 		return name.substring(0, delim);
 	}
 
 	/** Extract the last name from a full name
 	 * 
 	 * @param name Name
 	 * @return Last name
 	 */
 	public static String getLastName(String name) {
 		//if there is a comma then last name is first
 		if (name.indexOf(',') != -1) {
 			name = invertName(name);
 		} 
 		int delim = name.lastIndexOf(" ");
 		if (delim < 0) {
 			//no space -> name is a firstname
 			return "";
 		} else {
 			return name.substring(delim + 1, name.length());
 		}
 	}
 
 	/** Determine if two names are the same using N-Gram matching.
 	 * The similarity threshold is determined by {@link #SIMILARITY_THRESHOLD}
 	 * 
 	 * @param name1 First name
 	 * @param name2 Second name
 	 * @return True, if the names are the same (similar enough)
 	 */
 	public static boolean matchNames(String name1, String name2) {
 		boolean result = true;
 		//Parse the names
 		String first1 = getFirstName(name1.trim());
 		String last1 = getLastName(name1.trim());
 		String first2 = getFirstName(name2.trim());
 		String last2 = getLastName(name2.trim());
 
 		//If we only have firstnames, we cannot match
 		if (last1.length() < 2 || last2.length() < 2) {
 			return false;
 		}
 
 		//The last names must match exactly
 		if (!last1.equalsIgnoreCase(last2)) {
 			return false;
 		}
 		
 		//Check if one of the first names contains an initial
 		//If yes, compare only the initial characters
 		if (first1.indexOf(".") != -1 || first2.indexOf(".") != -1) {
 			if (!(first1.charAt(0) == first2.charAt(0))) {
 				return false;
 			}
 		} else {
 			//The first names must be similar enough
 			if (//check if the names are long enough
 			//(first1.length() > STRINGLENGTH_THRESHOLD) &&
 			//(first2.length() > STRINGLENGTH_THRESHOLD) &&
 			compare(first1, first2, NGRAM_SIZE) < SIMILARITY_THRESHOLD) {
 				return false;
 			}
 		}
 
 		return result;
 	}
 			
 	/** Add a statement to a repository
 	 * 
 	 * @param rep
 	 * @param stmt
 	 * @throws OpenRDFException
 	 * @throws IOException
 	 */
 	public static void addStatememt(Repository rep, Statement stmt)
 	throws OpenRDFException, IOException {
 		RepositoryConnection con = null;
 		
 		try {
 			con = rep.getConnection();
 			
 			con.add(stmt);
 		} 
 		finally {
 			if (con != null)
 				con.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());
 	}
 
 	
 
 	/** Generate a SHA1 digest of the string passed in and
 	 *  encode using hex encoding.
 	 * 
 	 * @param str String to be encoded
 	 * @return Digest
 	 */
 	public final static String createSHA1(String str) 
 	throws UnsupportedEncodingException, NoSuchAlgorithmException {
 	    String result = "";
 	    byte[] theTextToDigestAsBytes = str.getBytes( "8859_1" /* encoding */ );
 	    MessageDigest md = MessageDigest.getInstance( "SHA" );
 	    md.update( theTextToDigestAsBytes );
 	    byte[] digest = md.digest();
 	    //Write out a formatted string
 	    for (int i=0; i<digest.length; i++) {
 	        String hex = Integer.toHexString(digest[i]);
 	        if (hex.length() == 1) hex = "0" + hex;
 	        result += hex.substring(hex.length()-2);
 	    }
 	    return result.toUpperCase();
 	}
 	
 	/** Generate a SHA1 summary of an email address String
 	 *  (e.g. "pmika@cs.vu.nl")
 	 *  according the FOAF specification of the mbox_sha1sum property.
 	 * 
 	 * @param str E-mail address
 	 * @return Mailbox checksum
 	 */
 	public final static Literal createSha1Sum(String email) 
 	throws UnsupportedEncodingException, NoSuchAlgorithmException  {
 	    return new LiteralImpl(createSHA1("mailto:" + email));
 	}
 	
 	/** Generate a SHA1 summary of an email address URI
 	 *  (e.g. <mailto:pmika@cs.vu.nl>)
 	 *  according the FOAF specification of the mbox_sha1sum property.
 	 * 
 	 * @param str
 	 * @return Mailbox checksum
 	 */
 	public final static Literal createSha1Sum(URI email) 
 	throws UnsupportedEncodingException, NoSuchAlgorithmException  {
 	    return new LiteralImpl(createSHA1(email.toString()));
 	}
 
 }