enhancer/jersey/src/main/java/org/apache/stanbol/enhancer/jersey/writers/ContentItemWriter.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.stanbol.enhancer.jersey.writers;

import static javax.ws.rs.core.MediaType.APPLICATION_OCTET_STREAM_TYPE;
import static javax.ws.rs.core.MediaType.MULTIPART_FORM_DATA_TYPE;
import static javax.ws.rs.core.MediaType.TEXT_PLAIN_TYPE;
import static javax.ws.rs.core.MediaType.WILDCARD_TYPE;
import static org.apache.stanbol.enhancer.jersey.utils.RequestPropertiesHelper.REQUEST_PROPERTIES_URI;
import static org.apache.stanbol.enhancer.jersey.utils.RequestPropertiesHelper.getOutputContent;
import static org.apache.stanbol.enhancer.jersey.utils.RequestPropertiesHelper.getOutputContentParts;
import static org.apache.stanbol.enhancer.jersey.utils.RequestPropertiesHelper.getParsedContentURIs;
import static org.apache.stanbol.enhancer.jersey.utils.RequestPropertiesHelper.getRdfFormat;
import static org.apache.stanbol.enhancer.jersey.utils.RequestPropertiesHelper.isOmitMetadata;
import static org.apache.stanbol.enhancer.jersey.utils.RequestPropertiesHelper.isOmitParsedContent;
import static org.apache.stanbol.enhancer.servicesapi.helper.ContentItemHelper.getBlob;
import static org.apache.stanbol.enhancer.servicesapi.helper.ContentItemHelper.getContentParts;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;

import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Provider;

import org.apache.clerezza.commons.rdf.Graph;
import org.apache.clerezza.commons.rdf.IRI;
import org.apache.clerezza.rdf.core.serializedform.Serializer;
import org.apache.clerezza.rdf.core.serializedform.UnsupportedSerializationFormatException;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Property;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.http.HttpEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MIME;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.AbstractContentBody;
import org.apache.http.entity.mime.content.ContentBody;
import org.apache.http.entity.mime.content.ContentDescriptor;
import org.apache.http.entity.mime.content.InputStreamBody;
import org.apache.http.message.BasicNameValuePair;
import org.apache.stanbol.enhancer.servicesapi.Blob;
import org.apache.stanbol.enhancer.servicesapi.ContentItem;
import org.apache.stanbol.enhancer.servicesapi.helper.ContentItemHelper;
import org.codehaus.jettison.json.JSONArray;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component
@Service(Object.class)
@Property(name = "javax.ws.rs", boolValue = true)
@Provider
public class ContentItemWriter implements MessageBodyWriter<ContentItem> {

    public static final String CONTENT_ITEM_BOUNDARY;
    public static final String CONTENT_PARTS_BOUNDERY;;
    /**
     * The pool of ASCII chars to be used for generating a multipart boundary.
     */
    private final static char[] MULTIPART_CHARS =
            "-_1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                    .toCharArray();
    static {
        final Random rand = new Random();
        final int count = rand.nextInt(11) + 10; // a random size from 10 to 20
        StringBuilder randomString = new StringBuilder(count);
        for (int i = 0; i < count; i++) {
            randomString.append(MULTIPART_CHARS[rand.nextInt(MULTIPART_CHARS.length)]);
        }
        CONTENT_ITEM_BOUNDARY = "contentItem-"+randomString;
        CONTENT_PARTS_BOUNDERY = "contentParts-"+randomString;
    }
    private static final ContentType MULTIPART_ALTERNATE = ContentType.create("multipart/alternate");

    Logger log = LoggerFactory.getLogger(ContentItemWriter.class);
    
    /**
     * The "multipart/*" wilrcard
     */
    private static final MediaType MULTIPART = MediaType.valueOf(MULTIPART_FORM_DATA_TYPE.getType()+"/*");
    private static final Charset UTF8 = Charset.forName("UTF-8");
    /**
     * The media type for JSON-LD (<code>application/ld+json</code>)
     */
    private static String APPLICATION_LD_JSON = "application/ld+json";
    private static MediaType APPLICATION_LD_JSON_TYPE = MediaType.valueOf(APPLICATION_LD_JSON);
    private static final MediaType DEFAULT_RDF_FORMAT = new MediaType(
        APPLICATION_LD_JSON_TYPE.getType(), 
        APPLICATION_LD_JSON_TYPE.getSubtype(), 
        Collections.singletonMap("charset", UTF8.name()));
    
    @Reference
    private Serializer serializer;
    
    /**
     * Default Constructor used by OSGI. This expects that the {@link #serializer}
     * is injected
     */
    public ContentItemWriter(){};
    /**
     * Creates a {@link ContentItemWriter} by using the parsed Clerezza
     * {@link Serializer}. Intended to be used by unit tests or when running not
     * in an OSGI environment.
     * @param serializer
     */
    public ContentItemWriter(Serializer serializer) {
		this.serializer = serializer;
	}

	@Override
    public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
        return //MediaType.MULTIPART_FORM_DATA_TYPE.isCompatible(mediaType) &&
                ContentItem.class.isAssignableFrom(type);
    }

    @Override
    public long getSize(ContentItem t,
                        Class<?> type,
                        Type genericType,
                        Annotation[] annotations,
                        MediaType mediaType) {
        return -1;
    }

    @Override
    public void writeTo(ContentItem ci,
                        Class<?> type,
                        Type genericType,
                        Annotation[] annotations,
                        MediaType mediaType,
                        MultivaluedMap<String,Object> httpHeaders,
                        OutputStream entityStream) throws IOException, WebApplicationException {

        //(0) handle default dataType
        Map<String,Object> reqProp = ContentItemHelper.getRequestPropertiesContentPart(ci);
        boolean omitMetadata = isOmitMetadata(reqProp);
        if(!MULTIPART.isCompatible(mediaType)){ //two possible cases
            if(!omitMetadata){ //  (1) just return the RDF data
                //(1.a) Backward support for default dataType if no Accept header is set
                StringBuilder ctb = new StringBuilder();
                if (mediaType.isWildcardType() || 
                        TEXT_PLAIN_TYPE.isCompatible(mediaType) || 
                        APPLICATION_OCTET_STREAM_TYPE.isCompatible(mediaType)) {
                    ctb.append(APPLICATION_LD_JSON);
                } else {
                    ctb.append(mediaType.getType()).append('/').append(mediaType.getSubtype());
                }
                ctb.append(";charset=").append(UTF8.name());
                String contentType = ctb.toString();
                httpHeaders.putSingle(HttpHeaders.CONTENT_TYPE, contentType);
                try {
                	serializer.serialize(entityStream, ci.getMetadata(), contentType);
                } catch (UnsupportedSerializationFormatException e) {
                    throw new WebApplicationException("The enhancement results "
                        + "cannot be serialized in the requested media type: "
                        + mediaType.toString(),Response.Status.NOT_ACCEPTABLE);
                }
            } else { //  (2) return a single content part
                Entry<IRI,Blob> contentPart = getBlob(ci, Collections.singleton(mediaType.toString()));
                if(contentPart == null){ //no alternate content with the requeste media type
                    throw new WebApplicationException("The requested enhancement chain has not created an "
                            + "version of the parsed content in the reuqest media type "
                            + mediaType.toString(),Response.Status.UNSUPPORTED_MEDIA_TYPE);
                } else { //found -> stream the content to the client
                    //NOTE: This assumes that the presence of a charset
                    //      implies reading/writing character streams
                    String requestedCharset = mediaType.getParameters().get("charset");
                    String blobCharset = contentPart.getValue().getParameter().get("charset");
                    Charset readerCharset = blobCharset == null ? UTF8 : Charset.forName(blobCharset);
                    Charset writerCharset = requestedCharset == null ? null : Charset.forName(requestedCharset);
                    if(writerCharset != null && !writerCharset.equals(readerCharset)){
                        //we need to transcode
                        Reader reader = new InputStreamReader(
                            contentPart.getValue().getStream(),readerCharset);
                        Writer writer = new OutputStreamWriter(entityStream, writerCharset);
                        IOUtils.copy(reader, writer);
                        IOUtils.closeQuietly(reader);
                    } else { //no transcoding
                        if(requestedCharset == null && blobCharset != null){
                            httpHeaders.putSingle(HttpHeaders.CONTENT_TYPE, 
                                mediaType.toString()+"; charset="+blobCharset);
                        }
                        InputStream in  = contentPart.getValue().getStream();
                        IOUtils.copy(in, entityStream);
                        IOUtils.closeQuietly(in);
                    }
                }
            }
        } else { // multipart mime requested!
            final String charsetName = mediaType.getParameters().get("charset");
            final Charset charset = charsetName != null ? Charset.forName(charsetName) : UTF8;
            MediaType rdfFormat;
            String rdfFormatString = getRdfFormat(reqProp);
            if(rdfFormatString == null || rdfFormatString.isEmpty()){
                rdfFormat = DEFAULT_RDF_FORMAT;
            } else {
                try {
                    rdfFormat = MediaType.valueOf(rdfFormatString);
                    if(rdfFormat.getParameters().get("charset") == null){
                        //use the charset of the default RDF format
                        rdfFormat = new MediaType(
                            rdfFormat.getType(), rdfFormat.getSubtype(), 
                            DEFAULT_RDF_FORMAT.getParameters());
                    }
                } catch (IllegalArgumentException e) {
                    throw new WebApplicationException("The specified RDF format '"
                        + rdfFormatString +"' (used to serialize all RDF parts of " 
                        + "multipart MIME responses) is not a well formated MIME type",
                        Response.Status.BAD_REQUEST);
                }
            }
            //(1) setting the correct header
            String contentType = String.format("%s/%s; charset=%s; boundary=%s",
                mediaType.getType(),mediaType.getSubtype(),charset.toString(),CONTENT_ITEM_BOUNDARY);
            httpHeaders.putSingle(HttpHeaders.CONTENT_TYPE,contentType);
            MultipartEntityBuilder entityBuilder = MultipartEntityBuilder.create();
            entityBuilder.setBoundary(CONTENT_ITEM_BOUNDARY);
            //HttpMultipart entity = new HttpMultipart("from-data", charset ,CONTENT_ITEM_BOUNDARY);
            //(2) serialising the metadata
            if(!isOmitMetadata(reqProp)){
                entityBuilder.addPart("metadata", new ClerezzaContentBody(
                    ci.getUri().getUnicodeString(), ci.getMetadata(), rdfFormat));
//                entity.addBodyPart(new FormBodyPart("metadata", new ClerezzaContentBody(
//                    ci.getUri().getUnicodeString(), ci.getMetadata(),
//                    rdfFormat)));
            }
            //(3) serialising the Content (Bloby)
            //(3.a) Filter based on parameter
            List<Entry<IRI,Blob>> includedBlobs = filterBlobs(ci, reqProp);
            //(3.b) Serialise the filtered
            if(!includedBlobs.isEmpty()) {
                Map<String,ContentBody> contentParts = new LinkedHashMap<String,ContentBody>();
                for(Entry<IRI,Blob> entry : includedBlobs){
                    Blob blob = entry.getValue();
                    ContentType ct = ContentType.create(blob.getMimeType());
                    String cs = blob.getParameter().get("charset");
                    if(StringUtils.isNotBlank(cs)){
                        ct = ct.withCharset(cs);
                    }
                    contentParts.put(entry.getKey().getUnicodeString(), 
                        new InputStreamBody(blob.getStream(),ct));
                }
                //add all the blobs
                entityBuilder.addPart("content", new MultipartContentBody(contentParts,
                    CONTENT_PARTS_BOUNDERY, MULTIPART_ALTERNATE));
            } //else no content to include
            Set<String> includeContentParts = getIncludedContentPartURIs(reqProp);
            if(includeContentParts != null){
                //(4) serialise the Request Properties
                if(includeContentParts.isEmpty() || includeContentParts.contains(
                    REQUEST_PROPERTIES_URI.getUnicodeString())) {
                    JSONObject object;
                    try {
                        object = toJson(reqProp);
                    } catch (JSONException e) {
                        String message = "Unable to convert Request Properties " 
                                + "to JSON (values : "+reqProp+")!";
                        log.error(message,e);
                        throw new WebApplicationException(message, Response.Status.INTERNAL_SERVER_ERROR);
                    }
                    entityBuilder.addTextBody(
                        REQUEST_PROPERTIES_URI.getUnicodeString(), object.toString(),
                         ContentType.APPLICATION_JSON.withCharset(UTF8));
                }
                //(5) additional RDF metadata stored in contentParts
                for(Entry<IRI,Graph> entry : getContentParts(ci, Graph.class).entrySet()){
                    if(includeContentParts.isEmpty() || includeContentParts.contains(
                        entry.getKey())){
                        entityBuilder.addPart(entry.getKey().getUnicodeString(), 
                            new ClerezzaContentBody(null, //no file name
                                entry.getValue(),rdfFormat));
                    } // else ignore this content part
                }
            }
            entityBuilder.build().writeTo(entityStream);
        }   
            
    }
    /**
     * @param properties
     * @return
     */
    private JSONObject toJson(Map<?,?> map) throws JSONException {
        JSONObject object = new JSONObject();
        for(Entry<?,?> entry : map.entrySet()){
            Object value = getValue(entry.getValue());
            object.put(entry.getKey().toString(),value);
        }
        return object;
    }
    /**
     * @param entry
     * @return
     * @throws JSONException
     */
    private Object getValue(Object javaValue) throws JSONException {
        Object value;
        if(javaValue instanceof Collection<?>){
            value = new JSONArray();
            for(Object o : (Collection<?>)javaValue){
                ((JSONArray)value).put(getValue(o));
            }
        } else if(javaValue instanceof Map<?,?>){
            value = toJson((Map<?,?>)javaValue);
        } else {
            value = javaValue;
        }
        return value;
    }
    /**
     * @param properties
     * @return
     */
    private Set<String> getIncludedContentPartURIs(Map<String,Object> properties) {
        Collection<String> ocp = getOutputContentParts(properties);
        if(ocp == null || ocp.isEmpty()){
            return null;
        }
        Set<String> includeContentParts = new HashSet<String>(ocp);
        if(includeContentParts != null){
            if(includeContentParts.isEmpty()){ //empty == none
                includeContentParts = null;
            } else if (includeContentParts.contains("*")){ // * == all -> empty list
                includeContentParts = Collections.emptySet();
            }
        }
        return includeContentParts;
    }
    /**
     * @param ci
     * @param properties
     * @return
     */
    private List<Entry<IRI,Blob>> filterBlobs(ContentItem ci, Map<String,Object> properties) {
        final List<Entry<IRI,Blob>> includedContentPartList;
        Set<MediaType> includeMediaTypes = getIncludedMediaTypes(properties);
        if(includeMediaTypes == null){
            includedContentPartList = Collections.emptyList();
        } else {
            includedContentPartList = new ArrayList<Map.Entry<IRI,Blob>>();
            Set<String> ignoreContentPartUris = getIgnoredContentURIs(properties);
            nextContentPartEntry: 
            for(Entry<IRI,Blob> entry : getContentParts(ci,Blob.class).entrySet()){
                if(!ignoreContentPartUris.contains(entry.getKey().getUnicodeString())){
                    Blob blob = entry.getValue();
                    MediaType blobMediaType = MediaType.valueOf(blob.getMimeType());
                    for(MediaType included : includeMediaTypes) {
                        if(blobMediaType.isCompatible(included)){
                            includedContentPartList.add(entry);
                            continue nextContentPartEntry;
                        }
                    }
                } //else ignore this Blob
            }
        }
        return includedContentPartList;
    }
    /**
     * @param properties
     * @return
     */
    private Set<String> getIgnoredContentURIs(Map<String,Object> properties) {
        Set<String> ignoreContentPartUris = isOmitParsedContent(properties) ?
                new HashSet<String>(getParsedContentURIs(properties)) : null;
        if(ignoreContentPartUris == null){
            ignoreContentPartUris = Collections.emptySet();
        }
        return ignoreContentPartUris;
    }
    /**
     * @param properties
     * @return
     */
    private Set<MediaType> getIncludedMediaTypes(Map<String,Object> properties) throws WebApplicationException {
        Collection<String> includeMediaTypeStrings = getOutputContent(properties);
        if(includeMediaTypeStrings == null){
            return null;
        }
        Set<MediaType> includeMediaTypes = new HashSet<MediaType>(includeMediaTypeStrings.size());
        for(String includeString : includeMediaTypeStrings){
            if(includeString != null){
                includeString = includeString.trim();
                if(!includeString.isEmpty()){
                    if("*".equals(includeString)){ //also support '*' for '*/*'
                        includeMediaTypes.add(WILDCARD_TYPE);
                    } else {
                        try {
                            includeMediaTypes.add(MediaType.valueOf(includeString));
                        } catch (IllegalArgumentException e){
                            throw new WebApplicationException("The parsed outputContent "
                                + "parameter " + includeMediaTypeStrings +" contain an "
                                + "illegal formated MediaType!", Response.Status.BAD_REQUEST);
                        }
                    }
                }
            }
        }
        if(includeMediaTypes.contains(WILDCARD_TYPE)){
            includeMediaTypes = Collections.singleton(WILDCARD_TYPE);
        }
        return includeMediaTypes;
    }

    /**
     * Supports sending multipart mime as {@link ContentBody}.
     * @author Rupert Westenthaler
     *
     */
    private class MultipartContentBody extends AbstractContentBody implements ContentBody,ContentDescriptor {

        private Map<String,ContentBody> parts;
        private String boundary;

        public MultipartContentBody(Map<String,ContentBody> parts, String boundary, ContentType contentType){
            super(ContentType.create(contentType.getMimeType(), new BasicNameValuePair("boundary",boundary)));
            this.parts = parts;
            this.boundary = boundary;
        }
//        @Override
//        public String getCharset() {
//            return null; //no charset for multipart parts
//        }
//        @Override
//        public String getMimeType() {
//            String mime = new StringBuilder(super.getMimeType()).append("; boundary=")
//                    .append(boundary).toString();
//            log.info("!!! {}",mime);
//            return mime;
//            
//        }
        @Override
        public String getTransferEncoding() {
            return MIME.ENC_8BIT;
        }

        @Override
        public long getContentLength() {
            //not known as we would need to count the content length AND
            //the length of the different mime headers.
            return -1;
        }

        @Override
        public String getFilename() {
            return null;
        }

        @Override
        public void writeTo(OutputStream out) throws IOException {
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            builder.setBoundary(boundary);
            for(Entry<String,ContentBody> part : parts.entrySet()){
                builder.addPart(part.getKey(), part.getValue());
            }
            HttpEntity entity = builder.build();
            entity.writeTo(out);
        }
        
    }
    /**
     * Supports serialised RDF graphs as {@link ContentBody}
     * @author Rupert Westenthaler
     *
     */
    private class ClerezzaContentBody extends AbstractContentBody implements ContentBody,ContentDescriptor {

        private Graph graph;
        private String charset;
        private String name;

        protected ClerezzaContentBody(String name, Graph graph, MediaType mimeType){
            super(ContentType.create(new StringBuilder(mimeType.getType())
            .append('/').append(mimeType.getSubtype()).toString(), UTF8));
            charset = mimeType.getParameters().get("charset");
            if(charset == null || charset.isEmpty()){
                charset = UTF8.toString();
            }
            this.name = name;
            this.graph = graph;
        }

        @Override
        public String getCharset() {
            return charset;
        }

        @Override
        public String getTransferEncoding() {
            return MIME.ENC_8BIT;
        }

        @Override
        public long getContentLength() {
            return -1;
        }

        @Override
        public String getFilename() {
            return name;
        }

        @Override
        public void writeTo(OutputStream out) throws IOException {
            serializer.serialize(out, graph, getMediaType()+'/'+getSubType());
        }
    }
    
}