/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


package org.apache.oodt.profile.handlers.lightweight;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Stack;
import org.apache.oodt.commons.Configuration;
import org.apache.oodt.commons.ExecServerConfig;
import org.apache.oodt.profile.Profile;
import org.apache.oodt.profile.ProfileException;
import org.apache.oodt.profile.handlers.ProfileHandler;
import org.apache.oodt.commons.util.DOMParser;
import org.apache.oodt.commons.util.XML;
import org.apache.oodt.xmlquery.QueryElement;
import org.apache.oodt.xmlquery.XMLQuery;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

/**
 * A lightweight profile server.
 *
 * A lightweight profile server is lightweight because it doesn't rely on any external
 * database or other search/retrieval mechanism.
 *
 * @author Kelly
 */
final public class LightweightProfileServer implements ProfileHandler {
	/**
	 * Create a lightweight profile server using defaults.
	 *
	 * @throws IOException If an I/O error occurs.
	 * @throws SAXException If an error occurs parsing the profile file.
	 * @throws MalformedURLException If the default profile URL is malformed.
	 */
	public LightweightProfileServer() throws IOException, SAXException, MalformedURLException {
		this(System.getProperties());
	}

	/**
	 * Create a lightweight profile server using the given properties.
	 *
	 * The property we use is
	 * <code>profiles.url</code>,
	 * which is the URL of the file containing profile definitions that this server
	 * will read and serve.
	 *
	 * @param props Properties.
	 * @throws IOException If an I/O error occurs.
	 * @throws SAXException If an error occurs parsing the profile file.
	 * @throws MalformedURLException If the URL to the profile file is malformed.
	 */
	public LightweightProfileServer(Properties props) throws IOException, SAXException, MalformedURLException {
		this(new URL(props.getProperty("org.apache.oodt.profile.handlers.LightweightProfileServer.profiles.url",
                        props.getProperty("org.apache.oodt.profile.webServer.baseURL", "http://eda.jpl.nasa.gov")
                        + "/profiles.xml")),
			props.getProperty("org.apache.oodt.profile.handlers.LightweightProfileServer.id", "lightweight"));
	}

	/**
	 * Create a lightweight profile server using the given URL.
	 *
	 * @param url URL of the file containing profile definitions that this server will read and serve.
	 * @param id Identifier to report for when this handler is queried by name.
	 * @throws IOException If an I/O error occurs.
	 * @throws SAXException If an error occurs parsing the profile file.
	 * @throws MalformedURLException If <var>url</var> is malformed.
	 */
	public LightweightProfileServer(URL url, String id) throws IOException, SAXException, MalformedURLException {
		this.id = id;

		// Get the list of profiles from the cache, if it's there.
		profiles = (List) cache.get(url);
		if (profiles != null) return;

		// It wasn't in the cache, so create a parser to parse the file.  We only
		// deal with correct files, so turn on validation and install an error
		// handler that will throw an exception.
		profiles = new ArrayList();
		DOMParser parser = XML.createDOMParser();
		parser.setErrorHandler(new ErrorHandler() {
			public void error(SAXParseException ex) throws SAXParseException {
				System.err.println("Parse error line " + ex.getLineNumber() + " column "
					+ ex.getColumnNumber() + ": " + ex.getMessage());
				throw ex;
			}
			public void warning(SAXParseException ex) {
				System.err.println("Parse warning: " + ex.getMessage());
			}
			public void fatalError(SAXParseException ex) throws SAXParseException {
				throw ex;
			}
		});

		// Parse the file.
		InputSource inputSource = new InputSource(url.toString());
		parser.parse(inputSource);
		Document doc = parser.getDocument();

		// Normalize it and get the document element, and from that, create a list
		// of profiles, and add it to the cache.
		doc.normalize();
		Element root = doc.getDocumentElement();
		profiles = Profile.createProfiles(root, new SearchableObjectFactory());
		cache.put(url, profiles);

		System.err.println("LightweightProfileServer ready");
	}

	public List findProfiles(XMLQuery query) throws ProfileException {
		// Compute the where-expression based on the query string, and start off
		// with an empty set of results.
		Set matchingProfiles = new HashSet();
		WhereExpression whereExpression = createWhereExpression(query);

		// Search each profile, and add the results of the search to the set of results.
		for (Iterator i = profiles.iterator(); i.hasNext();) {
			SearchableProfile profile = (SearchableProfile) i.next();

			// Search the profile with the where-expression.
			Result result = profile.search(whereExpression);

			// If there are any matching elements, add the profile to the set.
			if (!result.matchingElements().isEmpty())
				matchingProfiles.add(profile);
		}

		// Convert from set to list.
		return new ArrayList(matchingProfiles);
	}

	/**
	 * Get a single profile matching the given ID.
	 *
	 * @param profID a {@link String} value.
	 * @return a {@link Profile} value.
	 */
	public Profile get(String profID) {
		if (profID == null) return null;
		Profile rc = null;
		for (Iterator i = profiles.iterator(); i.hasNext();) {
			Profile p = (Profile) i.next();
			if (p.getProfileAttributes().getID().equals(profID)) {
				rc = p;
				break;
			}
		}
		return rc;
	}

	/**
	 * Convert the XML query to a where expression.
	 *
	 * @param query The query to convert
	 * @return The equivalent, simplified where expression.
	 */
	private static WhereExpression createWhereExpression(XMLQuery query) {
		Stack stack = new Stack();
		 
		// Collect together the where- and from-sets, joined with an "and".
		List allElements = new ArrayList(query.getWhereElementSet());
		List fromElements = query.getFromElementSet();
		if (!fromElements.isEmpty()) {
			allElements.addAll(fromElements);
			allElements.add(new QueryElement("LOGOP", "AND"));
		}
		
		// For each item in the where-set
		for (Iterator i = allElements.iterator(); i.hasNext();) {
			QueryElement queryElement = (QueryElement) i.next();

			// Get the keyword and its type.
			String keyword = queryElement.getValue();
			String type = queryElement.getRole();

			if (type.equals("elemName")) {
				// It's an element name, so push the element name.
				stack.push(keyword);
			} else if (type.equals("LITERAL")) {
				// It's a literal value, so push the value.
				stack.push(keyword);
			} else if (type.equals("LOGOP")) {
				// It's a logical operator.  Pop the operands off the
				// stack and push the appropriate operator back on.
				if (keyword.equals("AND")) {
					stack.push(new AndExpression((WhereExpression) stack.pop(), (WhereExpression)stack.pop()));
				} else if (keyword.equals("OR")) {
					stack.push(new OrExpression((WhereExpression) stack.pop(), (WhereExpression)stack.pop()));
				} else if (keyword.equals("NOT")) {
					stack.push(new NotExpression((WhereExpression) stack.pop()));
				} else throw new IllegalArgumentException("Illegal operator \"" + keyword + "\" in query");
			} else if (type.equals("RELOP")) {
				// It's a relational operator.  Pop the element name and
				// literal value off the stack, and push the operator
				// expression on with the given operator.
				stack.push(new OperatorExpression((String) stack.pop(), (String) stack.pop(), keyword));
			}
		}

		// If there's nothing on the stack, we're given nothing, so give back everything.
		if (stack.size() == 0)
			return new ConstantExpression(true);
		else if (stack.size() > 1)
			throw new IllegalStateException("Imbalanced expression in query");
		
		// Simplify/optimize the where-expression and return it.
		return ((WhereExpression) stack.pop()).simplify();
	}

	/** {@inheritDoc} */
	public String getID() {
		return id;
	}

	/** Profiles I serve. */
	private List profiles;

	/**
	 * Cache of profiles.
	 *
	 * This is a mapping from {@link java.net.URL} of the profile source to the {@link
	 * List} of profiles.  We do this so we don't have to keep rereading and reparsing
	 * the possibly huge profile file each time an object of this class is
	 * instantiated.
	 *
	 * <p><em>Question:</em> Since when are multiple LightweightProfileServers being
	 * constructed anyway?  There's just one per profile server process, and it's
	 * using just the one file, so there should be no need for this cache.  Who added
	 * this?  And if it were me, what was I smoking?
	 */
	private static Map cache = new HashMap();

	/** My ID. */
	private String id;

	/**
	 * Application execution entry point.
	 *
	 * This lets you try out a query to the Lightweight Profile server.
	 *
	 * @param argv Command-line arguments.
	 * @throws Exception Should any error occur.
	 */
	public static void main(String[] argv) throws Exception {
		if (argv.length == 0) {
			System.err.println("Usage: <query>...");
			System.exit(1);
		}

		// Create the profile
		LightweightProfileServer lp = new LightweightProfileServer();

		// Gather together the command-line arguments into a single long string.
		StringBuffer b = new StringBuffer();
		for (int i = 0; i < argv.length; ++i)
			b.append(argv[i]).append(' ');

		// Create the query object from the expression.
		XMLQuery query = new XMLQuery(b.toString().trim(), /*id*/"cli1", /*title*/"CmdLine-1",
			/*desc*/"This is a query entered on the command-line", /*ddId*/null, /*resultModeId*/null,
			/*propType*/null, /*propLevels*/null, XMLQuery.DEFAULT_MAX_RESULTS);

		// Display the results.
		System.out.println(lp.findProfiles(query));

		// All done.
		System.exit(0);
	}
}