/**
 * 
 */
package org.gcube.portlets.user.workspace.server;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;

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

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.FilenameUtils;
import org.gcube.common.core.utils.logging.GCUBELog;
import org.gcube.portlets.user.homelibrary.home.exceptions.InternalErrorException;
import org.gcube.portlets.user.homelibrary.home.workspace.Workspace;
import org.gcube.portlets.user.homelibrary.home.workspace.WorkspaceFolder;
import org.gcube.portlets.user.homelibrary.home.workspace.WorkspaceItem;
import org.gcube.portlets.user.homelibrary.home.workspace.WorkspaceItemType;
import org.gcube.portlets.user.homelibrary.home.workspace.exceptions.InsufficientPrivilegesException;
import org.gcube.portlets.user.homelibrary.home.workspace.exceptions.ItemAlreadyExistException;
import org.gcube.portlets.user.homelibrary.home.workspace.exceptions.ItemNotFoundException;
import org.gcube.portlets.user.homelibrary.home.workspace.exceptions.WorkspaceFolderNotFoundException;
import org.gcube.portlets.user.homelibrary.home.workspace.exceptions.WrongDestinationException;
import org.gcube.portlets.user.homelibrary.home.workspace.folder.FolderItem;
import org.gcube.portlets.user.homelibrary.home.workspace.folder.items.Report;
import org.gcube.portlets.user.homelibrary.home.workspace.folder.items.ReportTemplate;
import org.gcube.portlets.user.homelibrary.util.Extensions;
import org.gcube.portlets.user.homelibrary.util.MimeTypeUtil;
import org.gcube.portlets.user.homelibrary.util.WorkspaceUtil;
import org.gcube.portlets.user.homelibrary.util.zip.UnzipUtil;
import org.gcube.portlets.user.workspace.client.view.windows.UploadResultMessage;
import org.gcube.portlets.user.workspace.server.util.Util;

/**
 * @author Federico De Faveri defaveri@isti.cnr.it
 *
 */
public class UploadServlet extends HttpServlet {

	public static final String UPLOAD_TYPE = "uploadType";

	public static final String ID_FOLDER = "idFolder";

	public static final String UPLOAD_FORM_ELEMENT = "uploadFormElement";

	public static final String FILE = "File";

	protected GCUBELog logger = new GCUBELog(UploadServlet.class);
	
	public static final String D4ST = Extensions.REPORT_TEMPLATE.getValue(); //extension of Report Template type
	public static final String D4SR = Extensions.REPORT.getValue(); //extension of Report type
	/**
	 * 
	 */
	private static final long serialVersionUID = -4197748678713054285L;


	/**
	 * {@inheritDoc}
	 */
	@Override
	public void init() throws ServletException {
		super.init();

		System.out.println("Workspace UploadServlet ready.");
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		System.out.println("GET on UploadServlet");
	}


	/**
	 * {@inheritDoc}
	 */
	@SuppressWarnings("rawtypes")
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		System.out.println("POST on UploadServlet");
		logger.trace("POST on UploadServlet");
		
		FileItemFactory factory = new DiskFileItemFactory();
		ServletFileUpload upload = new ServletFileUpload(factory);

		FileItem uploadItem = null;
		String destinationId = null;
		String uploadType = null;
		
		try {
			logger.trace("parsing request");
			List items = upload.parseRequest(request);

			Iterator it = items.iterator();
			while (it.hasNext()) {
				FileItem item = (FileItem) it.next();

				if (!item.isFormField() && UPLOAD_FORM_ELEMENT.equals(item.getFieldName())) {
					uploadItem = item;
				}

				if (item.isFormField() && ID_FOLDER.equals(item.getFieldName())){
					destinationId = item.getString();
				}
				
				if (item.isFormField() && UPLOAD_TYPE.equals(item.getFieldName())){
					uploadType = item.getString();
				}

			}
		} catch (FileUploadException e) {
			logger.error("Error processing request in upload servlet", e);
			sendError(response, "Internal error: Error during request processing");
			return;
		}


		if (uploadItem == null) {
			logger.error("Error processing request in upload servlet: No file to upload");
			sendError(response, "Internal error: No file to upload");
			return;
		}

		if (destinationId == null) {
			logger.error("Error processing request in upload servlet: No destination folder id found");
			sendError(response, "Internal error: No destination folder id found");
			return;
		}

		logger.trace("destination folder id: "+destinationId);
		logger.trace("uploadType: "+uploadType);

		Workspace wa = null;
		try {
			wa = Util.getWorkspace(request.getSession());
		} catch (Exception e) {
			logger.error("Error during workspace retrieving", e);
			response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Error processing request in upload servlet");
			return;
		}

		if (wa == null) {
			logger.error("Now workspace found in session");
			sendError(response, "Internal error: No workspace in session");
			return;
		}

		WorkspaceItem item;
		try {
			item = wa.getItem(destinationId);
		} catch (ItemNotFoundException e) {
			logger.error("Error, no destination folder found", e);
			sendError(response, "Internal error: No destination folder found");
			return;
		}

		if (item.getType() != WorkspaceItemType.FOLDER)  {
			logger.error("Error processing request in upload servlet: Wrong destination item");
			sendError(response, "Internal error: Wrong destination item");
			return;
		}

		WorkspaceFolder destinationFolder = (WorkspaceFolder) item;

		try {
			//we calculate an unique name for the current destination
			String itemName = WorkspaceUtil.getUniqueName(uploadItem.getName(), destinationFolder);
			
			String contentType = MimeTypeUtil.getMimeType(new BufferedInputStream(uploadItem.getInputStream()));
			logger.trace("Content type: "+contentType + " unique name: "+itemName);
			
//			System.out.println("Content type: "+contentType + " unique name: "+itemName);

			String extension = FilenameUtils.getExtension(itemName);
			logger.trace("extension: "+extension);
			
//			System.out.println("extension: "+extension);
			
			if(uploadType.compareTo(FILE)==0) {//IS FILE UPLOAD
				
				boolean isZipFile = MimeTypeUtil.isZipContentType(contentType);
				
				if(isZipFile && (extension.compareToIgnoreCase(D4ST)==0)){  //Create REPORT TEMPLATE
					
					String itemwithoutext = itemName.substring(0,itemName.lastIndexOf(D4ST)-1); //remove extension
					
//					System.out.println("itemwithoutext " +itemwithoutext);
					
					logger.trace("createTemplate: "+itemwithoutext);
					createTemplate(wa, itemwithoutext, uploadItem.getInputStream(), destinationFolder, response);
				
				}else if(isZipFile && (extension.compareToIgnoreCase(D4SR)==0)){ //Create REPORT
					
					String itemwithoutext = itemName.substring(0,itemName.lastIndexOf(D4SR)-1); //remove extension
					
//					System.out.println("itemwithoutext " +itemwithoutext);
					
					logger.trace("createReport: "+itemwithoutext);
					createReport(wa, itemwithoutext, uploadItem.getInputStream(), destinationFolder, response);
					
				}else{ //CREATE AN EXTERNAL FILE
					
					createExternalFile(itemName, uploadItem, destinationFolder, contentType, response);
				}
			
			}else {//IS ARCHIVE UPLOAD
				
				if (MimeTypeUtil.isZipContentType(contentType)){
					logger.trace("Unziping content");
					UnzipUtil.unzip(destinationFolder, uploadItem.getInputStream(), itemName);
					sendMessage(response, "Archive "+uploadItem.getName()+" imported correctly in "+destinationFolder.getPath());
				} else
					createExternalFile(itemName, uploadItem, destinationFolder, contentType, response);
			}
				
			uploadItem.delete();
		} catch (InsufficientPrivilegesException e) {
			logger.error("Error creating elements", e);
			sendError(response, "Internal error: Insufficient privileges");
			return;
		} catch (InternalErrorException e) {
			logger.error("Error creating elements", e);
			sendError(response, "Internal error: "+e.getMessage());
			return;
		} catch (ItemAlreadyExistException e) {
			logger.error("Error creating elements", e);
			sendError(response, "Internal error: An item with that name already exists");
			return;
		}
	}
	
	private void createExternalFile(String itemName, FileItem uploadItem, WorkspaceFolder destinationFolder, String contentType,  HttpServletResponse response) throws InternalErrorException, InsufficientPrivilegesException, ItemAlreadyExistException, IOException {
		
		//we need to recalculate the item name
		itemName = WorkspaceUtil.getUniqueName(uploadItem.getName(), destinationFolder);
		FolderItem createdItem = WorkspaceUtil.createExternalFile(destinationFolder, itemName, "", contentType, uploadItem.getInputStream());
		sendMessage(response, "File "+createdItem.getName()+" imported correctly in "+destinationFolder.getPath());
	}
	
	
	private void createReport(Workspace wa, String itemName, InputStream stream, WorkspaceFolder destinationFolder, HttpServletResponse response) throws InsufficientPrivilegesException, ItemAlreadyExistException, InternalErrorException, IOException{
		
		try {
			itemName = WorkspaceUtil.getUniqueName(itemName, destinationFolder);
			Report report = wa.createReport(itemName, "", Calendar.getInstance(), Calendar.getInstance(), "", "", "", 0, "", stream, destinationFolder.getId());
			sendMessage(response, "File "+report.getName()+" imported correctly in "+destinationFolder.getPath());
			
		} catch (WrongDestinationException e) {
			logger.error("Error creating elements", e);
			sendError(response, "Internal error: Wrong Destination");
		} catch (WorkspaceFolderNotFoundException e) {
			logger.error("Error creating elements", e);
			sendError(response, "Internal error: Workspace Folder Not Found");
		}
		
	}
	
	private void createTemplate(Workspace wa, String itemName, InputStream stream, WorkspaceFolder destinationFolder, HttpServletResponse response) throws InsufficientPrivilegesException, ItemAlreadyExistException, InternalErrorException, IOException{
		
		try {
			itemName = WorkspaceUtil.getUniqueName(itemName, destinationFolder);
			ReportTemplate template = wa.createReportTemplate(itemName, "", Calendar.getInstance(), Calendar.getInstance(), "", "", 0, "", stream, destinationFolder.getId());
			sendMessage(response, "File "+template.getName()+" imported correctly in "+destinationFolder.getPath());
			
		} catch (WrongDestinationException e) {
			logger.error("Error creating elements", e);
			sendError(response, "Internal error: Wrong Destination");
		} catch (WorkspaceFolderNotFoundException e) {
			logger.error("Error creating elements", e);
			sendError(response, "Internal error: Workspace Folder Not Found");
		}
		
	}
	
	
	protected void sendError(HttpServletResponse response, String message) throws IOException
	{
		response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
		UploadResultMessage resultMessage = UploadResultMessage.errorResult(message);
		response.getWriter().write(resultMessage.toString());
		response.flushBuffer();
	}
	
	protected void sendMessage(HttpServletResponse response, String message) throws IOException
	{
		response.setStatus(HttpServletResponse.SC_ACCEPTED);
		UploadResultMessage resultMessage = UploadResultMessage.okResult(message);
		response.getWriter().write(resultMessage.toString());
		response.flushBuffer();
	}
	
	protected void sendWarnMessage(HttpServletResponse response, String message) throws IOException
	{
		response.setStatus(HttpServletResponse.SC_ACCEPTED);
		UploadResultMessage resultMessage = UploadResultMessage.warnResult(message);
		response.getWriter().write(resultMessage.toString());
		response.flushBuffer();
	}


}