/**_____________________________________________________________________________
 *
 *                                 OATS - INAF
 *  Osservatorio Astronomico di Tireste - Istituto Nazionale di Astrofisica
 *  Astronomical Observatory of Trieste - National Institute for Astrophysics
 * ____________________________________________________________________________
 *
 * Copyright (C) 20016  Istituto Nazionale di Astrofisica
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc., 
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 * _____________________________________________________________________________
 **/
package it.inaf.oats.vospacebackend;

import it.inaf.oats.vospacebackend.implementation.VOSpaceBackend;
import it.inaf.oats.vospacebackend.implementation.VOSpaceBackImplFactory;
import it.inaf.oats.vospacebackend.exceptions.ExceptionMessage;
import it.inaf.oats.vospacebackend.exceptions.VOSpaceBackendException;
import it.inaf.oats.vospacebackend.utils.ConfigReader;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.Iterator;

import org.apache.log4j.Logger;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.IOUtils; 

import org.restlet.resource.Get;
import org.restlet.resource.Post;
import org.restlet.resource.Put;
import org.restlet.resource.Delete;
import org.restlet.Request;
import org.restlet.resource.ServerResource;
import org.restlet.representation.Variant;
import org.restlet.representation.Representation;
import org.restlet.representation.StringRepresentation;
import org.restlet.representation.FileRepresentation;

import org.restlet.ext.fileupload.RestletFileUpload;
       
import org.restlet.data.MediaType;
import org.restlet.data.Status;

/**
 *
 * @author bertocco
 */
public class VOSpaceBackendResource extends ServerResource {
    
    protected Logger log = Logger.getLogger(VOSpaceBackendResource.class);
    
    @Put
    public Representation doPut(Representation entity, Variant variant) throws Exception {
        
        Representation result = null;
        
        log.info("Entering in PUT operation");
 
        String security_token = "";
        String unique_file_id_str = ""; 
        String fileToManage = "";       
        InputStream is;
        if (entity != null) {
            log.info("Received good entity");
            try {
                log.debug("Trying to read attributes");
                Request request = getRequest();
                log.debug("AAA");
                security_token = (String)getRequest().getAttributes().get("security_token");
                unique_file_id_str = (String)getRequest().getAttributes().get("unique_file_id_string");
                fileToManage = (String)getRequest().getAttributes().get("fileToManage");
                log.debug("\nsecurity token = " + security_token +
                          "\nunique_file_id_str = " + unique_file_id_str +
                          "\nfileToManage = " + fileToManage);
            } catch (Exception e) {
                log.debug("Exception reading string parameters");
            }   
                        
            try {
 
                is = entity.getStream();
                log.debug("Input stream get");
                result = readAndSaveFile(fileToManage, unique_file_id_str, is);
                
            } catch (Exception e) {
                result = this.printMessage("File NOT Uploaded! Something went wrong.");    
            }    
            
        }
        
        return result;
    }
    
        
    @Post
    public Representation doPost(Representation entity) throws Exception {
        
        Representation result = null;
        log.info("Entering in POST operation");
    
        if (entity != null) {
        
            if (MediaType.MULTIPART_FORM_DATA.equals(entity.getMediaType(), true)) {
                log.info("Correctly Using MULTIPART_FORM_DATA");
            
                try {
                    result = this.uploadFile(entity);
                } catch (Exception e) {                
                    result = this.printMessage(e.getMessage());               
                }
            
            
            }  else {
                // POST request with unexpected type.
                setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
                result = this.printMessage("POST request with unexpected type.");
            }    
            
            
        } else {
            // POST request with no entity.
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            result = this.printMessage("POST request with no entity.");
        }
        
        return result;
    
    }

    @Get
    public Representation doGet(){
        
        Representation result = null;
        log.info("Entering in GET operation");
        String fileName = (String)getRequestAttributes().get("fileToManage");
        log.debug("File to download is: " + fileName);
        try {       
            result = this.downloadFile(fileName);
        } catch (Exception e) {  
            //setStatus(Status.CLIENT_ERROR_NOT_FOUND);
            result = this.printMessage("GET request: failed to download file.");  
        }  
        
        return result;
    }
    
    
    @Delete
    public Representation doDelete(){
        
        Representation result;
        
        log.info("Entering in DELETE operation");
        String fileName = (String)getRequestAttributes().get("fileToManage");
        log.debug("File to delete is: " + fileName);
        try {       
            result = this.deleteFile(fileName);
        } catch (Exception e) {         
            result = this.printMessage("DELETE request: failed to delete file " + fileName);  
        }   
         
        return result;  
    }
    
    private Representation uploadFile(Representation entity) throws Exception {
                
        Representation result = null;
         
        
        // 1/ Create a factory for disk-based file items
        DiskFileItemFactory factory = new DiskFileItemFactory();
        factory.setSizeThreshold(1000240);
        log.info("Factory created");
        // 2/ Create a new file upload handler based on the Restlet
        // FileUpload extension that will parse Restlet requests and
        // generates FileItems.
        RestletFileUpload upload = new RestletFileUpload(factory);
        log.info("RestletFileUpload created");
        
        List<FileItem> items;
        
        boolean fileFound = false; 
        String origFileName = null;           
        FileItem fileItemToStore = null;
        Map<String, String> parameters = new HashMap<String, String>();
               
        try {
            // 3/ Request is parsed by the handler which generates a list of FileItems
            items = upload.parseRequest(getRequest());
            
            for (final Iterator<FileItem> it = items.iterator(); it.hasNext(); ) {
                FileItem fi = it.next();
                String fileName = fi.getName();
                if (fileName == null) {
                    parameters.put(fi.getFieldName(), new String(fi.get(), "UTF-8"));
                } else {
                    fileItemToStore = fi;
                    origFileName = fileName;
                    fileFound = true;
                }
            }
        } catch (Exception e) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            result = this.printMessage("Unable to correctly parse request");
            return result;
        }
        
        if (!fileFound) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            result = this.printMessage("Unable to find a file to download");
            return result;
        }
        
        String unique_file_id_str;
        String security_token;
        
        if (parameters.isEmpty()) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            result = this.printMessage("Unable to find parameters in client request");
            return result;
        }
        
        if (origFileName == null) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            result = this.printMessage("Unable to find original file name in client request");
            return result;
        }
        
        if (parameters.get("unique_file_id_string") == null) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            result = this.printMessage("No parameter unique_file_id_string found in request");
            return result;
        }
        unique_file_id_str = parameters.get("unique_file_id_string");
        
    
        if (parameters.get("security_token") == null) {
            setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
            result = this.printMessage("No parameter security_token found in request");
            return result;
        }
        security_token = parameters.get("security_token");
        
        log.debug("unique_file_id_string = " + unique_file_id_str);
        
        log.debug("security_token = " + security_token);
        
        log.debug("fileName = " + origFileName);
        
        
        result = readAndSaveFile(origFileName, unique_file_id_str, fileItemToStore);
        
        return result;
        
    }
    
    private Representation readAndSaveFile(String origFileName, String unique_file_id_str, FileItem fi)
                           throws IOException, VOSpaceBackendException {
                
        Representation result;
        log.debug("Entering in readAndSaveFile");
        
        InputStream is = fi.getInputStream();
        log.debug("Input stream get");
        
        return readAndSaveFile(origFileName, unique_file_id_str, is);
        
    }
    
    
    private Representation readAndSaveFile(String origFileName, String unique_file_id_str, InputStream is)
                           throws IOException, VOSpaceBackendException {
        
        Representation result;
        
        byte[] data = IOUtils.toByteArray(is);
        log.debug("toByteArray OK");
        // Calculate the file MD5 checksum (so will not need to re-read 
        // the file a new time later
        String md5sum = new String(DigestUtils.md5Hex(data));
        log.debug("MD5Sum del file: " + md5sum);
        // Get temporary document root from configuration file
        String tmpStorageRoot = new String();
        try {
            ConfigReader myConf = new ConfigReader("VOSpace.properties");
            tmpStorageRoot = myConf.getProperty("fs.posix.tmp.storage.root"); 
        } catch (Exception e) {
            ExceptionMessage exMsg = new ExceptionMessage();
            log.debug(MessageFormat.format(
                      exMsg.getMessage("UNABLE_TO_READ_PROPERTIES"), "VOSpace.properties"));
                      throw new VOSpaceBackendException(MessageFormat.format(
                             exMsg.getMessage("PROPERTY_NOT_FOUND"), "fs.posix.tmp.storage.root", "VOSpace.properties"));
        }
        // Create the temporary directory, if needed
        File path = new File(tmpStorageRoot);
        if (!path.exists()) {
            boolean status = path.mkdirs();
        }
        // Seve the temporary file in temporary location with the new unique name
        File savedUploadedFile = new File(path + File.separator + unique_file_id_str);
        FileOutputStream outStream = new FileOutputStream(savedUploadedFile);
        outStream.write(data);
        outStream.close();
        try {
            if (this.storeUploadedFile(unique_file_id_str, origFileName, md5sum)) {  
                setStatus(Status.SUCCESS_OK); 
                result = this.printMessage("File successfully uploaded");
            } else {                  
                result = this.printMessage("File NOT Uploaded! Something went wrong.");
            }
        } catch (Exception e) {
            result = this.printMessage("File NOT Uploaded! Something went wrong.");    
        }
            
        return result;            
    }
    
    
    private boolean storeUploadedFile(String tmp_file_name, String orig_f_name, 
                                      String md5_sum) throws Exception {
        boolean stored = false;
        log.debug("Entering in storeUploadedFile");
        VOSpaceBackImplFactory myVOSpaceFactory = new VOSpaceBackImplFactory(); 
        log.debug("myVOSpaceFactory created");
        VOSpaceBackend myVOSpace = myVOSpaceFactory.getVOSpaceBackImpl();
        log.debug("myVOSpace get");
        stored = myVOSpace.createFile(orig_f_name, tmp_file_name, md5_sum);
        log.debug("File stored: " + stored);
        return stored;
                
    }
    
    private Representation downloadFile(String fileName) throws Exception {
        
        Representation result;
        
        log.debug("Entering in downloadFile");
        VOSpaceBackImplFactory myVOSpaceFactory = new VOSpaceBackImplFactory(); 
        log.debug("myVOSpaceFactory created");
        VOSpaceBackend myVOSpace = myVOSpaceFactory.getVOSpaceBackImpl();
        log.debug("myVOSpace get");
        File fileToDownload = myVOSpace.returnFile(fileName);
        if (fileToDownload != null ) {  
            log.debug("File found, fileToDownload is not null");
            FileRepresentation fr = new FileRepresentation(fileToDownload.getAbsolutePath(),
                                                             MediaType.APPLICATION_OCTET_STREAM);
            result = fr; 
            setStatus(Status.SUCCESS_OK); 
 
        } else {  
            log.debug("File NOT found, fileToDownload is null");                     
            result = this.printMessage("Unable to download file. Something went wrong!"); 
            setStatus(Status.SERVER_ERROR_INTERNAL);
        }
        
        return result;
    }
    
    private Representation deleteFile(String fileName) throws Exception {
         
        Representation result = null;
                   
        log.debug("Entering in deleteFile");
        VOSpaceBackImplFactory myVOSpaceFactory = new VOSpaceBackImplFactory(); 
        log.debug("myVOSpaceFactory created");
        VOSpaceBackend myVOSpace = myVOSpaceFactory.getVOSpaceBackImpl();
        log.debug("myVOSpace delete");
        try {       
            if(myVOSpace.deleteFile(fileName)) {
                log.debug("DELETE request: file " + fileName +  " removed.");
                result = this.printMessage("DELETE request: file " + fileName +  " removed.");                 
                setStatus(Status.SUCCESS_OK); 
            } else {
                log.debug("DELETE request: failed to remove file " + fileName);
                result = this.printMessage("DELETE request: failed to remove file " + fileName); 
                setStatus(Status.SERVER_ERROR_INTERNAL);
            }
        } catch (Exception e) { 
            log.debug("DELETE request: failed to remove file " + fileName);
            result = this.printMessage("DELETE request: failed to remove file " + fileName); 
                setStatus(Status.SERVER_ERROR_INTERNAL);  
        }   
        
        return result;
    }
    
    
    private Representation printMessage(String error) {
        
            StringBuilder sb = new StringBuilder("");
            sb.append(error);
            sb.append("\n");
            return new StringRepresentation(sb.toString(), MediaType.TEXT_PLAIN);
    }

}
