/*
    * Copyright 2008 Simon Martinelli, Rebenweg 32, 3236 Gampelen, Switzerland
    *
    * Licensed 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.simject.remoting.server;
  
  import java.beans.XMLDecoder;
  import java.beans.XMLEncoder;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.StringTokenizer;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.simject.SimFactory;
  import org.simject.util.Protocol;
  import org.simject.util.SimConstants;
  
  /**
   * This servlet can be used as endpoint for remote access over HTTP to a
   * resource
   * 
   * @author Simon Martinelli
   */
  @SuppressWarnings("serial")
  public class SimServerServlet extends HttpServlet {
  
  	private final static Logger logger = Logger
  			.getLogger(SimServerServlet.class.getName());
  
  	/**
  	 * Context parameter that contains the configuration file location
  	 */
  	private final static String SIMJECT_CONFIG = "simjectConfig";
  
  	/**
  	 * Reference to the SimFactory
  	 */
  	private SimFactory simFactory;
  
  	@Override
  	public void init() throws ServletException {
  		if (this.simFactory == null) {
  			// Get the context parameter with the config file
  			final String configFile = this.getServletContext()
  					.getInitParameter(SIMJECT_CONFIG);
  			// create a SimFactory based on the config file
  			this.simFactory = new SimFactory(configFile);
  		}
  	}
  
  	@Override
  	protected void doPost(final HttpServletRequest req,
  			final HttpServletResponse resp) throws ServletException,
  			IOException {
  		this.invokeMethod(req, resp);
  	}
  
  	/**
  	 * Invokes a method based on the parameters passed from the client
  	 * 
  	 * @param req
  	 * @param resp
  	 * @param obj
  	 * @param args
  	 * @throws IOException
  	 * @throws IllegalAccessException
  	 * @throws InvocationTargetException
  	 * @throws IOException
  	 * @throws ClassNotFoundException
  	 * @throws NoSuchMethodException
  	 * @throws SecurityException
  	 */
  	private void invokeMethod(final HttpServletRequest req,
  			final HttpServletResponse resp) throws IOException {
  
  		Object result = null;
  		try {
  			// get the classname
 			final String className = this.getClassName(req);
 			// create a Class instance
 			final Class<?> clazz = Class.forName(className);
 			// and get the resource from the SimFactory
 			final Object obj = this.simFactory.getResource(clazz);
 			// get passed arguments and invoke the method
 			final Object[] args = this.getArguments(req);
 			// get the method name from the HTTP header
 			final String methodString = req
 					.getHeader(SimConstants.PARAM_METHOD);
 
 			// get the parameter types from the HTTP header
 			final String paramTypesString = req
 					.getHeader(SimConstants.PARAM_TYPES);
 
 			logger.info("Request for class <" + clazz.getName() + "> method <"
 					+ methodString + "> params <" + paramTypesString + ">");
 
 			if (paramTypesString == null) {
 				// method without parameters to invoke
 				final Method method = obj.getClass().getMethod(methodString);
 				result = method.invoke(obj);
 			} else {
 				// method with parameters should be called. Converts the string
 				// from the header to Class array
 				final Class<?>[] parameterTypes = this
 						.getParameterTypes(paramTypesString);
 				final Method method = obj.getClass().getMethod(methodString,
 						parameterTypes);
 
 				result = method.invoke(obj, args);
 			}
 		} catch (Exception e) {
 			// If an exception occurs during invocation put it in the result to
 			// have it serialized
 			logger.log(Level.INFO, "Exception occured during invocation", e);
 			result = e;
 		}
 		if (result != null) {
 			if (req.getContentType().equals(Protocol.Xml.getContentType())) {
 				this.sendXmlResponse(resp, result);
 			} else {
 				this.sendBinaryResponse(resp, result);
 			}
 		}
 	}
 
 	/**
 	 * Sends the result as binary stream
 	 * 
 	 * @param resp
 	 * @param result
 	 * @throws IOException
 	 */
 	private void sendBinaryResponse(final HttpServletResponse resp,
 			final Object result) throws IOException {
 		final ByteArrayOutputStream baos = new ByteArrayOutputStream();
 		final ObjectOutputStream oos = new ObjectOutputStream(baos);
 		oos.writeObject(result);
 		oos.close();
 
 		resp.setContentType(Protocol.Binary.getContentType());
 		resp.getOutputStream().write(baos.toByteArray());
 	}
 
 	/**
 	 * Sends the result as XML stream
 	 * 
 	 * @param resp
 	 * @param result
 	 * @throws IOException
 	 */
 	private void sendXmlResponse(final HttpServletResponse resp,
 			final Object result) throws IOException {
 		resp.setContentType(Protocol.Xml.getContentType());
 		final XMLEncoder encoder = new XMLEncoder(resp.getOutputStream());
 		encoder.writeObject(result);
 	}
 
 	/**
 	 * Returns an array of Class containing the types of the parameters
 	 * 
 	 * @param parameterString
 	 * @return
 	 * @throws ClassNotFoundException
 	 */
 	private Class<?>[] getParameterTypes(final String parameterString)
 			throws ClassNotFoundException {
 		Class<?>[] parameters = new Class[0];
 		if (parameterString != null) {
 			// The parameter types are seperated by ","
 			final StringTokenizer stokenizer = new StringTokenizer(
 					parameterString, SimConstants.PARAM_TYPE_DELIM);
 			parameters = new Class[stokenizer.countTokens()];
 			int index = 0;
 			while (stokenizer.hasMoreTokens()) {
 				final String className = stokenizer.nextToken();
 
 				final Class<?> clazz = Class.forName(className);
 				parameters[index] = clazz;
 				index++;
 			}
 		}
 		return parameters;
 	}
 
 	/**
 	 * Get Arguments
 	 * 
 	 * @param req
 	 * @return
 	 * @throws IOException
 	 * @throws ClassNotFoundException
 	 */
 	private Object[] getArguments(final HttpServletRequest req)
 			throws IOException, ClassNotFoundException {
 
 		Object args = null;
 		if (req.getContentType().equals(Protocol.Xml.getContentType())) {
 			final XMLDecoder decoder = new XMLDecoder(req.getInputStream());
 			args = decoder.readObject();
 		} else {
 			final ObjectInputStream ois = new ObjectInputStream(req
 					.getInputStream());
 			args = ois.readObject();
 		}
 
 		return (Object[]) args;
 	}
 
 	/**
 	 * Parses the class name out of the path info
 	 * 
 	 * @param req
 	 * @return
 	 */
 	private String getClassName(final HttpServletRequest req) {
 		final StringTokenizer stokenzier = new StringTokenizer(req
 				.getPathInfo(), "/");
 		String[] tokens = new String[stokenzier.countTokens()];
 		int index = 0;
 		while (stokenzier.hasMoreTokens()) {
 			tokens[index] = stokenzier.nextToken();
 			index++;
 		}
 		return tokens[0];
 	}
 
 	@Override
 	protected void doGet(final HttpServletRequest req,
 			final HttpServletResponse resp) throws ServletException,
 			IOException {
 		this.doPost(req, resp);
 	}
 }