/**
    *    Copyright 2011 meltmedia
    *
    *    Licensed 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.
   */
  package org.xchain.framework.servlet;
  
  import org.apache.commons.fileupload.disk.DiskFileItemFactory;
  import org.apache.commons.fileupload.servlet.ServletFileUpload;
  import org.apache.commons.fileupload.FileItem;
  import org.apache.commons.fileupload.FileUploadException;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import javax.servlet.http.HttpServletRequestWrapper;
  import javax.servlet.http.HttpServletRequest;
  
  import java.util.List;
  import java.util.Map;
  import java.util.HashMap;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.Enumeration;
  
  import java.io.File;
  import java.lang.reflect.Array;
  
  /**
   *
   * This code was adapted from code originally written by Darius Robinson.
   *
   * @author Darius Robinson
   * @author Christian Trimble
   * @author John Trimble
   * @author Josh Kennedy
   * @version 1.0
   */
  public class MultipartFormDataServletRequest
    extends HttpServletRequestWrapper {
    
    public static Logger log = LoggerFactory.getLogger(MultipartFormDataServletRequest.class);
  
    private Map<String, String[]> parameterMap = new HashMap<String, String[]>();
    private Map<String, FileItem[]> fileItemMap = new HashMap<String, FileItem[]>();
  
    public MultipartFormDataServletRequest(HttpServletRequest request, long maxSize, int sizeThreshold, String repositoryPath)
      throws FileUploadException
    {
      super(request);
  
      // Create the disk file item factory.
      DiskFileItemFactory factory = createDiskFileItemFactory(sizeThreshold, repositoryPath);
      ServletFileUpload servletFileUpload = new ServletFileUpload(factory);
      // maximum size before a FileUploadException will be thrown
      servletFileUpload.setSizeMax(maxSize);
      
      // parse the request.
      Iterator<FileItem> fileItemIterator = servletFileUpload.parseRequest(request).iterator(); // Oye! Unchecked type conversion.
      
      // create temporary maps for parameters and file items.
      Map<String, List<String>> parameterMap = new HashMap<String, List<String>>();
      Map<String, List<FileItem>> fileItemMap = new HashMap<String, List<FileItem>>();
      
      // populate the maps.
      while( fileItemIterator.hasNext() ) {
        FileItem fileItem = fileItemIterator.next();
        if (fileItem.isFormField()) {
          putListMapValue(parameterMap, fileItem.getFieldName(), fileItem.getString());
        } else {
          putListMapValue(fileItemMap, fileItem.getFieldName(), fileItem);
        }
      }
      
      // convert the array lists.
      convertListMapToArrayMap(parameterMap, this.parameterMap, String.class);
      convertListMapToArrayMap(fileItemMap, this.fileItemMap, FileItem.class);
  
      if( log.isDebugEnabled() ) {
        logFileItemMap();
      }
  
    }
  
    public FileItem getFileItem( String name )
    {
      FileItem fileItem = null;
      FileItem[] fileItemArray = (FileItem[])fileItemMap.get(name);
  
     if( fileItemArray != null )
       fileItem = fileItemArray[0];
 
     return fileItem;
   }
 
   public Enumeration<String> getFileItemNames()
   {
     return new IteratorEnumeration<String>(fileItemMap.keySet().iterator());
   }
 
   public Map<String, FileItem[]> getFileItemMap()
   {
     return fileItemMap;
   }
 
   public FileItem[] getFileItemValues( String name )
   {
     return (FileItem[])fileItemMap.get(name);
   }
 
   public String getParameter( String name )
   {
     String parameter = null;
     String[] parameterList = (String[])parameterMap.get(name);
 
     if( parameterList != null && parameterList.length > 0 ) {
       parameter = parameterList[0];
     }
 
     return parameter;
   }
 
   public Enumeration<String> getParameterNames() { return new IteratorEnumeration<String>(parameterMap.keySet().iterator()); }
 
   public Map<String, String[]> getParameterMap() { return parameterMap; }
 
   public String[] getParameterValues( String name ) { return (String[])parameterMap.get(name); }
 
   private static <K,V> Map<K, V[]> convertListMapToArrayMap(Map<K, List<V>> listMap, Map<K, V[]> arrayMap, Class<V> elementType) {
     if( arrayMap == null ) 
       arrayMap = new HashMap<K, V[]>();
     for( Map.Entry<K, List<V>> e : listMap.entrySet() ) {
       V[] valueArray = (V[]) Array.newInstance(elementType, e.getValue().size());
       arrayMap.put(e.getKey(), e.getValue().toArray(valueArray));
     }
     return arrayMap;
   }
 
   private static <K, V> void putListMapValue( Map<K, List<V>> map, K key, V value )
   {
     List<V> valueArray = map.get(key);
 
     if( valueArray == null ) {
       valueArray = new ArrayList<V>();
       map.put(key, valueArray);
     }
     valueArray.add(value);
   }
 
   private static DiskFileItemFactory createDiskFileItemFactory( int sizeThreshold, String repositoryPath ) throws FileUploadException {
     DiskFileItemFactory factory = new DiskFileItemFactory();
     
     // the location for saving data that is larger than getSizeThreshold()
     File repository = new File(repositoryPath);
     factory.setRepository(repository);
     
     // maximum size that will be stored in memory
     factory.setSizeThreshold(sizeThreshold);
     
     // Check to see if repository exists; if not, try to create it; if this fails, throw an exception. 
     if( repository.exists() ) {
       if( !repository.isDirectory() ) {
         throw new FileUploadException("Cannot upload files because the specified temporary "
                         + "directory is of type file. (" + repository.getAbsolutePath() + ")");
       }
     } else if( !repository.mkdir() ) {
       throw new FileUploadException("Cannot upload files because the specified temporary "
                         + " does not exist, and attempts to create it have failed. ("
                         + repository.getAbsolutePath() + ")");
           
     }
     return factory;
   }
 
   protected void logFileItemMap()
   {
     log.debug("File item map has "+fileItemMap.keySet().size()+" keys.");
     Iterator<Map.Entry<String, FileItem[]>> entryIterator = fileItemMap.entrySet().iterator();
     while( entryIterator.hasNext() ) {
       Map.Entry<String, FileItem[]> entry = entryIterator.next();
       String key = entry.getKey();
       FileItem[] fileItems = entry.getValue();
 
       log.debug("Key '"+key+"' has "+fileItems.length+" entries.");
 
       for( int i = 0; i < fileItems.length; i++ ) {
         log.debug("Name='"+fileItems[i].getName()+"', size="+fileItems[i].getSize()+", content-type='"+fileItems[i].getContentType()+"'");
       }
     }
   }
 }
 
 class IteratorEnumeration<T>
   implements Enumeration<T>
 {
   Iterator<T> wrappedIterator = null;
   public IteratorEnumeration( Iterator<T> wrappedIterator ) { this.wrappedIterator = wrappedIterator; }
   public boolean hasMoreElements() { return wrappedIterator.hasNext(); }
   public T nextElement() { return wrappedIterator.next(); }
 }