/**
    *    Copyright 2009 Webster Smalley
    *
    *   Licensed 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 com.webstersmalley.watermarker;
  
  import java.awt.AlphaComposite;
  import java.awt.Color;
  import java.awt.Font;
  import java.awt.FontMetrics;
  import java.awt.Graphics2D;
  import java.awt.geom.Rectangle2D;
  import java.awt.image.BufferedImage;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.Properties;
  
  import javax.swing.UIManager;
  import javax.swing.UnsupportedLookAndFeelException;
  
  import com.sun.image.codec.jpeg.JPEGCodec;
  import com.sun.image.codec.jpeg.JPEGImageDecoder;
  import com.sun.image.codec.jpeg.JPEGImageEncoder;
  
  /**
   * @author Matthew Smalley
   * 
   */
  public class WaterMarker {
  	
  	static {
  		try {
  			UIManager.setLookAndFeel(
  			        UIManager.getSystemLookAndFeelClassName());
  		} catch (ClassNotFoundException e) {
  			e.printStackTrace();
  		} catch (InstantiationException e) {
  			e.printStackTrace();
  		} catch (IllegalAccessException e) {
  			e.printStackTrace();
  		} catch (UnsupportedLookAndFeelException e) {
  			e.printStackTrace();
  		}
  
  	}
  	
  	private ProgressBar pb = new ProgressBar();
  
  	// Default Configuration
  	private String watermarkText = "Copyright (c) 2009 Webster-Smalley"; // Tahoma - 933x64 @ size 50.
  	private Color textForegroundColour = Color.BLUE;
  	private Color textBackgroundColour = Color.BLACK;
  	private int fontScaling = 3;
  	private String fontName = "Tahoma";
  	private float fontAlpha = 0.2f;
  	
  	
  	
  	private BufferedImage loadImage(String filename) {
  		// Create BufferedImage
  		BufferedImage bi = null;
  		try {
  			// load file from disk using Sun's JPEGIMageDecoder
  			FileInputStream fis = new FileInputStream(filename);
  			JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(fis);
  			bi = decoder.decodeAsBufferedImage();
  			fis.close();
  		} catch (Exception e) {
  			throw new RuntimeException("Error loading image", e);
  		}
  		return bi;
  	}
  
  	public void addWaterMarkToFolder(String inputFoldername, String outputFoldername, boolean recurse) throws IOException {
  		File folder = new File(inputFoldername);
  		File[] children = folder.listFiles();
  		
  		pb.show();
  		
  		pb.incrementJobCount(children.length);
  		
  		for (File child: children) {
  			pb.setCurrentJobName(child.getAbsolutePath());
 
 			if (child.isDirectory() && recurse) {
 				addWaterMarkToFolder(child.getAbsolutePath(), outputFoldername + File.separator + child.getName(), true);
 			} else if (child.getName().toLowerCase().endsWith(".jpg")) {
 				addWaterMark(child.getAbsolutePath(), outputFoldername + File.separator + child.getName());
 			}
 			pb.postCompletion();
 		}
 	}
 	
 	public void addWaterMark(String inputFilename, String outputFilename) throws IOException {
 		BufferedImage bi = loadImage(inputFilename);
 		
 		int imageWidth = bi.getWidth();
 		int imageHeight = bi.getHeight();
 		
 		int fontSize = (imageWidth / 90) * fontScaling;
 		if ((imageHeight / 48) * fontScaling < fontSize) {
 			fontSize = (imageHeight / 48) * fontScaling;
 		}
 		
 		Font fnt = new Font(fontName, Font.BOLD, fontSize);
 
 		Graphics2D g2d = (Graphics2D) bi.createGraphics();
 
 		FontMetrics fm = g2d.getFontMetrics(fnt);
 		Rectangle2D stringBound = fm.getStringBounds(watermarkText, g2d);
 		int textHeight = (int)(stringBound.getHeight()); 
 		int textWidth  = (int)(stringBound.getWidth());
 		int x = (imageWidth-textWidth)/2;
 		int y = (imageHeight-textHeight)/3;
 		
 		g2d.setFont(fnt);
 		g2d.setColor(textForegroundColour);
 		g2d.setBackground(textBackgroundColour);
 		g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, fontAlpha));
 		g2d.drawString(watermarkText, x, y);
 		g2d.dispose();
 
 		File outputfolder = new File(outputFilename).getParentFile();
 		if (!outputfolder.exists()) {
 			if (!outputfolder.mkdirs()) {
 				throw new RuntimeException ("Error creating folder: " + outputfolder.getAbsolutePath());
 			}
 		}
 		OutputStream os = new FileOutputStream(outputFilename);
 		JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(os);
 		encoder.encode(bi);
 		os.close();
 
 	}
 	
 	public void loadProperties(String filename) throws FileNotFoundException, IOException {
 		Properties properties = new Properties();
 		properties.load(new FileInputStream(filename));
 		
 		
 		watermarkText = properties.getProperty("watermark.text");
 		textForegroundColour = Color.decode(properties.getProperty("watermark.colour"));
 		textBackgroundColour = Color.decode(properties.getProperty("watermark.background"));
 		fontScaling = Integer.parseInt(properties.getProperty("watermark.size"));
 		fontName = properties.getProperty("watermark.font");
 		fontAlpha = Float.parseFloat(properties.getProperty("watermark.alpha"));
 	}
 	
 	public static void main(String[] args) throws Exception {
 		if (args.length != 2) {
 			System.out.println("Usage: watermarker inputfile/folder outputfolder");
 			System.exit(1);
 		}
 
 		WaterMarker wm = new WaterMarker();
 
 		if (new File("watermarker.properties").exists()) {
 			wm.loadProperties("watermarker.properties");
 		}
 		
 		File f = new File(args[0]);
 		if (f.isDirectory()) {
 			wm.addWaterMarkToFolder(args[0], args[1], true);
 		} else {
 			wm.addWaterMark(args[0], args[1]);
 		}
 		
 		System.exit(0);
 	}
 
 }