/*
    *  Copyright (C) 2003-2005 SINTEF
    *  Author:  Fredrik Vraalsen (fredrik dot vraalsen at sintef dot no)
    *  Webpage: http://coras.sourceforge.net/
    *
    *  This program is free software; you can redistribute it and/or
    *  modify it under the terms of the GNU Lesser General Public License
    *  as published by the Free Software Foundation; either version 2.1
    *  of the License, or (at your option) any later version.
   *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   *  Lesser General Public License for more details.
   *
   *  You should have received a copy of the GNU Lesser General Public
   *  License along with this program; if not, write to the Free
   *  Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   *  02111-1307 USA
   */
  package no.sintef.xmldb;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.StringTokenizer;
  
  import javax.naming.Context;
  import javax.naming.InitialContext;
  import javax.naming.NamingException;
  
  import org.apache.log4j.Logger;
  import org.exist.jboss.XmlDbService;
  import org.xmldb.api.base.Collection;
  import org.xmldb.api.base.Resource;
  import org.xmldb.api.base.ResourceSet;
  import org.xmldb.api.base.Service;
  import org.xmldb.api.base.XMLDBException;
  import org.xmldb.api.modules.CollectionManagementService;
  import org.xmldb.api.modules.XMLResource;
  import org.xmldb.api.modules.XPathQueryService;
  
  /***
   * XML:DB database handler.
   * 
   * @author Fredrik Vraalsen
   */
  public final class XmlDbHandler {
  
  	private static final Logger LOGGER = Logger.getLogger(XmlDbHandler.class);
  	private static XmlDbHandler handler = null;
  	
  	private XmlDbService xmlDbService = null;
  	
  	/***
  	 * Singleton class, use getHandler() method.
  	 */
  	private XmlDbHandler() {
  		try {
  			Context ctx = new InitialContext();
  			xmlDbService = (XmlDbService) ctx.lookup(XmlDbService.class.getName());
  		} catch (NamingException e) {
  			LOGGER.fatal("Unable to lookup XmlDbService", e);
  		}
  	}
  	
  	/***
  	 * Gets the XmlDbHandler instance.
  	 * 
  	 * @return the XmlDbHandler
  	 */
  	public static synchronized XmlDbHandler getHandler() {
  		if (handler == null) {
  			try {
  				handler = new XmlDbHandler();
  			} catch (Throwable t) {
  				LOGGER.fatal("Unable to create XmlDbHandler", t);
  			}
  		}
  		return handler;
  	}
  
  	/***
  	 * Get first XMLResource in collection matching specified query.
  	 * 
  	 * TODO includes subcollections?
  	 * 
  	 * @param parent
  	 *            full path of parent collection, using '/' as path separator
  	 * @param query
  	 *            XPath query string
  	 * @param namespaceMappings
  	 *            prefix -> namespace URI mappings
  	 * @return first XMLResource matching query, or null if none is found or
  	 *         error occurs
  	 */
  	public XMLResource getSingleXmlResource(String parent, String query, Map namespaceMappings) {
  		Collection c = null;
  		try {
 			c = getCollection(parent);
 			ResourceSet set = getResourceSet(c, query, namespaceMappings);
 			if (set == null || set.getSize() == 0) {
 				return null;
 			}
 			// TODO What to do if multiple resources?
 			Resource r = set.getResource(0);
 			if (r instanceof XMLResource) {
 				return (XMLResource) r;
 			}
 		} catch (XMLDBException e) {
 			LOGGER.error("Error while getting XML resource with query " + query
 					+ " on collection " + parent, e);
 		} finally {
 			if (c != null) {
 				try {
 					c.close();
 				} catch (XMLDBException e) {
 					LOGGER.warn("Could not close collection " + c, e);
 				}
 			}
 		}
 		return null;
 	}
 
 	/***
 	 * Get XMLResources in collection matching specified query. Resources which
 	 * could not be loaded from database because of errors are not included in
 	 * result.
 	 * 
 	 * TODO includes subcollections?
 	 * 
 	 * @param parent
 	 *            full path of parent collection, using '/' as path separator
 	 * @param query
 	 *            XPath query
 	 * @param namespaceMappings
 	 *            prefix -> namespace URI mappings
 	 * @return array of XMLResources matching query, possibly empty (never null)
 	 */
 	public XMLResource[] getXmlResources(String parent, String query, Map namespaceMappings) {
 		Collection c = null;
 		try {
 			c = getCollection(parent); 
 			ResourceSet set = getResourceSet(c, query, namespaceMappings);
 			if (set == null) {
 				return new XMLResource[0];
 			}
 			ArrayList resources = new ArrayList();
 			for (int i = 0; i < set.getSize(); i++) {
 				try {
 					Resource r = set.getResource(i);
 					if (r instanceof XMLResource) {
 						resources.add(r);
 					}
 				} catch (XMLDBException e) {
 					LOGGER.error("Error while getting XML resource with query " + query
 							+ " on collection " + parent, e);
 				}
 			}
 			return (XMLResource[]) resources.toArray(new XMLResource[0]);
 		} catch (XMLDBException e) {
 			LOGGER.error("Error while getting XML resources with query " + query
 					+ " on collection " + parent, e);
 			return new XMLResource[0];
 		} finally {
 			if (c != null) {
 				try {
 					c.close();
 				} catch (XMLDBException e) {
 					LOGGER.warn("Could not close collection " + c, e);
 				}
 			}
 		}
 	}
 
 	/***
 	 * Create XMLResource in specified collection.
 	 * 
 	 * @param parent
 	 *            full path of parent collection to create resource in, using
 	 *            '/' as path separator
 	 * @return the created XMLResource, or null if error occured
 	 */
 	public XMLResource createXmlResource(String parent) {
 		if (parent == null) {
 			return null;
 		}
 		Collection c = getCollection(parent);
 		if (c == null) {
 			c = createCollection(parent);
 		}
 		if (c == null) {
 			return null;
 		}
 		try {
 			return (XMLResource) c.createResource(null, XMLResource.RESOURCE_TYPE);
 		} catch (XMLDBException e) {
 			LOGGER.error("Could not create XMLResource in collection " + parent, e);
 			return null;
 		} finally {
 			try {
 				c.close();
 			} catch (XMLDBException e) {
 				LOGGER.warn("Could not close collection " + c, e);
 			}
 		}
 	}
 
 	/***
 	 * Delete XMLResource.
 	 * 
 	 * @param resource
 	 *            resource to delete
 	 * @throws XMLDBException
 	 *             if resource cannot be deleted from database
 	 */
 	public void deleteResource(XMLResource resource) throws XMLDBException {
 		if (resource == null) {
 			return;
 		}
 		Collection c = null;
 		try {
 			c = resource.getParentCollection();
 			c.removeResource(resource);
 		} catch (XMLDBException e) {
 			LOGGER.error("Could not remove XMLResource " + resource + " from collection " + c, e);
 			throw e;
 		} finally {
 			if (c != null) {
 				try {
 					c.close();
 				} catch (XMLDBException e) {
 					LOGGER.warn("Could not close collection " + c, e);
 				}
 			}
 		}
 	}
 
 	/***
 	 * Store an XMLResource in the database.
 	 * 
 	 * @param resource
 	 *            the XMLResource to store
 	 * @throws XMLDBException
 	 *             if error occurs when storing resource in database
 	 */
 	public void storeResource(XMLResource resource) throws XMLDBException {
 		if (resource == null) {
 			return;
 		}
 		Collection c = null;
 		try {
 			c = resource.getParentCollection();
 			c.storeResource(resource);
 		} catch (XMLDBException e) {
 			LOGGER.error("Could not store XMLResource " + resource.getDocumentId()
 					+ " in collection " + c.getName(), e);
 			throw e;
 		} finally {
 			if (c != null) {
 				try {
 					c.close();
 				} catch (XMLDBException e) {
 					LOGGER.warn("Could not close collection " + c, e);
 				}
 			}
 		}
 	}
 
 	/***
 	 * Create a collection in the database.
 	 * 
 	 * @param path
 	 *            full path specifying location and name of collection, using
 	 *            '/' as path separator
 	 * @return the XML:DB Collection, or null if error occured
 	 */
 	private Collection createCollection(String path) {
 		LOGGER.debug("Create collection " + path);
 		if (path == null) {
 			return null;
 		}
 		int pos = path.lastIndexOf('/');
 		String parentName = pos == -1 ? "" : path.substring(0, pos);
 		String name = pos == -1 ? path : path.substring(pos + 1);
 		Collection parentCollection = null; 
 		try {
 			parentCollection = getCollection(parentName);
 			if (parentCollection == null && !("".equals(parentName))) {
 				parentCollection = createCollection(parentName);
 			}
 			if (parentCollection == null) {
 				LOGGER.error("Could not create parent collection " + parentName);
 				return null;
 			}
 			CollectionManagementService service = 
 				(CollectionManagementService) parentCollection.getService(
 						"CollectionManagementService", "1.0");
 			return service.createCollection(name);
 		} catch (XMLDBException e) {
 			LOGGER.error("Could not create Collection " + path, e);
 			return null;
 		} finally {
 			try {
 				parentCollection.close();
 			} catch (XMLDBException e) {
 				LOGGER.warn("Could not close collection " + parentCollection, e);
 			}
 		}
 	}
 
 	/***
 	 * Get the set of XMLResources matching the query.
 	 * 
 	 * @param parent
 	 *            the parent collection
 	 * @param query
 	 *            XPath query string
 	 * @param namespaceMappings
 	 *            prefix -> namespace URI mappings
 	 * @return ResourceSet containing XMLResources matching query
 	 */
 	private ResourceSet getResourceSet(Collection parent, String query, Map namespaceMappings) {
 		LOGGER.debug("getResourceSet(" + parent + ", " + query + ")");
 		if (query == null || parent == null) {
 			return null;
 		}
 		
 		XPathQueryService queryService = getXPathQueryService(parent);
 		try {
 			// TODO: need namespace declaration?
 		    if (namespaceMappings != null) {
 		        for (Iterator i = namespaceMappings.keySet().iterator(); i.hasNext();) {
                     Object name = i.next();
                     Object uri = namespaceMappings.get(name);
                     if ((name instanceof String) && (uri instanceof String)) {
                         queryService.setNamespace((String) name, (String) uri);
                     } // TODO else what?
                 }
 		    }
 			return queryService.query(query);
 		} catch (XMLDBException e) {
 			LOGGER.error("Unable to perform XPath query " + query + " on collection " + parent, e);
 			return null;
 		} finally {
 			try {
 				parent.close();
 			} catch (XMLDBException e) {
 				LOGGER.warn("Unable to close collection " + parent, e);
 			}
 		}
 	}
 
 	/***
 	 * Get the specified Collection from the database.
 	 * 
 	 * @param path
 	 *            full path specifying location and name of collection, using
 	 *            '/' as path separator
 	 * @return the Collection, or null if error occurs
 	 */
 	private Collection getCollection(String path) {
 		try {
 			if (path == null) {
 				return null;
 			}
 			Collection result = xmlDbService.getBaseCollection();
 			StringTokenizer tk = new StringTokenizer(path, "/");
 			while (result != null && tk.hasMoreTokens()) {
 				String name = tk.nextToken();
 				if (name == null || name.equals("")) {
 					continue;
 				}
 				result = result.getChildCollection(name);
 			}
 			return result;
 		} catch (XMLDBException e) {
 			LOGGER.error("Error while looking up collection " + path, e);
 			return null;
 		}
 	}
 
 	/***
 	 * Get XPathQueryService for collection.
 	 * 
 	 * @param collection
 	 *            the collection
 	 * @return the XPathQueryService, or null if error occurs
 	 */
 	private static XPathQueryService getXPathQueryService(Collection collection) {
 		if (collection == null) {
 			return null;
 		}
 		Service s = null;
 		try {
 			s = collection.getService("XPathQueryService", "1.0");
 		} catch (XMLDBException e) {
 			LOGGER.error("Error while getting XPathQueryService for collection " + collection, e);
 		}
 		if (s instanceof XPathQueryService) {
 			return (XPathQueryService) s;
 		} else {
 			LOGGER.error("Unable to get XPathQueryService for collection " + collection + ", got " + s);
 			return null;
 		}
 	}
 
 	
 }