ImageController

/******************************************************************************
 * ImageController.java - The Spring controller to fetch images
 *
 * BuckoVidLib - The BuckoSoft Video Library
 * Copyright(c) 2014 - Dick Balaska
 *
 */
package com.buckosoft.BuckoVidLib.web;

import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Iterator;

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import com.buckosoft.BuckoVidLib.business.BuckoVidLib;
import com.buckosoft.BuckoVidLib.domain.VideoBase;
import com.buckosoft.BuckoVidLib.util.ConfigManager;
import com.buckosoft.BuckoVidLib.util.DomainConverter;

/** The Spring controller to fetch images (background art)
 * @author dick
 * @since 2014-10-07
 */
@Controller(value="image")
@RequestMapping("/image")
public class ImageController  {
	private final Log log = LogFactory.getLog(getClass());
	private	final String defaultBackground = "http://www.buckosoft.com/bvlib/static/defaultBackground.jpg";
	private	final String greyBackground = "http://www.buckosoft.com/bvlib/static/greyBackground.png";
	private	final String tteoacBackground = "http://www.buckosoft.com/bvlib/static/tteoacBackground.jpg";

	/** Fit the image to the window */
	public final static int bgFit = 0;
	/** Fill the window with the image */
	public final static int bgFill = 1;
	/** Plain grey background */
	public final static int bgGrey = 2;

	public final static String keyDefault = "0";
	public final static String keyNone = "1";
	public final static String keyTteoac = "2";


	@Autowired
	private BuckoVidLib		bvl;

	private	boolean	useImageCache = false;
	private	String	imageCacheBaseDir;

	/** Bean constructor - instantiated by Spring */
	public ImageController() {
		useImageCache = ConfigManager.getBoolean("BuckoVidLib.useImageCache", false);
		imageCacheBaseDir = ConfigManager.getString("BuckoVidLib.imageCacheBaseDir", "C:/configureme");
	}


	/**
	 * @param useImageCache the useImageCache to set
	 */
	public void setUseImageCache(boolean useImageCache) {
		this.useImageCache = useImageCache;
	}


	/** Fetch a background image. <br>
	 * Session parameters:
	 * <ul>
	 * <li>backgroundFit - how do we scale the image?
	 * <li>allowRestricted - Are you hunting Horcruxes?
	 * </ul>
	 * Optional Url parameters
	 * <ul>
	 * <li>w = width of image
	 * <li>h = height of image
	 * <li>a = artShow override for the fit type
	 * </ul>
	 * @param key The base36 video key
	 * @param request The request that contains the session that contains the user
	 * @param response Write the image/jpeg
	 */
	@RequestMapping("/{key}")
	public void handleRequest(@PathVariable("key") String key,
			HttpServletRequest request, OutputStream outputStream) {
//		String s = "/library/metadata/3164/art/1412661793";	// holy grail background
//		String t = "/library/metadata/3133/art/1412371407";
//		URL url = new URL("http://lamp/plex" + (key.endsWith("k") ? s : t));
		int	w = 0;
		int	h = 0;
		String s;
		int backgroundFit = bgFit;
		boolean a = false;		// running ArtShow?
		s = request.getParameter("w");
		if (s != null)
			w = Integer.parseInt(s);
		s = request.getParameter("h");
		if (s != null)
			h = Integer.parseInt(s);
		s = request.getParameter("a");
		if (s != null)
			a = true;
		log.debug("w/h = " + w + "/" + h);
		if (w > 3000 || h > 3000 || w < 0 || h < 0) {
			log.warn("BADGUY! Limiting requested image size " + w + "/" + h);
			w = 400;
			h = 400;
		}
		backgroundFit = bvl.getBackgroundFit(request, a);
		if (log.isTraceEnabled()) {
			for (Enumeration<String> e = request.getHeaderNames(); e.hasMoreElements();) {
				String ee = e.nextElement();
				String ww = request.getHeader(ee);
				log.debug("Header '" + ee + "' : '" + ww + "'");
			}
			for (Enumeration<String> e = request.getParameterNames(); e.hasMoreElements();) {
				String ee = e.nextElement();
				String ww = request.getParameter(ee);
				log.debug("Param '" + ee + "' : '" + ww + "'");
			}
		}
		VideoBase v = null;
		String printedTitle = null;
		String	backgroundUrl;
		if (key.equals("0")) {
			backgroundUrl = defaultBackground;
			backgroundFit = bgFill;				// default image (DVD rack) always fills
		} else if (key.equals("1")) {
			backgroundUrl = greyBackground;
		} else if (key.equals("2")) {
			backgroundUrl = tteoacBackground;
			backgroundFit = bgFill;				// tteoac always fills

		} else {
			boolean b = bvl.isAllowRestricted(request);
			v = bvl.getVideoBaseFromKey(DomainConverter.keyToInt(key), b);
			if (v == null) {
				log.warn("Video not found for key: " + key);
				backgroundUrl = defaultBackground;
			} else {
				printedTitle = v.getTitle() + " (" + v.getYear() + ")";
				backgroundUrl = bvl.getPlexUrl() + v.getBackgroundUrl();
			}
		}
		BufferedImage img = null;
		if (useImageCache) {
			s = imageCacheBaseDir + "/art/" + key;
			File f = null;
			try {
				f = new File(s);
			} catch (Exception e) {
				log.warn("imageController: Can't create file '" + s + "'");
				return;
			}
//			Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("jpg");
//			ImageReader reader = (ImageReader)readers.next();
			ImageReader reader = null;
			ImageInputStream iis = null;
			try {
				iis = ImageIO.createImageInputStream(f);
				log.debug("iis = " + iis);
				if (iis == null) {
					log.warn("imageController: Can't read file '" + s + "'");
					return;
				}
				Iterator<ImageReader> readers = ImageIO.getImageReaders(iis);
				reader = (ImageReader)readers.next();
				reader.setInput(iis, true);
				img = reader.read(0);
				iis.close();
			} catch (Exception e) {
				log.warn(e);
				if (reader != null)
					reader.dispose();
				img = null;
				if (iis != null) {
					try {
						iis.close();
					} catch (Exception e1) {}
				}
				log.warn("imageController: Can't create image '" + s + "'");
				return;
			}
		} else {
			// read the image from plex
			URL url;
			try {
				url = new URL(backgroundUrl);
			} catch (MalformedURLException e2) {
				log.warn("Failed to convert '" + backgroundUrl + "'");
				return;
			}
			try {
				img = ImageIO.read(url);
			} catch (Exception e1) {
				log.warn("Can't load image for " + (v != null ? v.getTitle() : "null image"));
				return;
			}
		}
		log.info("Fetch background for: " + printedTitle);
		log.debug("original image: " + img.getWidth() + "/" + img.getHeight());
		log.debug("backgroundFit = " + backgroundFit);
		if (backgroundFit != bgFit) {									// handle fill
			if (w > 1 && h > 1) {
				int	targetw;
				int	targeth;
				double wp = (double)img.getWidth() / (double)w;
				double hp = (double)img.getHeight() / (double)h;
				if (hp < wp) {
					targetw = (int)((double)img.getWidth() / hp);
					targeth = h;
				} else {
					targeth = (int)((double)img.getHeight() / wp);
					targetw = w;
				}
				log.debug("grow target: " + targetw + "/" + targeth);
				BufferedImage scaled = new BufferedImage(targetw, targeth, BufferedImage.TYPE_INT_BGR);
				Graphics2D g;
				g = scaled.createGraphics();
				g.drawImage(img.getScaledInstance(targetw, targeth, Image.SCALE_SMOOTH), null, null);
				// replace outgoing image with scaled version
				img = scaled;
				g.dispose();
				// pick an exact sized slice out of the image
				int overw = img.getWidth() - w;
				int	overh = img.getHeight() - h;
				int shiftw = (int)(Math.random()*overw);
				int shifth = (int)(Math.random()*overh);
				if (key.equals(keyTteoac)) {
					shiftw = overw/2;
					shifth = 0;
				}
				log.debug("over: " + overw + "/" + overh + " shift: " + shiftw + "/" + shifth);
				img = img.getSubimage(shiftw, shifth, w-17, h-0);
			}
		} else {													// handle fit
			if (w > 1 && h > 1) {
				int	targetw;
				int	targeth;
				int x = 0;
				int y = 0;
				double wp = (double)w / (double)img.getWidth();
				double hp = (double)h / (double)img.getHeight();
				if (hp < wp) {
					targetw = (int)((double)img.getWidth() * hp);
					targeth = (int)((double)img.getHeight() * hp);
					x = w/2 - (targetw/2);
				} else {
					targeth = (int)((double)img.getHeight() * wp);
					targetw = (int)((double)img.getWidth() * wp);
					y = h/2 - (targeth/2);
				}
				log.debug("screen: " + w + " / " + h);
				log.debug("wp = " + wp + " hp = " + hp);
				log.debug("grow target: " + targetw + "/" + targeth);
				log.debug("x/y: " + x + " / " + y);
				BufferedImage scaled = new BufferedImage(targetw, targeth, BufferedImage.TYPE_INT_BGR);
				Graphics2D g;
				g = scaled.createGraphics();
				g.drawImage(img.getScaledInstance(targetw, targeth, Image.SCALE_SMOOTH), null, null);
				// replace outgoing image with scaled version
				img = scaled;
				img = new BufferedImage(w-17, h-1, BufferedImage.TYPE_INT_BGR);
				g = img.createGraphics();
				g.setColor(Color.gray);
				g.fillRect(0, 0, w, h);

				g.drawImage(scaled, null, x, y);
				g.dispose();
				scaled = null;
			}
		}
		// Add the title to the corner
		if (printedTitle != null && printedTitle.length() > 0) {
			Graphics2D g = img.createGraphics();
			Font font = new Font("SansSerif", Font.BOLD, 30);
			Font oldFont = g.getFont();
			g.setFont(font);
			FontMetrics fm = g.getFontMetrics(font);
			int hofs = h - fm.getHeight() - 0;		// Allow for the footer bar.
			int wofs = w - fm.stringWidth(printedTitle) - 32;
			g.setColor(Color.black);
			g.drawString(printedTitle, wofs, hofs);
			g.setColor(Color.white);
			g.drawString(printedTitle, wofs-2, hofs-2);
	//		g.setColor(Color.black);
	//		g.drawString(printedTitle, wofs-2, hofs-2);
	//		g.drawString(printedTitle, wofs+2, hofs+2);
	//		g.drawString(printedTitle, wofs-2, hofs+2);
	//		g.drawString(printedTitle, wofs+2, hofs-2);
	//		g.setColor(Color.white);
	//		g.drawString(printedTitle, wofs, hofs);

			g.setFont(oldFont);
			g.dispose();
		}
		// write the image to the stream
		try {
			ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream);
			Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");
			ImageWriter writer = (ImageWriter)writers.next();
			writer.setOutput(ios);
			writer.write(img);
		} catch (IOException e) {
			log.warn("Failed to write image " + backgroundUrl);
		}
		return;
	}

	/** Read an unfiltered background image from plex. <br>
	 * This is a slimmed down version of main imageReader, with no processing.
	 * It's used to build the cache
	 * @param key The bvlKey
	 * @param outputStream
	 * @return null on success, otherwise an error message
	 */
	public String handleRequest(String key, OutputStream outputStream) {
		VideoBase v = bvl.getVideoBaseFromKey(DomainConverter.keyToInt(key), true);
		String backgroundUrl = bvl.getPlexUrl() + v.getBackgroundUrl();
		BufferedImage img = null;
		URL url;
		String s;
		try {
			url = new URL(backgroundUrl);
		} catch (MalformedURLException e2) {
			s = "Failed to convert '" + backgroundUrl + "'";
			log.warn(s);
			return(s);
		}
		try {
			img = ImageIO.read(url);
		} catch (Exception e1) {
			s = "Can't load image for " + (v != null ? v.getTitle() : "null image");
			log.warn(s);
			return(s);
		}
		try {
			ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream);
			Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");
			ImageWriter writer = (ImageWriter)writers.next();
			writer.setOutput(ios);
			writer.write(img);
		} catch (IOException e) {
			s = "Failed to write image " + backgroundUrl;
			log.warn(s);
			return(s);
		}
		return(null);
	}
}