/*
    * Licensed to The Apereo Foundation under one or more contributor license
    * agreements. See the NOTICE file distributed with this work for additional
    * information regarding copyright ownership.
    *
    *
    * The Apereo Foundation licenses this file to you under the Educational
    * Community 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://opensource.org/licenses/ecl2.txt
   *
   * 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.opencastproject.mediapackage;
  
  import static org.opencastproject.util.data.functions.Misc.chuck;
  
  import org.opencastproject.util.DateTimeSupport;
  import org.opencastproject.util.XmlSafeParser;
  
  import org.apache.commons.lang3.StringUtils;
  import org.codehaus.jettison.mapped.Configuration;
  import org.codehaus.jettison.mapped.MappedNamespaceConvention;
  import org.codehaus.jettison.mapped.MappedXMLStreamWriter;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  import java.io.StringWriter;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  
  import javax.xml.bind.JAXBException;
  import javax.xml.bind.Marshaller;
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.stream.XMLStreamException;
  import javax.xml.stream.XMLStreamWriter;
  
  /**
   * Convenience implementation that supports serializing and deserializing media packages.
   */
  public final class MediaPackageParser {
  
    /**
     * Private constructor to prohibit instances of this static utility class.
     */
    private MediaPackageParser() {
      // Nothing to do
    }
  
    /**
     * Serializes the media package to a string.
     *
     * @param mediaPackage
     *          the media package
     * @return the serialized media package
     */
    public static String getAsXml(MediaPackage mediaPackage) {
      if (mediaPackage == null)
        throw new IllegalArgumentException("Mediapackage must not be null");
      try {
        Marshaller marshaller = MediaPackageImpl.context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, false);
        StringWriter writer = new StringWriter();
        marshaller.marshal(mediaPackage, writer);
        return writer.toString();
      } catch (JAXBException e) {
        throw new IllegalStateException(e.getLinkedException() != null ? e.getLinkedException() : e);
      }
    }
  
    /**
     * Serializes the media package to a JSON string.
     *
     * @param mediaPackage
     *          the media package
     * @return the serialized media package
     */
    public static String getAsJSON(MediaPackage mediaPackage) {
      if (mediaPackage == null) {
        throw new IllegalArgumentException("Mediapackage must not be null");
      }
      try {
        Marshaller marshaller = MediaPackageImpl.context.createMarshaller();
  
        Configuration config = new Configuration();
        config.setSupressAtAttributes(true);
        MappedNamespaceConvention con = new MappedNamespaceConvention(config);
       StringWriter writer = new StringWriter();
       XMLStreamWriter xmlStreamWriter = new MappedXMLStreamWriter(con, writer) {
         @Override
         public void writeStartElement(String prefix, String local, String uri) throws XMLStreamException {
           super.writeStartElement("", local, "");
         }
 
         @Override
         public void writeStartElement(String uri, String local) throws XMLStreamException {
           super.writeStartElement("", local, "");
         }
 
         @Override
         public void setPrefix(String pfx, String uri) throws XMLStreamException {
         }
 
         @Override
         public void setDefaultNamespace(String uri) throws XMLStreamException {
         }
       };
 
       marshaller.marshal(mediaPackage, xmlStreamWriter);
       return writer.toString();
     } catch (JAXBException e) {
       throw new IllegalStateException(e.getLinkedException() != null ? e.getLinkedException() : e);
     }
   }
 
   /** Serializes a media package to a {@link Document} without any further processing. */
   public static Document getAsXmlDocument(MediaPackage mp) {
     try {
       final Marshaller marshaller = MediaPackageImpl.context.createMarshaller();
       final Document doc = newDocument();
       marshaller.marshal(mp, doc);
       return doc;
     } catch (JAXBException e) {
       return chuck(e);
     }
   }
 
   /** Create a new DOM document. */
   private static Document newDocument() {
     final DocumentBuilderFactory docBuilderFactory = XmlSafeParser.newDocumentBuilderFactory();
     docBuilderFactory.setNamespaceAware(true);
     try {
       return docBuilderFactory.newDocumentBuilder().newDocument();
     } catch (ParserConfigurationException e) {
       return chuck(e);
     }
   }
 
   /**
    * Serializes the media package to a {@link org.w3c.dom.Document}.
    * <p>
    * todo Implementation is currently defective since it misses various properties. See
    * http://opencast.jira.com/browse/MH-9489 Use {@link #getAsXmlDocument(MediaPackage)} instead if you do not need a
    * serializer.
    *
    * @param mediaPackage
    *          the mediapackage
    * @param serializer
    *          the serializer
    * @return the serialized media package
    * @throws MediaPackageException
    *           if serializing fails
    */
   public static Document getAsXml(MediaPackage mediaPackage, MediaPackageSerializer serializer)
           throws MediaPackageException {
     DocumentBuilderFactory docBuilderFactory = XmlSafeParser.newDocumentBuilderFactory();
     docBuilderFactory.setNamespaceAware(true);
 
     DocumentBuilder docBuilder = null;
     try {
       docBuilder = docBuilderFactory.newDocumentBuilder();
     } catch (ParserConfigurationException e1) {
       throw new MediaPackageException(e1);
     }
 
     Document doc = docBuilder.newDocument();
 
     // Root element "mediapackage"
     Element mpXml = doc.createElement("mediapackage");
     doc.appendChild(mpXml);
 
     // Handle
     if (mediaPackage.getIdentifier() != null)
       mpXml.setAttribute("id", mediaPackage.getIdentifier().toString());
 
     // Start time
     if (mediaPackage.getDate() != null && mediaPackage.getDate().getTime() > 0)
       mpXml.setAttribute("start", DateTimeSupport.toUTC(mediaPackage.getDate().getTime()));
 
     // Duration
     if (mediaPackage.getDuration() != null)
       mpXml.setAttribute("duration", Long.toString(mediaPackage.getDuration()));
 
     // Separate the media package members
     List<Track> tracks = new ArrayList<Track>();
     List<Attachment> attachments = new ArrayList<Attachment>();
     List<Catalog> metadata = new ArrayList<Catalog>();
     List<MediaPackageElement> others = new ArrayList<MediaPackageElement>();
 
     // Sort media package elements
     for (MediaPackageElement e : mediaPackage.elements()) {
       if (e instanceof Track)
         tracks.add((Track) e);
       else if (e instanceof Attachment)
         attachments.add((Attachment) e);
       else if (e instanceof Catalog)
         metadata.add((Catalog) e);
       else
         others.add(e);
     }
 
     // Tracks
     if (tracks.size() > 0) {
       Element tracksNode = doc.createElement("media");
       Collections.sort(tracks);
       for (Track t : tracks) {
         tracksNode.appendChild(t.toManifest(doc, serializer));
       }
       mpXml.appendChild(tracksNode);
     }
 
     // Metadata
     if (metadata.size() > 0) {
       Element metadataNode = doc.createElement("metadata");
       Collections.sort(metadata);
       for (Catalog m : metadata) {
         metadataNode.appendChild(m.toManifest(doc, serializer));
       }
       mpXml.appendChild(metadataNode);
     }
 
     // Attachments
     if (attachments.size() > 0) {
       Element attachmentsNode = doc.createElement("attachments");
       Collections.sort(attachments);
       for (Attachment a : attachments) {
         attachmentsNode.appendChild(a.toManifest(doc, serializer));
       }
       mpXml.appendChild(attachmentsNode);
     }
 
     // Unclassified
     if (others.size() > 0) {
       Element othersNode = doc.createElement("unclassified");
       Collections.sort(others);
       for (MediaPackageElement e : others) {
         othersNode.appendChild(e.toManifest(doc, serializer));
       }
       mpXml.appendChild(othersNode);
     }
 
     return mpXml.getOwnerDocument();
   }
 
   /**
    * Parses the media package and returns its object representation.
    *
    * @param xml
    *          the serialized media package
    * @return the media package instance
    * @throws MediaPackageException
    *           if de-serializing the media package fails
    */
   public static MediaPackage getFromXml(String xml) throws MediaPackageException {
     MediaPackageBuilder builder = MediaPackageBuilderFactory.newInstance().newMediaPackageBuilder();
     return builder.loadFromXml(xml);
   }
 
   /**
    * Serializes media package list to a string.
    *
    * @param mediaPackages
    *          media package list to be serialized
    * @return serialized media package list
    * @throws MediaPackageException
    *           if serialization fails
    */
   public static String getArrayAsXml(List<MediaPackage> mediaPackages) throws MediaPackageException {
     try {
       StringBuilder builder = new StringBuilder();
       if (mediaPackages.isEmpty())
         return builder.toString();
       builder.append(getAsXml(mediaPackages.get(0)));
       for (int i = 1; i < mediaPackages.size(); i++) {
         builder.append("###");
         builder.append(getAsXml(mediaPackages.get(i)));
       }
       return builder.toString();
     } catch (Exception e) {
       if (e instanceof MediaPackageException) {
         throw (MediaPackageException) e;
       } else {
         throw new MediaPackageException(e);
       }
     }
   }
 
   /**
    * Parses the serialized media package list.
    *
    * @param xml
    *          String to be parsed
    * @return parsed media package list
    * @throws MediaPackageException
    *           if de-serialization fails
    */
   public static List<MediaPackage> getArrayFromXml(String xml) throws MediaPackageException {
     try {
       List<MediaPackage> mediaPackages = new LinkedList<MediaPackage>();
       if (StringUtils.isBlank(xml))
         return mediaPackages;
       String[] xmlArray = xml.split("###");
       for (String xmlElement : xmlArray) {
         mediaPackages.add(getFromXml(xmlElement.trim()));
       }
       return mediaPackages;
     } catch (Exception e) {
       if (e instanceof MediaPackageException) {
         throw (MediaPackageException) e;
       } else {
         throw new MediaPackageException(e);
       }
     }
   }
 
 }