package org.jaudiotagger.tag.asf;

 import org.jaudiotagger.audio.asf.data.AsfHeader;

 import org.jaudiotagger.audio.asf.data.MetadataDescriptor;

 import org.jaudiotagger.logging.ErrorMessage;

 import org.jaudiotagger.tag.id3.valuepair.ImageFormats;

 import org.jaudiotagger.tag.asf.AbstractAsfTagImageField;

 import org.jaudiotagger.tag.asf.AsfFieldKey;

 import java.io.ByteArrayOutputStream;

 import java.io.UnsupportedEncodingException;

 import java.util.logging.Logger;

 /**

  * Encapsulates the WM/Pictures provides some convenience methods for decoding

  * the binary data it contains

  * <p/>

  * The value of a WM/Pictures metadata descriptor is as follows:

  * <p/>

  * byte0 Picture Type byte1-4 Length of the image data mime type encoded as

  * UTF-16LE null byte null byte description encoded as UTF-16LE (optional) null

  * byte null byte image data

  */

 public class AsfTagCoverField extends AbstractAsfTagImageField

 {

     /**

      * Logger Object

      */

     public final static Logger LOGGER = Logger

             .getLogger("org.jaudiotagger.audio.asf.tag");

     /**

      * Description

      */

     private String description;

     /**

      * We need this to retrieve the buffered image, if required

      */

     private int endOfName = 0;

     /**

      * Image Data Size as read

      */

     private int imageDataSize;

     /**

      * Mimetype of binary

      */

     private String mimeType;

     /**

      * Picture Type

      */

     private int pictureType;

     /**

      * Create New Image Field

      * 

      * @param imageData

      * @param pictureType

      * @param description

      * @param mimeType

      */

     public AsfTagCoverField(final byte[] imageData, final int pictureType,

             final String description, final String mimeType) {

         super(new MetadataDescriptor(AsfFieldKey.COVER_ART.getFieldName(),

                 MetadataDescriptor.TYPE_BINARY));

         this.getDescriptor()

                 .setBinaryValue(

                         createRawContent(imageData, pictureType, description,

                                 mimeType));

     }

     /**

      * Creates an instance from a metadata descriptor

      * 

      * @param source

      *            The metadata descriptor, whose content is published.<br>

      */

     public AsfTagCoverField(final MetadataDescriptor source) {

         super(source);

         if (!source.getName().equals(AsfFieldKey.COVER_ART.getFieldName())) {

             throw new IllegalArgumentException(

                     "Descriptor description must be WM/Picture");

         }

         if (source.getType() != MetadataDescriptor.TYPE_BINARY) {

             throw new IllegalArgumentException("Descriptor type must be binary");

         }

         try {

             processRawContent();

         } catch (final UnsupportedEncodingException uee) {

             // Should never happen

             throw new RuntimeException(uee); // NOPMD by Christian Laireiter on 5/9/09 5:45 PM

         }

     }

     private byte[] createRawContent(final byte[] data, final int pictureType,

             final String description, String mimeType) { // NOPMD by Christian Laireiter on 5/9/09 5:46 PM

         this.description = description;

         // Get Mimetype from data if not already setField

         if (mimeType == null) {

             mimeType = ImageFormats.getMimeTypeForBinarySignature(data);

             // Couldnt identify lets default to png because probably error in

             // code because not 100% sure how to identify

             // formats

             if (mimeType == null) {

                 LOGGER.warning(ErrorMessage.GENERAL_UNIDENITIFED_IMAGE_FORMAT

                         .getMsg());

                 mimeType = ImageFormats.MIME_TYPE_PNG;

             }

         }

         final ByteArrayOutputStream baos = new ByteArrayOutputStream();

         // PictureType

         baos.write(pictureType);

         // ImageDataSize

         baos.write(org.jaudiotagger.audio.generic.Utils

                 .getSizeLEInt32(data.length), 0, 4);

         // mimetype

         byte[] mimeTypeData;

         try {

             mimeTypeData = mimeType.getBytes(AsfHeader.ASF_CHARSET.name());

         } catch (final UnsupportedEncodingException uee) {

             // Should never happen

             throw new RuntimeException("Unable to find encoding:" // NOPMD by Christian Laireiter on 5/9/09 5:45 PM

                     + AsfHeader.ASF_CHARSET.name());

         }

         baos.write(mimeTypeData, 0, mimeTypeData.length);

         // Seperator

         baos.write(0x00);

         baos.write(0x00);

         // description

         if (description != null && description.length() > 0) {

             byte[] descriptionData;

             try {

                 descriptionData = description.getBytes(AsfHeader.ASF_CHARSET

                         .name());

             } catch (final UnsupportedEncodingException uee) {

                 // Should never happen

                 throw new RuntimeException("Unable to find encoding:" // NOPMD by Christian Laireiter on 5/9/09 5:45 PM

                         + AsfHeader.ASF_CHARSET.name());

             }

             baos.write(descriptionData, 0, descriptionData.length);

         }

         // Seperator (always write whther or not we have descriptor field)

         baos.write(0x00);

         baos.write(0x00);

         // Image data

         baos.write(data, 0, data.length);

         return baos.toByteArray();

     }

     public String getDescription() {

         return this.description;

     }

     @Override

     public int getImageDataSize() {

         return this.imageDataSize;

     }

     public String getMimeType() {

         return this.mimeType;

     }

     public int getPictureType() {

         return this.pictureType;

     }

     /**

      * @return the raw image data only

      */

     @Override

     public byte[] getRawImageData() {

         final ByteArrayOutputStream baos = new ByteArrayOutputStream();

         baos.write(getRawContent(), this.endOfName, this.toWrap

                 .getRawDataSize()

                 - this.endOfName);

         return baos.toByteArray();

     }

     private void processRawContent() throws UnsupportedEncodingException {

         // PictureType

         this.pictureType = this.getRawContent()[0];

         // ImageDataSize

         this.imageDataSize = org.jaudiotagger.audio.generic.Utils.getIntLE(this

                 .getRawContent(), 1, 2);

         // Set Count to after picture type,datasize and two byte nulls

         int count = 5;

         this.mimeType = null;

         this.description = null; // Optional

         int endOfMimeType = 0;

         while (count < this.getRawContent().length - 1) {

             if (getRawContent()[count] == 0 && getRawContent()[count + 1] == 0) {

                 if (this.mimeType == null) {

                     this.mimeType = new String(getRawContent(), 5, (count) - 5,

                             "UTF-16LE");

                     endOfMimeType = count + 2;

                 } else if (this.description == null) {

                     this.description = new String(getRawContent(),

                             endOfMimeType, count - endOfMimeType, "UTF-16LE");

                     this.endOfName = count + 2;

                     break;

                 }

             }

             count += 2; // keep on two byte word boundary

         }

     }

 }