/**
 * 
 */
package org.gcube.portlets.widgets.workspaceuploader.server;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileItemIterator;
import org.apache.commons.fileupload.FileItemStream;
import org.apache.commons.fileupload.FileUploadBase;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.util.Streams;
import org.apache.commons.io.FilenameUtils;
import org.gcube.common.homelibary.model.items.type.WorkspaceItemType;
import org.gcube.common.homelibrary.home.exceptions.InternalErrorException;
import org.gcube.common.homelibrary.home.workspace.Workspace;
import org.gcube.common.homelibrary.home.workspace.WorkspaceFolder;
import org.gcube.common.homelibrary.home.workspace.WorkspaceItem;
import org.gcube.common.homelibrary.home.workspace.exceptions.InsufficientPrivilegesException;
import org.gcube.common.homelibrary.home.workspace.exceptions.ItemAlreadyExistException;
import org.gcube.common.homelibrary.home.workspace.exceptions.ItemNotFoundException;
import org.gcube.common.homelibrary.home.workspace.exceptions.WorkspaceFolderNotFoundException;
import org.gcube.common.homelibrary.home.workspace.exceptions.WrongDestinationException;
import org.gcube.common.homelibrary.home.workspace.exceptions.WrongItemTypeException;
import org.gcube.common.homelibrary.home.workspace.folder.FolderItem;
import org.gcube.common.homelibrary.home.workspace.folder.items.Report;
import org.gcube.common.homelibrary.home.workspace.folder.items.ReportTemplate;
import org.gcube.common.homelibrary.util.Extensions;
import org.gcube.common.homelibrary.util.MimeTypeUtil;
import org.gcube.common.homelibrary.util.WorkspaceUtil;
import org.gcube.portlets.widgets.workspaceuploader.client.ConstantsWorkspaceUploader;
import org.gcube.portlets.widgets.workspaceuploader.server.notification.NotificationsWorkspaceUploader;
import org.gcube.portlets.widgets.workspaceuploader.server.upload.AbstractUploadProgressListener;
import org.gcube.portlets.widgets.workspaceuploader.server.upload.MemoryUploadListener;
import org.gcube.portlets.widgets.workspaceuploader.server.upload.UploadCanceledException;
import org.gcube.portlets.widgets.workspaceuploader.server.upload.UploadProgressInputStream;
import org.gcube.portlets.widgets.workspaceuploader.server.upload.UploadProgressListener;
import org.gcube.portlets.widgets.workspaceuploader.server.upload.WorkspaceUploaderMng;
import org.gcube.portlets.widgets.workspaceuploader.server.util.WsUtil;
import org.gcube.portlets.widgets.workspaceuploader.shared.HandlerResultMessage;
import org.gcube.portlets.widgets.workspaceuploader.shared.WorkspaceUploadFile;
import org.gcube.portlets.widgets.workspaceuploader.shared.WorkspaceUploaderItem;
import org.gcube.portlets.widgets.workspaceuploader.shared.WorkspaceUploaderItem.UPLOAD_STATUS;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The Class WorkspaceUploadServletStream.
 *
 * @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it
 * @Jan 21, 2014
 */
public class WorkspaceUploadServletStream extends HttpServlet implements Servlet{

	public static final String UNKNOWN_UNKNOWN = "unknown/unknown";

	private static final long serialVersionUID = 1778008252774571216L;

	protected static final String UTF_8 = "UTF-8";

	public static final String UPLOAD_TYPE = ConstantsWorkspaceUploader.UPLOAD_TYPE;

	public static final String ID_FOLDER = ConstantsWorkspaceUploader.ID_FOLDER;

	public static final String UPLOAD_FORM_ELEMENT = ConstantsWorkspaceUploader.UPLOAD_FORM_ELEMENT;

	public static final String CLIENT_UPLOAD_KEYS = ConstantsWorkspaceUploader.CLIENT_UPLOAD_KEYS;
	
	public static final String JSON_CLIENT_KEYS = ConstantsWorkspaceUploader.JSON_CLIENT_KEYS;
	
	public static final String IS_OVERWRITE = ConstantsWorkspaceUploader.IS_OVERWRITE;
	
	public static final String CANCEL_UPLOAD = ConstantsWorkspaceUploader.CANCEL_UPLOAD;
	
	public static final String FILE = "File";

	public static final String D4ST = Extensions.REPORT_TEMPLATE.getName(); //extension of Report Template type
	public static final String D4SR = Extensions.REPORT.getName(); //extension of Report type
	
	public static Logger logger = LoggerFactory.getLogger(WorkspaceUploadServletStream.class);

	private static boolean appEngine = false;

	/*
	 * (non-Javadoc)
	 * 
	 * @see javax.servlet.GenericServlet#init()
	 */
	@Override
	public void init() throws ServletException {
		super.init();

		String appe = getInitParameter("appEngine");
		if (appe != null) {
			appEngine = "true".equalsIgnoreCase(appe);
		} else {
			appEngine = isAppEngine();
		}
		
		logger.debug("init: appEngine is "+appEngine);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		logger.debug("GET method in "+WorkspaceUploadServletStream.class.getName()+" is running");
		String clientUploadKey = request.getParameter(CLIENT_UPLOAD_KEYS);
        if (clientUploadKey == null){
        	sendError(response, "Internal error: UPLOAD KEY NOT FOUND");
        	return;
        }
        logger.debug("GET method CLIENT_UPLOAD_KEY "+clientUploadKey);
        
        boolean cancelUpload = Boolean.parseBoolean(request.getParameter(CANCEL_UPLOAD));
        logger.debug("GET method CANCEL_UPLOAD "+cancelUpload);
        if (cancelUpload) {
          cancelUpload(request.getSession(), clientUploadKey);
          sendMessage(response, "Upload abort: "+request.getParameter(CANCEL_UPLOAD));
        }else
        	logger.debug(CANCEL_UPLOAD + " param not found");
//        }else
//        	 sendError(response, "Internal error: CANCEL_UPLOAD NOT FOUND");
        
        return;
	}
	
	/**
	 * {@inheritDoc}
	 */
	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		System.out.println("POST on UploadServlet");
		logger.info("POST on UploadServlet");
		
		if (!ServletFileUpload.isMultipartContent(request)) {
			logger.error("ERROR: multipart request not found");
			sendError(response, "ERROR: multipart request not found");
		}

	    HttpSession session = request.getSession();
	    logger.debug("UPLOAD-SERVLET (" + session.getId() + ") new upload request received.");
		String destinationId = null;
		String uploadType = null;
		boolean isOverwrite = false;
//		String clientUploadKey = null;
		FileItemStream uploadItem = null;
		ArrayList<String> listClientUploadKeys = null;
		
		FileItemFactory factory = new DiskFileItemFactory();
		ServletFileUpload servletFileUpload = new ServletFileUpload(factory);

		try {
		
			/**
			 * An iterator to instances of <code>FileItemStream</code>
			 * parsed from the request, in the order that they were
			 *transmitted.
			 */
			FileItemIterator fileItemIterator = servletFileUpload.getItemIterator(request);
			
			int uploadItemsCnt = 0;
			
			//GET FILE STREAM
			while (fileItemIterator.hasNext()) {
				FileItemStream item = fileItemIterator.next();
				
				if (item.isFormField() && ID_FOLDER.equals(item.getFieldName())){
					destinationId = Streams.asString(item.openStream());
					logger.debug("ID_FOLDER OK "+destinationId);
				}
				
				if (item.isFormField() && UPLOAD_TYPE.equals(item.getFieldName())){
					uploadType = Streams.asString(item.openStream());
					logger.debug("UPLOAD_TYPE OK " +uploadType);
				}
				
				if (item.isFormField() && IS_OVERWRITE.equals(item.getFieldName())){
					isOverwrite = Boolean.parseBoolean(Streams.asString(item.openStream()));    
					logger.debug("IS_OVERWRITE OK "+ isOverwrite);
				}
				
				if(item.isFormField() && CLIENT_UPLOAD_KEYS.equals(item.getFieldName())){
					String jsonClientUploadKey = Streams.asString(item.openStream());
					logger.debug("CLIENT_UPLOAD_KEY OK "+jsonClientUploadKey);
					LinkedHashMap<String, String> mapKeys = parseJSONClientUploadKeys(jsonClientUploadKey);
					listClientUploadKeys = new ArrayList<String>(mapKeys.keySet());
					removeListenersIfDone(session, listClientUploadKeys);
					for (String clientUploadKey : listClientUploadKeys) {
						String fileName = mapKeys.get(clientUploadKey);
						WorkspaceUploaderItem workspaceUploader = createNewWorkspaceUploader(clientUploadKey,destinationId,mapKeys.get(clientUploadKey));
						logger.debug("created "+workspaceUploader);
						saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.WAIT, "Uploading "+fileName+" at 0%", request.getSession());
					}
				}
				
				//MUST BE THE LAST PARAMETER TRASMITTED
				if (UPLOAD_FORM_ELEMENT.equals(item.getFieldName())){
					uploadItem = item;
					logger.debug("UPLOAD_FORM_ELEMENT OK "+uploadItem.getName());
//					break;
					uploadData(request, response, uploadItem, destinationId, uploadType, listClientUploadKeys.get(uploadItemsCnt), isOverwrite);
					uploadItemsCnt++;
				}
			}
			
		} catch (FileUploadException e) {
			logger.error("Error processing request in upload servlet", e);
			sendError(response, "Internal error: Error during request processing");
			return;
		}
	}
	
	

	/**
	 * Removes the listener if done.
	 *
	 * @param session the session
	 * @param keys the keys
	 */
	private void removeListenersIfDone(HttpSession session, List<String> keys){
		
		for (String key : keys) {
			
		  AbstractUploadProgressListener listener = getCurrentListener(session, key);
		    if (listener != null) {
		      logger.debug("Listener found");
		      if (listener.isCanceled() || listener.getPercentage() >= 100){
		    	  logger.debug("Listener isCanceled or 100%, removing");
		    	  removeCurrentListener(session, key);
		      }
		    }else
		    	logger.debug("Session id: "+session.getId() +" - "+key+" - Listener not found");
		}
	  
	}
	
	/**
	 * Parses the json client upload keys.
	 *
	 * @param jsonClientUploadKeys the json client upload keys
	 * @return the linked hash map
	 * @throws FileUploadException the file upload exception
	 */
	@SuppressWarnings("rawtypes")
	private static LinkedHashMap<String, String> parseJSONClientUploadKeys(final String jsonClientUploadKeys) throws FileUploadException{
		JSONTokener tokener = new JSONTokener(jsonClientUploadKeys);
		JSONObject root;
		LinkedHashMap<String, String> keyFiles = null;
		try {
			
			root = new JSONObject(tokener);
			JSONArray jsonArray = root.getJSONArray(JSON_CLIENT_KEYS);
			keyFiles = new LinkedHashMap<String, String>(jsonArray.length());
			logger.debug("jsonArray :"+jsonArray.toString());
			for (int i=0; i<jsonArray.length(); i++) {
				JSONObject object = jsonArray.getJSONObject(i);
				logger.debug("object :"+object);
				String key = (String) object.keys().next();
				String value = object.getString(key);
				logger.debug("key :"+key+", value: "+value);
				keyFiles.put(key, value);
			}
			/*
			JSONObject object = jsonArray.getJSONObject(0);
			Iterator it = object.keys();
			while(it.hasNext()){
				String key = (String) it.next();
				String value = object.getString(key);
				logger.debug("key :"+key+", value: "+value);
				keyFiles.put((String) key, value);
			}
		*/
		} catch (JSONException e) {
			logger.error("An error occurred during parsing file names: "+keyFiles, e);
			throw new FileUploadException("An error occurred during parsing file names");
		}
		
		logger.debug("keyFiles: "+keyFiles);
		return keyFiles;
	}

	/**
	 * Upload data.
	 *
	 * @param request the request
	 * @param response the response
	 * @param uploadItem the upload item
	 * @param destinationId the destination id
	 * @param uploadType the upload type
	 * @param clientUploadKey the client upload key
	 * @param isOverwrite the is overwrite
	 * @throws ServletException the servlet exception
	 * @throws IOException Signals that an I/O exception has occurred.
	 */
	private void uploadData(HttpServletRequest request, final HttpServletResponse response, final FileItemStream uploadItem, String destinationId,String uploadType,String clientUploadKey, boolean isOverwrite) throws ServletException, IOException{

		String fileName = uploadItem.getName();
		logger.info("Upload servlet parameters: [fileName: "+fileName+ ", destinationId: "+destinationId +", uploadType: "+uploadType+", isOverwrite: "+isOverwrite+", clientUploadKey: "+clientUploadKey+"]");
	
		if (uploadType == null || uploadType.isEmpty()) {
			logger.error("Error processing request in upload servlet for: "+fileName+". No upload type found");
			sendError(response, "Internal error: No upload type found");
			return;
		}
	
		if(clientUploadKey==null || clientUploadKey.isEmpty()){
			logger.error("Error processing request in upload servlet for: "+fileName+". No client upload key found");
			sendError(response, "Internal error: No client upload key found");
			return;
		}
		
		//CLIENT UPLOAD IS THE KEY
//		WorkspaceUploaderItem workspaceUploader = createNewWorkspaceUploader(clientUploadKey,destinationId,fileName);
//		saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.WAIT, "Uploading "+fileName+" at 0%", request.getSession());


		//RETRIVE WORKSPACE UPLOADER FROM SESSION
		
		WorkspaceUploaderItem workspaceUploader = null;
		try {
			workspaceUploader = WsUtil.getWorkspaceUploaderInSession(request.getSession(), clientUploadKey);
		} catch (Exception e) {
			logger.error("Error during workspace uploader retrieving", e);
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading "+fileName+". Error processing request in upload servlet", request.getSession());
			response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Error processing request in upload servlet");
			return;
		}
		
		//TODO DEBUG REMOVE THIS
//		saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading "+fileName+". Error processing request in upload servlet", request.getSession());
//		response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Error processing request in upload servlet");
//		return;
		
		Workspace wa = null;
		try {
			logger.debug("getWorkspace from HL");
			wa = WsUtil.getWorkspace(request.getSession());
		} catch (Exception e) {
			logger.error("Error during workspace retrieving", e);
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading "+fileName+". Error processing request in upload servlet", request.getSession());
			response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Error processing request in upload servlet");
			return;
		}

		if (wa == null) {
			logger.error("Now workspace found in session");
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading "+fileName+". No workspace in session", request.getSession());
			sendError(response, "Internal error: No workspace in session");
			return;
		}

		WorkspaceItem item;
		try {
			logger.debug("getWorkspace Item from HL");
			item = wa.getItem(destinationId);
		} catch (ItemNotFoundException e) {
			logger.error("Error, no destination folder found", e);
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading "+fileName+". No destination folder found", request.getSession());
			sendError(response, "Internal error: No destination folder found");
			return;
		}

		if (item.getType() != WorkspaceItemType.FOLDER && item.getType() != WorkspaceItemType.SHARED_FOLDER)  {
			logger.error("Error processing request in upload servlet: Wrong destination item");
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading "+fileName+". Wrong destination item", request.getSession());
			sendError(response, "Internal error: Wrong destination item");
			return;
		}
		
		final WorkspaceFolder destinationFolder = (WorkspaceFolder) item;
		try {
			//we calculate an unique name for the current destination
			String itemName = "";
			
			logger.debug("getItemName from HL");
			if(!isOverwrite)
				itemName = WorkspaceUtil.getUniqueName(fileName, destinationFolder);
			else
				itemName = fileName;
			
			Long size = getContentLength(request);
			logger.debug("size: " + size + " bytes");
			
			String contentType = null; //It's set into HL
			
			/*
			String contentType = uploadItem.getContentType();
			logger.debug("Content type (mime type): "+contentType + " unique name: "+itemName);
			
			if(contentType==null || contentType.compareTo(UNKNOWN_UNKNOWN)==0){
				logger.warn("Content Type not detected forcing to null");
				contentType = null;
			}
			*/
			String extension = FilenameUtils.getExtension(itemName);
			logger.debug("extension: "+extension);
			
			//CONFIRM DESTINATION FOLDER 
			workspaceUploader.getFile().setParentId(destinationFolder.getId());
			
			//Create Item Uploader to read progress
//			WorkspaceUploadFile wsUploadFile = new WorkspaceUploadFile(destinationFolder.getId(), itemName);
//			workspaceUploader.setFile(wsUploadFile);
//			workspaceUploader.setStatusDescription("Uploading "+itemName+" at 0%");
			
			//instanciate the progress listener
			final AbstractUploadProgressListener uploadProgressListener = createNewListener(request.getSession(), clientUploadKey);
			final UploadProgressInputStream inputStream = new UploadProgressInputStream(uploadItem.openStream(), size);
			inputStream.addListener(uploadProgressListener);
			workspaceUploader.setUploadProgress(uploadProgressListener.getUploadProgress());
			
			saveWorkspaceUploaderInSession(workspaceUploader, request.getSession());
			
			if(uploadType.compareTo(FILE)==0) {//IS FILE UPLOAD
				
				boolean isZipFile = MimeTypeUtil.isZipContentType(contentType);
				
				if(isZipFile && (extension.compareToIgnoreCase(D4ST)==0)){  //Create REPORT TEMPLATE

					String newItemName = itemName;
					logger.debug("createTemplate: "+newItemName);
					
					createTemplate(workspaceUploader, request.getSession(), wa, newItemName, inputStream, destinationFolder, response, isOverwrite);
				
				}else if(isZipFile && (extension.compareToIgnoreCase(D4SR)==0)){ //Create REPORT

					String newItemName = itemName;
					logger.debug("createReport: "+newItemName);
					createReport(workspaceUploader, request.getSession(), wa, newItemName, inputStream, destinationFolder, response, isOverwrite);
				}else{ //CREATE AN EXTERNAL FILE
					
					workspaceUploader = WorkspaceUploaderMng.uploadFile(workspaceUploader, request.getSession(), wa, itemName, inputStream, destinationFolder, contentType, isOverwrite, size);
					
					if(workspaceUploader==null)
						throw new Exception("Error when creating uploader, it is null!");
					
					sendMessage(response, workspaceUploader.getIdentifier());
				}
			
			}else {//IS ARCHIVE UPLOAD
				
				if (MimeTypeUtil.isZipContentType(contentType)){
					logger.debug("Unziping content");
					workspaceUploader = WorkspaceUploaderMng.uploadArchive(workspaceUploader, request.getSession(), itemName, inputStream, destinationFolder, size);
					
					if(workspaceUploader==null)
						throw new Exception("Error when creating uploader, it is null!");
					
					sendMessage(response, workspaceUploader.getIdentifier());
				} else{
					workspaceUploader = WorkspaceUploaderMng.uploadFile(workspaceUploader, request.getSession(), wa, itemName, inputStream, destinationFolder, contentType, isOverwrite, size);
					
					if(workspaceUploader==null)
						throw new Exception("Error when creating uploader, it is null!");
					
					sendMessage(response, workspaceUploader.getIdentifier());
				}
			}

//			file.delete();
		} catch (InsufficientPrivilegesException e) {
			logger.error("Error creating elements", e);
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading. Insufficient privileges", request.getSession());
			sendError(response, "Internal error: Insufficient privileges");
			return;
		} catch (InternalErrorException e) {
			logger.error("Error creating elements", e);
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading:"+e.getMessage(), request.getSession());
			sendError(response, "Internal error: "+e.getMessage());
			return;
		} catch (ItemAlreadyExistException e) {
			logger.error("Error creating elements", e);
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading. An item with that name already exists", request.getSession());
			sendError(response, "Internal error: An item with that name already exists");
			return;
		}catch (Exception e) {
			logger.error("Error creating elements", e);
			saveWorkspaceUploaderStatus(workspaceUploader, UPLOAD_STATUS.FAILED, "An error occurred when uploading. "+e.getMessage(), request.getSession());
//			sendError(response, "Internal error: An error occurred on uploading the file, try again later");
			return;
		}finally{
			removeCurrentListener(request.getSession(), clientUploadKey);
		}
	}
	

	/**
	 * Save workspace uploader status.
	 *
	 * @param workspaceUploader the workspace uploader
	 * @param status the status
	 * @param description the description
	 * @param session the session
	 * @return the workspace uploader item
	 */
	private synchronized WorkspaceUploaderItem saveWorkspaceUploaderStatus(WorkspaceUploaderItem workspaceUploader, UPLOAD_STATUS status, String description, HttpSession session){
		workspaceUploader.setUploadStatus(status);
		workspaceUploader.setStatusDescription(description);
		try {
			saveWorkspaceUploaderInSession(workspaceUploader, session);
		} catch (Exception e) {
			logger.error(e.getMessage());
		}
		return workspaceUploader;
	}


	/**
	 * Creates the new workspace uploader.
	 *
	 * @param clientUploadKey the client upload key
	 * @param folderParentId the folder parent id
	 * @param fileName the file name
	 * @return the workspace uploader item
	 */
	private WorkspaceUploaderItem createNewWorkspaceUploader(String clientUploadKey, String folderParentId, String fileName){
		//CLIENT UPLOAD IS THE KEY
		WorkspaceUploaderItem workspaceUploader = new WorkspaceUploaderItem(clientUploadKey);
		workspaceUploader.setClientUploadKey(clientUploadKey);
		//Create File
		WorkspaceUploadFile wsUploadFile = new WorkspaceUploadFile(folderParentId, fileName);
		workspaceUploader.setFile(wsUploadFile);
		return workspaceUploader;
	}

	 /**
	 * Gets the random.
	 *
	 * @return the random
	 */
	private static int getRandom(){
		 Random randomGenerator = new Random();
		 return randomGenerator.nextInt(Integer.MAX_VALUE);
   }
	
	/**
	 * Save workspace uploader in session.
	 *
	 * @param workspaceUploader the workspace uploader
	 * @param httpSession the http session
	 * @return the workspace uploader item
	 * @throws Exception the exception
	 */
	public static void saveWorkspaceUploaderInSession(WorkspaceUploaderItem workspaceUploader, HttpSession httpSession) throws Exception {

		if(workspaceUploader!=null){
			try {
				WsUtil.putWorkspaceUploaderInSession(httpSession, workspaceUploader);
			} catch (Exception e) {
				logger.error("Error during WorkspaceUploaderItem save in session workspace uploader: "+workspaceUploader,e);
				throw new Exception("An error occurred during uploading. Try again");
			}
		}else
			throw new Exception("An error occurred during uploading. Workspace Uploader not found. Abort and try again");
	}
	
	//TEST TIME
	/**
	 * Prints the start time.
	 *
	 * @return the long
	 */
	public static Long printStartTime(){
		Long startTime =  System.currentTimeMillis();
		logger.debug("Start time: "+startTime);
		return startTime;
	}
	//TEST TIME
	/**
	 * Prints the elapsed time.
	 *
	 * @param startTime the start time
	 */
	public static void printElapsedTime(long startTime){
		Long endTime = System.currentTimeMillis() - startTime;
		String time = String.format("%d msc %d sec", endTime, TimeUnit.MILLISECONDS.toSeconds(endTime));
		logger.debug("Elapsed Time: "+time);
	}
	
	/**
	 * Notify upload in shared folder.
	 *
	 * @param httpSession the http session
	 * @param workspace the workspace
	 * @param itemId the item id
	 * @param destinationFolderId the destination folder id
	 * @param isOverwrite the is overwrite
	 */
	public static void notifyUploadInSharedFolder(final HttpSession httpSession, final Workspace workspace, final String itemId, final String destinationFolderId, final boolean isOverwrite){
		
		new Thread(){
			public void run() {
				WorkspaceItem sourceItem;
				try {
					sourceItem = workspace.getItem(itemId);
					String sourceSharedId = sourceItem.getIdSharedFolder();
					WorkspaceItem folderDestinationItem = workspace.getItem(destinationFolderId);
					NotificationsWorkspaceUploader.checkSendNotifyChangedItemToShare(httpSession, sourceItem, sourceSharedId, folderDestinationItem,isOverwrite);
				} catch (Exception e) {
					logger.error("Error in notifyUploadInSharedFolder", e);
				}	
			};
			
		}.start();	
	}
	
	/**
	 * Overwrite item.
	 *
	 * @param wa the wa
	 * @param itemName the item name
	 * @param fileData the file data
	 * @param destinationFolder the destination folder
	 * @return the folder item
	 */
	private FolderItem overwriteItem(Workspace wa, String itemName, InputStream fileData, WorkspaceFolder destinationFolder){
		
		FolderItem overwriteItem = null;
	
		try {
			logger.debug("case overwriting item.. "+itemName);
			overwriteItem = (FolderItem) wa.find(itemName, destinationFolder.getId());
			logger.debug("overwriteItem item was found, id is: "+overwriteItem.getId());
			wa.updateItem(overwriteItem.getId(), fileData);
			logger.debug("updateItem with id: "+overwriteItem.getId()+ ", is completed");
		} catch (ItemNotFoundException e) {
			logger.error("Error in createExternalFile, ItemNotFoundException", e);
		} catch (WrongItemTypeException e) {
			logger.error("Error in createExternalFile, WrongItemTypeException", e);
		} catch (WorkspaceFolderNotFoundException e) {
			logger.error("Error in createExternalFile, WorkspaceFolderNotFoundException", e);
		} catch (WrongDestinationException e) {
			logger.error("Error in createExternalFile, WrongDestinationException", e);
		} catch (InsufficientPrivilegesException e) {
			logger.error("Error in createExternalFile, InsufficientPrivilegesException", e);
		} catch (ItemAlreadyExistException e) {
			logger.error("Error in createExternalFile, ItemAlreadyExistException", e);
		} catch (InternalErrorException e) {
			logger.error("Error in createExternalFile, InternalErrorException", e);
		}catch (Exception e) {
			logger.error("Error in createExternalFile, Exception", e);
		}
		
		return overwriteItem;	
	}

	
	/**
	 * Creates the report.
	 *
	 * @param workspaceUploader the workspace uploader
	 * @param httpSession the http session
	 * @param wa the wa
	 * @param itemName the item name
	 * @param fileInputStream the file input stream
	 * @param destinationFolder the destination folder
	 * @param response the response
	 * @param isOverwrite the is overwrite
	 * @throws InsufficientPrivilegesException the insufficient privileges exception
	 * @throws ItemAlreadyExistException the item already exist exception
	 * @throws InternalErrorException the internal error exception
	 * @throws IOException Signals that an I/O exception has occurred.
	 */
	private void createReport(WorkspaceUploaderItem workspaceUploader, HttpSession httpSession, Workspace wa, String itemName, InputStream fileInputStream, WorkspaceFolder destinationFolder, HttpServletResponse response, boolean isOverwrite) throws InsufficientPrivilegesException, ItemAlreadyExistException, InternalErrorException, IOException{
		
		try {
			
			Report report = null;
			
			if(!isOverwrite){
				itemName = WorkspaceUtil.getUniqueName(itemName, destinationFolder);
				report = wa.createReport(itemName, "", Calendar.getInstance(), Calendar.getInstance(), "", "", "", 0, "",fileInputStream, destinationFolder.getId());
				
				notifyUploadInSharedFolder(httpSession,wa,report.getId(),destinationFolder.getId(), isOverwrite);
				sendMessage(response, "File "+report.getName()+" imported correctly in "+destinationFolder.getPath());
			}
			else{ 	//CASE OVERWRITE
				FolderItem rep = overwriteItem(wa, itemName, fileInputStream, destinationFolder);
				
				if(rep!=null){
					
					notifyUploadInSharedFolder(httpSession,wa,rep.getId(),destinationFolder.getId(), isOverwrite);
					sendMessage(response, "File "+rep.getName()+" imported correctly in "+destinationFolder.getPath());
				}
				else
					sendError(response,"Internal error: Workspace Item Not Found");
			}
		} catch (WrongDestinationException e) {
			logger.error("Error creating elements", e);
			workspaceUploader.setUploadStatus(UPLOAD_STATUS.FAILED);
			workspaceUploader.setStatusDescription("An error occurred when uploading. Wrong Destination");
			sendError(response, "Internal error: Wrong Destination");
		} catch (WorkspaceFolderNotFoundException e) {
			logger.error("Error creating elements", e);
			workspaceUploader.setUploadStatus(UPLOAD_STATUS.FAILED);
			workspaceUploader.setStatusDescription("An error occurred when uploading. Workspace Folder Not Found");
			sendError(response, "Internal error: Workspace Folder Not Found");
		}finally{
			try {
//				StreamUtils.deleteTempFile(file);
				WsUtil.eraseWorkspaceUploaderInSession(httpSession, workspaceUploader.getIdentifier());
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
		
	}

	/**
	 * Creates the template.
	 *
	 * @param workspaceUploader the workspace uploader
	 * @param httpSession the http session
	 * @param wa the wa
	 * @param itemName the item name
	 * @param fileInputStream the file input stream
	 * @param destinationFolder the destination folder
	 * @param response the response
	 * @param isOverwrite the is overwrite
	 * @throws InsufficientPrivilegesException the insufficient privileges exception
	 * @throws ItemAlreadyExistException the item already exist exception
	 * @throws InternalErrorException the internal error exception
	 * @throws IOException Signals that an I/O exception has occurred.
	 */
	private void createTemplate(WorkspaceUploaderItem workspaceUploader, HttpSession httpSession, Workspace wa, String itemName, InputStream fileInputStream, WorkspaceFolder destinationFolder, HttpServletResponse response, boolean isOverwrite) throws InsufficientPrivilegesException, ItemAlreadyExistException, InternalErrorException, IOException{
		
		try {
			
			ReportTemplate template = null;
			
			if(!isOverwrite){
				itemName = WorkspaceUtil.getUniqueName(itemName, destinationFolder);
				template = wa.createReportTemplate(itemName, "", Calendar.getInstance(), Calendar.getInstance(), "", "", 0, "", fileInputStream, destinationFolder.getId());
				
				notifyUploadInSharedFolder(httpSession,wa,template.getId(),destinationFolder.getId(), isOverwrite);
				sendMessage(response, "File "+template.getName()+" imported correctly in "+destinationFolder.getPath());
				
			}else{ 	//CASE OVERWRITE
				FolderItem rep = overwriteItem(wa, itemName, fileInputStream, destinationFolder);
				
				if(rep!=null){
					
					notifyUploadInSharedFolder(httpSession,wa,rep.getId(),destinationFolder.getId(), isOverwrite);
					sendMessage(response, "File "+rep.getName()+" imported correctly in "+destinationFolder.getPath());
				}
				else
					sendError(response,"Internal error: Workspace Item Not Found");
			}

		} catch (WrongDestinationException e) {
			logger.error("Error creating elements", e);
			workspaceUploader.setUploadStatus(UPLOAD_STATUS.FAILED);
			workspaceUploader.setStatusDescription("An error occurred when uploading. Wrong Destination");
			sendError(response, "Internal error: Wrong Destination");
		} catch (WorkspaceFolderNotFoundException e) {
			logger.error("Error creating elements", e);
			workspaceUploader.setUploadStatus(UPLOAD_STATUS.FAILED);
			workspaceUploader.setStatusDescription("An error occurred when uploading. Workspace Folder Not Found");
			sendError(response, "Internal error: Workspace Folder Not Found");
		}finally{
			try {
//				StreamUtils.deleteTempFile(fileInputStream);
				WsUtil.eraseWorkspaceUploaderInSession(httpSession, workspaceUploader.getIdentifier());
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
		
	}
	
	
	/**
	 * Send error.
	 *
	 * @param response the response
	 * @param message the message
	 * @throws IOException Signals that an I/O exception has occurred.
	 */
	protected void sendError(HttpServletResponse response, String message) throws IOException{
		try {
			response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
			HandlerResultMessage resultMessage = HandlerResultMessage.errorResult(message);
			response.getWriter().write(resultMessage.toString());
			//5.6 Closure of Response Object:
			//When a response is closed, the container must immediately flush all remaining content in the response buffer to the client
//			response.flushBuffer();
		} catch (IOException e){
			logger.warn("IOException class name: "+e.getClass().getSimpleName());
			if (e.getClass().getSimpleName().equals("ClientAbortException"))
				logger.warn("Skipping ClientAbortException: "+e.getMessage());
			else
				throw e; //Sending Exceptions
		}
	}
	
	/**
	 * Send message.
	 *
	 * @param response the response
	 * @param message the message
	 * @throws IOException Signals that an I/O exception has occurred.
	 */
	protected void sendMessage(HttpServletResponse response, String message) throws IOException{
		try {
			response.setStatus(HttpServletResponse.SC_ACCEPTED);
			HandlerResultMessage resultMessage = HandlerResultMessage.okResult(message);
			response.getWriter().write(resultMessage.toString());
			//5.6 Closure of Response Object:
			//When a response is closed, the container must immediately flush all remaining content in the response buffer to the client
//			response.flushBuffer();
		} catch (IOException e){
			logger.warn("IOException class name: "+e.getClass().getSimpleName());
			if (e.getClass().getSimpleName().equals("ClientAbortException"))
				logger.warn("Skipping ClientAbortException: "+e.getMessage());
			else
				throw e; //Sending Exceptions
		}
	}
	
	/**
	 * Send warn message.
	 *
	 * @param response the response
	 * @param message the message
	 * @throws IOException Signals that an I/O exception has occurred.
	 */
	protected void sendWarnMessage(HttpServletResponse response, String message) throws IOException{
		try {
			response.setStatus(HttpServletResponse.SC_ACCEPTED);
			HandlerResultMessage resultMessage = HandlerResultMessage.warnResult(message);
			response.getWriter().write(resultMessage.toString());
			//5.6 Closure of Response Object:
			//When a response is closed, the container must immediately flush all remaining content in the response buffer to the client
//			response.flushBuffer();
		} catch (IOException e){
			logger.warn("IOException class name: "+e.getClass().getSimpleName());
			if (e.getClass().getSimpleName().equals("ClientAbortException"))
				logger.warn("Skipping ClientAbortException: "+e.getMessage());
			else
				throw e; //Sending Exceptions
		}
	}
	
	/**
	 * Mark the current upload process to be canceled.
	 *
	 * @param session the session
	 * @param clientUploadKey the client upload key
	 */
	public void cancelUpload(HttpSession session, String clientUploadKey) {
		logger.debug("UPLOAD-SERVLET (" + session.getId()+ ") cancelling Upload: "+clientUploadKey);
		AbstractUploadProgressListener listener = getCurrentListener(session, clientUploadKey);
		if (listener != null && !listener.isCanceled()) {
			logger.info("CancelUpload listener is "+listener.toString());
			listener.setException(new UploadCanceledException());
		}else
			logger.info("Skipping cancel upload: listener is null or is cancel");
	}
	
	/**
	 * Get the listener active in this session.
	 *
	 * @param session the session
	 * @param clientUploadKey the client upload key
	 * @return the listener active
	 */
	protected AbstractUploadProgressListener getCurrentListener(HttpSession session, String clientUploadKey) {
		if (isAppEngine()) {
			return MemoryUploadListener.current(session.getId(), clientUploadKey);
		} else {
			return UploadProgressListener.current(session, clientUploadKey);
		}
	}

	/**
	 * Just a method to detect whether the web container is running with
	 * appengine restrictions.
	 *
	 * @return true if the case of the application is running in appengine
	 */
	public boolean isAppEngine() {
		return appEngine;
	}
	
	/**
	 * Create a new listener for this session.
	 *
	 * @param session the session
	 * @param clientUploadKey the client upload key
	 * @return the appropriate listener
	 */
	protected AbstractUploadProgressListener createNewListener(HttpSession session, String clientUploadKey) {
		if (isAppEngine()) {
			return new MemoryUploadListener(session, clientUploadKey, 0, 100);
		} else {
			return new UploadProgressListener(session, clientUploadKey, 0, 100);
		}
	}

	
	/**
	 * Gets the content length.
	 *
	 * @param request the request
	 * @return the content length
	 */
	private long getContentLength(HttpServletRequest request) {
		long size = -1;
		try {
			size = Long.parseLong(request
					.getHeader(FileUploadBase.CONTENT_LENGTH));
		} catch (NumberFormatException e) {
		}
		return size;
	}
	
	/**
	 * Remove the listener active in this session.
	 *
	 * @param session the session
	 * @param clientUploadKey the client upload key
	 */
	protected void removeCurrentListener(HttpSession session, String clientUploadKey) {
		logger.debug("RemoveCurrentListener: "+clientUploadKey);
		AbstractUploadProgressListener listener = getCurrentListener(session, clientUploadKey);
	
		if (listener != null) {
			logger.debug("Removing listener: "+listener.getClientUploadKey());
			listener.remove();
		}else
			logger.warn("Listener "+clientUploadKey+ "is null");
	}
	
	/**
	 * The main method.
	 *
	 * @param args the arguments
	 */
	/*
	public static void main(String[] args) {
		try {
			parseJSONClientUploadKeys("{\"ClientKeys\":[{\"3D6CAAEFF9241F6\":\"bookmarks.xml\"}, {\"69E9907A78AD20B\":\"WFS\"}]}");
		} catch (FileUploadException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}*/
	

}