package org.apache.fulcrum.upload;

/*
 * 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.
 */

import java.io.File;
import java.io.IOException;
import java.util.List;

import javax.portlet.ActionRequest;
import javax.servlet.http.HttpServletRequest;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemIterator;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.portlet.PortletFileUpload;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

/**
 * <p>
 * This class is an implementation of {@link UploadService}.
 *
 * <p>
 * Files will be stored in temporary disk storage on in memory, depending on
 * request size, and will be available from the
 * <code>org.apache.fulcrum.util.parser.ParameterParser</code> as
 * <code>org.apache.commons.fileupload.FileItem</code> objects.
 *
 * <p>
 * This implementation of {@link UploadService} handles multiple files per
 * single html form, sent using multipart/form-data encoding type, as specified
 * by RFC 1867. Use
 * <code>org.apache.fulcrum.parser.ParameterParser#getFileItems(String)</code> to
 * acquire an array of <code>org.apache.commons.fileupload.FileItem</code> objects
 * associated with given html form.
 *
 * @author <a href="mailto:Rafal.Krzewski@e-point.pl">Rafal Krzewski</a>
 * @author <a href="mailto:dlr@collab.net">Daniel Rall</a>
 * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
 * @version $Id$
 */
public class DefaultUploadService extends AbstractLogEnabled
		implements UploadService, Initializable, Configurable, Contextualizable {
	/** A File Item Factory object for the actual uploading */
	private DiskFileItemFactory itemFactory;

	private int sizeThreshold;
	private int sizeMax;

	private String repositoryPath;
	private String headerEncoding;

	/**
	 * The application root
	 */
	private String applicationRoot;

	/**
	 * The maximum allowed upload size
	 */
	@Override
	public long getSizeMax() {
		return sizeMax;
	}

	/**
	 * The threshold beyond which files are written directly to disk.
	 */
	@Override
	public long getSizeThreshold() {
		return itemFactory.getSizeThreshold();
	}

	/**
	 * The location used to temporarily store files that are larger than the size
	 * threshold.
	 */
	@Override
	public String getRepository() {
		return itemFactory.getRepository().getAbsolutePath();
	}

	/**
	 * @return Returns the headerEncoding.
	 */
	@Override
	public String getHeaderEncoding() {
		return headerEncoding;
	}

	/**
	 * <p>
	 * Parses a <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant
	 * <code>multipart/form-data</code> stream.
	 * </p>
	 *
	 * @param req The servlet request to be parsed.
	 * @throws ServiceException Problems reading/parsing the request or storing the
	 *                          uploaded file(s).
	 */
	@Override
	public List<FileItem> parseRequest(HttpServletRequest req) throws ServiceException {
		return parseRequest(req, this.sizeMax, this.itemFactory);
	}

	/**
	 * <p>
	 * Parses a <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant
	 * <code>multipart/form-data</code> stream.
	 * </p>
	 *
	 * @param req  The servlet request to be parsed.
	 * @param path The location where the files should be stored.
	 * @throws ServiceException Problems reading/parsing the request or storing the
	 *                          uploaded file(s).
	 */
	@Override
	public List<FileItem> parseRequest(HttpServletRequest req, String path) throws ServiceException {
		return parseRequest(req, this.sizeThreshold, this.sizeMax, path);
	}

	/**
	 * <p>
	 * Parses a <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant
	 * <code>multipart/form-data</code> stream.
	 * </p>
	 *
	 * @param req           The servlet request to be parsed.
	 * @param sizeThreshold the max size in bytes to be stored in memory
	 * @param sizeMax       the maximum allowed upload size in bytes
	 * @param path          The location where the files should be stored.
	 * @return list of file items
	 * @throws ServiceException Problems reading/parsing the request or storing the
	 *                          uploaded file(s).
	 */
	@Override
	public List<FileItem> parseRequest(HttpServletRequest req, int sizeThreshold, int sizeMax, String path)
			throws ServiceException {
		return parseRequest(req, sizeMax, new DiskFileItemFactory(sizeThreshold, new File(path)));
	}

	/**
	 * <p>
	 * Parses a <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant
	 * <code>multipart/form-data</code> stream.
	 * </p>
	 *
	 * @param req     The servlet request to be parsed.
	 * @param sizeMax the maximum allowed upload size in bytes
	 * @param factory the file item factory to use
	 * @return list of file items
	 * @throws ServiceException Problems reading/parsing the request or storing the
	 *                          uploaded file(s).
	 */
	protected List<FileItem> parseRequest(HttpServletRequest req, int sizeMax, DiskFileItemFactory factory)
			throws ServiceException {
		try {
			ServletFileUpload fileUpload = new ServletFileUpload(factory);
			fileUpload.setSizeMax(sizeMax);
			fileUpload.setHeaderEncoding(headerEncoding);
			return fileUpload.parseRequest(req);
		} catch (FileUploadException e) {
			throw new ServiceException(UploadService.ROLE, e.getMessage(), e);
		}
	}

	/**
	 * Processes an <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a>
	 * compliant <code>multipart/form-data</code> stream.
	 *
	 * @param req The servlet request to be parsed.
	 *
	 * @return An iterator to instances of <code>FileItemStream</code> parsed from
	 *         the request, in the order that they were transmitted.
	 *
	 * @throws ServiceException if there are problems reading/parsing the request or
	 *                          storing files. This may also be a network error
	 *                          while communicating with the client or a problem
	 *                          while storing the uploaded content.
	 */
	@Override
	public FileItemIterator getItemIterator(HttpServletRequest req) throws ServiceException {
		ServletFileUpload upload = new ServletFileUpload();
		try {
			return upload.getItemIterator(req);
		} catch (FileUploadException e) {
			throw new ServiceException(UploadService.ROLE, e.getMessage(), e);
		} catch (IOException e) {
			throw new ServiceException(UploadService.ROLE, e.getMessage(), e);
		}
	}

	/**
	 * <p>
	 * Parses a <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant
	 * <code>multipart/form-data</code> stream.
	 * </p>
	 *
	 * @param req The portlet request to be parsed.
	 * @throws ServiceException Problems reading/parsing the request or storing the
	 *                          uploaded file(s).
	 */
	@Override
	public List<FileItem> parseRequest(ActionRequest req) throws ServiceException {
		return parseRequest(req, this.sizeMax, this.itemFactory);
	}

	/**
	 * <p>
	 * Parses a <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant
	 * <code>multipart/form-data</code> stream.
	 * </p>
	 *
	 * @param req  The portlet request to be parsed.
	 * @param path The location where the files should be stored.
	 * @throws ServiceException Problems reading/parsing the request or storing the
	 *                          uploaded file(s).
	 */
	@Override
	public List<FileItem> parseRequest(ActionRequest req, String path) throws ServiceException {
		return parseRequest(req, this.sizeThreshold, this.sizeMax, path);
	}

	/**
	 * <p>
	 * Parses a <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant
	 * <code>multipart/form-data</code> stream.
	 * </p>
	 *
	 * @param req           The portlet request to be parsed.
	 * @param sizeThreshold the max size in bytes to be stored in memory
	 * @param sizeMax       the maximum allowed upload size in bytes
	 * @param path          The location where the files should be stored.
	 * @throws ServiceException Problems reading/parsing the request or storing the
	 *                          uploaded file(s).
	 */
	@Override
	public List<FileItem> parseRequest(ActionRequest req, int sizeThreshold, int sizeMax, String path)
			throws ServiceException {
		return parseRequest(req, sizeMax, new DiskFileItemFactory(sizeThreshold, new File(path)));
	}

	/**
	 * <p>
	 * Parses a <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a> compliant
	 * <code>multipart/form-data</code> stream.
	 * </p>
	 *
	 * @param req     The portlet request to be parsed.
	 * @param sizeMax the maximum allowed upload size in bytes
	 * @param factory the file item factory to use
	 * @return The list of FileItem parts uploaded
	 * @throws ServiceException Problems reading/parsing the request or storing the
	 *                          uploaded file(s).
	 */
	protected List<FileItem> parseRequest(ActionRequest req, int sizeMax, DiskFileItemFactory factory)
			throws ServiceException {
		try {
			PortletFileUpload fileUpload = new PortletFileUpload(factory);
			fileUpload.setSizeMax(sizeMax);
			fileUpload.setHeaderEncoding(headerEncoding);
			return fileUpload.parseRequest(req);
		} catch (FileUploadException e) {
			throw new ServiceException(UploadService.ROLE, e.getMessage(), e);
		}
	}

	/**
	 * Processes an <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a>
	 * compliant <code>multipart/form-data</code> stream.
	 *
	 * @param req The portlet request to be parsed.
	 *
	 * @return An iterator to instances of <code>FileItemStream</code> parsed from
	 *         the request, in the order that they were transmitted.
	 *
	 * @throws ServiceException if there are problems reading/parsing the request or
	 *                          storing files. This may also be a network error
	 *                          while communicating with the client or a problem
	 *                          while storing the uploaded content.
	 */
	@Override
	public FileItemIterator getItemIterator(ActionRequest req) throws ServiceException {
		PortletFileUpload upload = new PortletFileUpload();
		try {
			return upload.getItemIterator(req);
		} catch (FileUploadException e) {
			throw new ServiceException(UploadService.ROLE, e.getMessage(), e);
		} catch (IOException e) {
			throw new ServiceException(UploadService.ROLE, e.getMessage(), e);
		}
	}

	/**
	 * Utility method that determines whether the request contains multipart
	 * content.
	 *
	 * @param req The servlet request to be evaluated. Must be non-null.
	 *
	 * @return <code>true</code> if the request is multipart; <code>false</code>
	 *         otherwise.
	 */
	@Override
	public boolean isMultipart(HttpServletRequest req) {
		return ServletFileUpload.isMultipartContent(req);
	}

	/**
	 * Utility method that determines whether the request contains multipart
	 * content.
	 *
	 * @param req The portlet request to be evaluated. Must be non-null.
	 *
	 * @return <code>true</code> if the request is multipart; <code>false</code>
	 *         otherwise.
	 */
	@Override
	public boolean isMultipart(ActionRequest req) {
		return PortletFileUpload.isMultipartContent(req);
	}

	/**
	 * @see org.apache.fulcrum.ServiceBroker#getRealPath(String)
	 */
	private String getRealPath(String path) {
		String absolutePath = null;
		if (applicationRoot == null) {
			absolutePath = new File(path).getAbsolutePath();
		} else {
			absolutePath = new File(applicationRoot, path).getAbsolutePath();
		}

		return absolutePath;
	}

	// ---------------- Avalon Lifecycle Methods ---------------------
	/**
	 * Avalon component lifecycle method
	 */
	@Override
	public void configure(Configuration conf) {
		repositoryPath = conf.getAttribute(UploadService.REPOSITORY_KEY, UploadService.REPOSITORY_DEFAULT);

		headerEncoding = conf.getAttribute(UploadService.HEADER_ENCODING_KEY, UploadService.HEADER_ENCODING_DEFAULT);

		sizeMax = conf.getAttributeAsInteger(UploadService.SIZE_MAX_KEY, UploadService.SIZE_MAX_DEFAULT);

		sizeThreshold = conf.getAttributeAsInteger(UploadService.SIZE_THRESHOLD_KEY,
				UploadService.SIZE_THRESHOLD_DEFAULT);
	}

	/**
	 * Avalon component lifecycle method
	 *
	 * Initializes the service.
	 *
	 * This method processes the repository path, to make it relative to the web
	 * application root, if necessary
	 */
	@Override
	public void initialize() throws Exception {
		// test for the existence of the path within the webapp directory.
		// if it does not exist, assume the path was to be used as is.
		String testPath = getRealPath(repositoryPath);
		File testDir = new File(testPath);
		if (testDir.exists()) {
			repositoryPath = testPath;
		}

		getLogger().debug("Upload Service: REPOSITORY_KEY => " + repositoryPath);

		itemFactory = new DiskFileItemFactory(sizeThreshold, new File(repositoryPath));
	}

	/**
	 * Avalon component lifecycle method
	 */
	@Override
	public void contextualize(Context context) throws ContextException {
		this.applicationRoot = context.get("urn:avalon:home").toString();
	}
}