content: /*
   * Copyright (C) 2013 4th Line GmbH, Switzerland
   *
   * The contents of this file are subject to the terms of either the GNU
   * Lesser General Public License Version 2 or later ("LGPL") or the
   * Common Development and Distribution License Version 1 or later
   * ("CDDL") (collectively, the "License"). You may not use this file
   * except in compliance with the License. See LICENSE.txt for more
   * information.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   */
  
  package org.fourthline.cling.model.meta;
  
  
  import org.fourthline.cling.model.Validatable;
  import org.fourthline.cling.model.ValidationError;
  import org.fourthline.cling.model.types.BinHexDatatype;
  import org.seamless.util.io.IO;
  import org.seamless.util.MimeType;
  import org.seamless.util.URIUtil;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.logging.Logger;
  
  /**
   * The metadata of a device icon, might include the actual image data of a local icon.
   *
   * <p>
   * Note that validation of icons is lax on purpose, a valid <code>Icon</code> might still
   * return <code>null</code> from {@link #getMimeType()}, {@link #getWidth()},
   * {@link #getHeight()}, and {@link #getDepth()}. However, {@link #getUri()} will return
   * a valid URI for a valid <code>Icon</code>.
   * </p>
   *
   * @author Christian Bauer
   */
  public class Icon implements Validatable {
  
      final private static Logger log = Logger.getLogger(StateVariable.class.getName());
  
      final private MimeType mimeType;
      final private int width;
      final private int height;
      final private int depth;
      final private URI uri;
      final private byte[] data;
  
      // Package mutable state
      private Device device;
  
      /**
       * Used internally by Cling when {@link RemoteDevice} is discovered, you shouldn't have to call this.
       */
      public Icon(String mimeType, int width, int height, int depth, URI uri) {
          this(mimeType != null && mimeType.length() > 0 ? MimeType.valueOf(mimeType) : null, width, height, depth, uri, null);
      }
  
      /**
       * Use this constructor if your local icon data can be resolved on the classpath, for
       * example: <code>MyClass.class.getResource("/my/icon.png)</code>
       *
       * @param url A URL of the icon data that can be read with <code>new File(url.toURI())</code>.
       */
      public Icon(String mimeType, int width, int height, int depth, URL url) throws IOException{
          this(mimeType, width, height, depth, new File(URIUtil.toURI(url)));
      }
  
      /**
       * Use this constructor if your local icon data can be resolved with a <code>File</code>, the file's
       * name must be unique within the scope of a device.
       */
      public Icon(String mimeType, int width, int height, int depth, File file) throws IOException {
          this(mimeType, width, height, depth, file.getName(), IO.readBytes(file));
      }
  
      /**
       * Use this constructor if your local icon data is an <code>InputStream</code>.
       *
       * @param uniqueName Must be a valid URI path segment and unique within the scope of a device.
       */
      public Icon(String mimeType, int width, int height, int depth, String uniqueName, InputStream is) throws IOException {
          this(mimeType, width, height, depth, uniqueName, IO.readBytes(is));
      }
  
      /**
       * Use this constructor if your local icon data is in a <code>byte[]</code>.
       *
       * @param uniqueName Must be a valid URI path segment and unique within the scope of a device.
       */
      public Icon(String mimeType, int width, int height, int depth, String uniqueName, byte[] data) {
          this(mimeType != null && mimeType.length() > 0 ? MimeType.valueOf(mimeType) : null, width, height, depth, URI.create(uniqueName), data);
      }
  
      /**
       * Use this constructor if your local icon is binary data encoded with <em>BinHex</em>.
  
       * @param uniqueName Must be a valid URI path segment and unique within the scope of a device.
       * @param binHexEncoded The icon bytes encoded as BinHex.
       */
      public Icon(String mimeType, int width, int height, int depth, String uniqueName, String binHexEncoded) {
          this(
                  mimeType, width, height, depth, uniqueName,
                  binHexEncoded != null && !binHexEncoded.equals("") ? new BinHexDatatype().valueOf(binHexEncoded) : null
          );
      }
  
      protected Icon(MimeType mimeType, int width, int height, int depth, URI uri, byte[] data) {
          this.mimeType = mimeType;
          this.width = width;
          this.height = height;
          this.depth = depth;
          this.uri = uri;
          this.data = data;
      }
  
      public MimeType getMimeType() {
          return mimeType;
      }
  
      public int getWidth() {
          return width;
      }
  
      public int getHeight() {
          return height;
      }
  
      public int getDepth() {
          return depth;
      }
  
      public URI getUri() {
          return uri;
      }
  
      public byte[] getData() {
          return data;
      }
  
      public Device getDevice() {
          return device;
      }
  
      void setDevice(Device device) {
          if (this.device != null)
              throw new IllegalStateException("Final value has been set already, model is immutable");
          this.device = device;
      }
  
      public List<ValidationError> validate() {
          List<ValidationError> errors = new ArrayList<>();
  
          if (getMimeType() == null) {
              log.warning("UPnP specification violation of: " + getDevice());
              log.warning("Invalid icon, missing mime type: " + this);
          }
          if (getWidth() == 0) {
              log.warning("UPnP specification violation of: " + getDevice());
              log.warning("Invalid icon, missing width: " + this);
          }
          if (getHeight() == 0) {
              log.warning("UPnP specification violation of: " + getDevice());
              log.warning("Invalid icon, missing height: " + this);
          }
          if (getDepth() == 0) {
              log.warning("UPnP specification violation of: " + getDevice());
              log.warning("Invalid icon, missing bitmap depth: " + this);
          }
  
          if (getUri() == null) {
              errors.add(new ValidationError(
                      getClass(),
                      "uri",
                      "URL is required"
              ));
          } else {
          	try {
          		URL testURI = getUri().toURL();
          		if (testURI == null)
          			throw new MalformedURLException();
          	} catch (MalformedURLException ex) {
          		errors.add(new ValidationError(
          				getClass(),
          				"uri",
          				"URL must be valid: " + ex.getMessage())
          				);
          	} catch (IllegalArgumentException ex) {
          		// Relative URI is fine here!
          	}
          }
  
          return errors;
      }
  
      public Icon deepCopy() {
          return new Icon(
                  getMimeType(),
                  getWidth(),
                  getHeight(),
                  getDepth(),
                  getUri(),
                  getData()
          );
      }
  
      @Override
      public String toString() {
          return "Icon(" + getWidth() + "x" + getHeight() + ", MIME: " + getMimeType() + ") " + getUri();
      }
  }