import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.Part;

import org.apache.commons.fileupload.FileItem;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MultipartRequest extends HttpServletRequestWrapper {

    private static final Logger logger = LoggerFactory.getLogger(MultipartRequest.class);

    private Map<String, List<String>> formParams;

    private Map<String, List<FileItem>> fileParams;

    private Map<String, String[]> parameterMap;

    public MultipartRequest(HttpServletRequest request) throws IOException {
        super(request);
        formParams = new LinkedHashMap<String, List<String>>();
        fileParams = new LinkedHashMap<String, List<FileItem>>();

        try {
            parseRequest(request);
        } catch (ServletException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private void parseRequest(HttpServletRequest request) throws IOException, ServletException {

        Iterator<Part> parts = request.getParts().iterator();
        List<FileItem> items = new ArrayList<>();

        while (parts.hasNext()) {
            Part p = parts.next();

            if (p.getContentType() == null || !p.getContentType().toLowerCase().startsWith("image"))
                continue;

            items.add(new PartItem(p));
        }

        List<FileItem> fileItems = items;

        for (FileItem item : fileItems) {
            if (item.isFormField())
                addFormParam(item);
            else
                addFileParam(item);
        }
    }

    private void addFileParam(FileItem item) {
        if (fileParams.containsKey(item.getFieldName())) {
            fileParams.get(item.getFieldName()).add(item);
        } else {
            List<FileItem> items = new ArrayList<FileItem>();
            items.add(item);
            fileParams.put(item.getFieldName(), items);
        }
    }

    private void addFormParam(FileItem item) {
        if (formParams.containsKey(item.getFieldName())) {
            formParams.get(item.getFieldName()).add(getItemString(item));
        } else {
            List<String> items = new ArrayList<String>();
            items.add(getItemString(item));
            formParams.put(item.getFieldName(), items);
        }
    }

    private String getItemString(FileItem item) {
        try {
            String characterEncoding = getRequest().getCharacterEncoding();
            return (characterEncoding == null) ? item.getString() : item
                    .getString(characterEncoding);
        } catch (UnsupportedEncodingException e) {
            logger.error("Unsupported character encoding "
                    + getRequest().getCharacterEncoding());
            return item.getString();
        }
    }

    @Override
    public String getParameter(String name) {
        if (formParams.containsKey(name)) {
            List<String> values = formParams.get(name);
            if (values.isEmpty())
                return "";
            else
                return values.get(0);
        } else {
            return super.getParameter(name);
        }
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        if (parameterMap == null) {
            Map<String, String[]> map = new LinkedHashMap<String, String[]>();

            for (String formParam : formParams.keySet()) {
                map.put(formParam,
                        formParams.get(formParam).toArray(new String[0]));
            }

            map.putAll(super.getParameterMap());

            parameterMap = Collections.unmodifiableMap(map);
        }

        return parameterMap;
    }

    @Override
    public Enumeration<String> getParameterNames() {
        Set<String> paramNames = new LinkedHashSet<String>();
        paramNames.addAll(formParams.keySet());

        Enumeration<String> original = super.getParameterNames();
        while (original.hasMoreElements()) {
            paramNames.add(original.nextElement());
        }

        return Collections.enumeration(paramNames);
    }

    @Override
    public String[] getParameterValues(String name) {
        if (formParams.containsKey(name)) {
            List<String> values = formParams.get(name);
            if (values.isEmpty())
                return new String[0];
            else
                return values.toArray(new String[values.size()]);
        } else {
            return super.getParameterValues(name);
        }
    }

    public FileItem getFileItem(String name) {
        if (fileParams.containsKey(name)) {
            List<FileItem> items = fileParams.get(name);

            return items.get(0);
        } else {
            return null;
        }
    }
}