// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.servlets.filetransfer;

import org.apache.commons.fileupload.*;
import org.apache.commons.fileupload.servlet.*;
import org.apache.commons.fileupload.util.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.filesinksource.*;
import org.litesoft.logger.*;
import org.litesoft.server.file.*;
import org.litesoft.util.*;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

public abstract class AbstractFileTransferServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected static Logger LOGGER = LoggerFactory.getLogger( AbstractFileTransferServlet.class );

    /**
     * Return True for all the Content Types that we want the Browser to simply show!
     * <p/>
     * Otherwise, the Browser will be told to "ask" what to do with it!
     */
    protected boolean isDirectViewContent( String pContentType ) {
        return pContentType.startsWith( "image/" ) || pContentType.startsWith( "text/" );
    }

    /**
     * Return False for any Content Types that we are Not aware of what we want the browser to do with it!
     * <p/>
     * Will only be called if  isDirectViewContent( pContentType )  return false
     */
    protected boolean isKnownContentType( String pContentType ) {
        return pContentType.startsWith( "application/" );
    }

    @Override
    public void init()
            throws ServletException {
        FileSinkAndSourceFactory.setInstance( initialize() );
    }

    abstract protected FileSinkAndSourceFactory initialize()
            throws ServletException;

    /**
     * Download uses GET.
     */
    @Override
    public void doGet( HttpServletRequest pReq, final HttpServletResponse pResp )
            throws ServletException, IOException {
        String zPathInfo = pReq.getPathInfo();
        String zOpaqueHandle = ConstrainTo.significantOrNull( cleanFileName( zPathInfo ) );
        if ( zOpaqueHandle == null ) {
            pResp.sendError( HttpServletResponse.SC_NOT_FOUND, "Null or zero length OpaqueHandle" );
            return;
        }
        FileSource zFileSource = FileSinkAndSourceFactory.getInstance().createFileSource( zOpaqueHandle );
        FileSourceInfo zFileInfo = zFileSource.get();
        String zFileName = zFileInfo.getName();
        String zContentType = ConstrainTo.notNull( getServletContext().getMimeType( zFileName.toLowerCase() ) );
        pResp.setContentType( zContentType );
        long zSize = zFileInfo.getSize();
        if ( zSize < Integer.MAX_VALUE ) {
            pResp.setContentLength( (int) zSize );
        }

        if ( !isDirectViewContent( zContentType ) ) {
            pResp.setHeader( "Content-Disposition", "attachment;filename=" + zFileName );  // Only if want OS to ask disposition
            if ( !isKnownContentType( zContentType ) ) {
                LOGGER.info.log( "zName=", zFileName, " zContentType=", zContentType );
            }
        }

        // Caching Control
        pResp.addHeader( "cache-control", "max-age=10" );
        // We'd like to add these, but IE7 has a specific bug when downloading Microsoft Office files.  See:
        //  http://support.microsoft.com/kb/317208/
        //  pResp.addHeader( "cache-control", "no-store" );
        //  pResp.addHeader( "Pragma", "no-cache" );

        Utils.copy( zFileInfo.getInputStream(), new OutputStreamFactory() // closes InputStream
        {
            @Override
            public OutputStream createOutputStream()
                    throws IOException {
                return pResp.getOutputStream();
            }
        } );
    }

    /**
     * Upload uses POST.
     */
    @Override
    public void doPost( HttpServletRequest pReq, HttpServletResponse pResp )
            throws ServletException, IOException {
        PrintWriter zPrintWriter = pResp.getWriter();
        pResp.setContentType( "application/xml" );
        try {
            insureCharacterEncoding( pReq );
            // Check that we have a file upload request
            if ( ServletFileUpload.isMultipartContent( pReq ) ) {
                ServletFileUpload upload = new ServletFileUpload();
                Map<String, String> zResults = new HashMap<String, String>();
                // Parse the request
                FileItemIterator iter = upload.getItemIterator( pReq );
                while ( iter.hasNext() ) {
                    FileItemStream item = iter.next();
                    String name = item.getFieldName();
                    if ( !item.isFormField() ) {
                        String zFileName = item.getName();
                        LOGGER.debug.log( "Upload file name before clean: ", zFileName );
                        zFileName = justFileName( zFileName );
                        FileSink zSink = FileSinkAndSourceFactory.getInstance().createFileSink( zFileName );
                        String zOpaqueHandle = zSink.put( item.openStream() ); // closes InputStream
                        zResults.put( zFileName, zOpaqueHandle );
                    } else {
                        String zStreamAsString = Streams.asString( item.openStream() ); // closes InputStream
                        LOGGER.warn.log( "Form field ", name, " with value ", zStreamAsString, " detected." );
                    }
                }

                List<String> zKeys = new ArrayList<String>( zResults.keySet() );
                Collections.sort( zKeys );

                zPrintWriter.println( "<success>" );
                for ( String zKey : zKeys ) {
                    String zValue = zResults.get( zKey );
                    zPrintWriter.println( "    <file name=\"" + zKey + "\" handle=\"" + zValue + "\" />" );
                }
                zPrintWriter.println( "</success>" );
                zPrintWriter.flush();
            }
        }
        catch ( Exception e ) {
            LOGGER.warn.log( e );
            zPrintWriter.println( "<fail>" );
            String zFailOut = Throwables.printStackTraceToString( e );
            zFailOut = Strings.replace( zFailOut, "<", "&lt;" );
            zFailOut = Strings.replace( zFailOut, ">", "&gt;" );
            zPrintWriter.println( zFailOut );
            zPrintWriter.println( "</fail>" );
            zPrintWriter.flush();
        }
    }

    private String justFileName( String pFileName ) {
        pFileName = "/" + cleanFileName( pFileName );
        return pFileName.substring( pFileName.lastIndexOf( '/' ) + 1 );
    }

    private String cleanFileName( String pFileName ) {
        pFileName = ConstrainTo.notNull( pFileName ).trim().replace( '\\', '/' );
        if ( (pFileName.length() >= 2) && Character.isLetter( pFileName.charAt( 0 ) ) && (':' == pFileName.charAt( 1 )) ) {
            pFileName = pFileName.substring( 2 ).trim();
        }
        while ( pFileName.startsWith( "/" ) ) {
            pFileName = pFileName.substring( 1 ).trim();
        }
        return pFileName;
    }

    private void insureCharacterEncoding( HttpServletRequest pReq )
            throws UnsupportedEncodingException {
        String zEnc = pReq.getCharacterEncoding();
        if ( zEnc != null ) {
            LOGGER.debug.log( zEnc, " = pReq.getCharacterEncoding();" );
        } else {
            LOGGER.debug.log( "pReq.setCharacterEncoding( \"", FileUtils.UTF_8, "\" );" );
            pReq.setCharacterEncoding( FileUtils.UTF_8 );
        }
    }

    /**
     * Obtain information on this servlet.
     *
     * @return String describing this servlet.
     */
    @Override
    public String getServletInfo() {
        return "File transfer servlet -- used to receive and send files";
    }
}