package com.bbn.openmap.image;

import com.bbn.openmap.Layer;
import com.bbn.openmap.MapBean;
import com.bbn.openmap.MapHandler;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.proj.ProjectionFactory;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
import java.util.ArrayList;
import javax.swing.ImageIcon;

/**
 * AbstractMapBeanPrinter is a generic class for creating print jobs
 * with MapBeans in it.  This class can be subclassed to add extra
 * printing code, for istance to add text labels, map thumbnails, or any
 * other "extra" printable in addition to the map itself.
 *
 * Any subclass must implement the print(...) method specified in interface
 * Printable.
 *
 * Subclasses may use the following functions in the implementation of the
 * print method:
 *
 * alignPaper(...) - aligns the paper so that (0,0) represents the upper left
 * corner of the printable area.
 *
 * drawMap(...) - draws the map to a specified area of the print with
 * the specified size.
 *
 * Protected variables layersToBePrinted and printProjection may also be
 * accessed, perhaps to manipulate an off-screen image.
 *
 * Modified from MapBeanPrinter.java distributed with openmap-4.6.
 *
 * @author Brian Sperlongano
 */
public abstract class AbstractMapBeanPrinter implements Printable
{
	protected Layer[] layersToBePrinted;
	protected Projection printProjection;
	
	/**
	 * Constructor
	 *
	 * @param    layersToBePrinted   Layers to print
	 * @param    printProj           Projection to print
	 *
	 */
    public AbstractMapBeanPrinter(Layer[] layersToBePrinted, Projection printProj)
	{
		this.layersToBePrinted = layersToBePrinted;
		this.printProjection = printProj;
    }
	
	/**
	 * Constructor
	 *
	 * @param    mapHandlerToBePrinted MapHandler which contains the MapBean and
	 * 									Layers to be printed.
	 *
	 */
    public AbstractMapBeanPrinter(MapHandler mapHandlerToBePrinted)
	{
		this.printProjection =
			((MapBean)(mapHandlerToBePrinted.getAll("com.bbn.openmap.MapBean")
						   .toArray()[0]))
			.getProjection().makeClone();
		
		this.layersToBePrinted =
			convertToLayers
			(mapHandlerToBePrinted.getAll("com.bbn.openmap.Layer").toArray());
    }
	
	/**
	 * Constructor
	 *
	 * @param    mapBean             MapBean to be printed
	 *
	 */
    public AbstractMapBeanPrinter(MapBean mapBean)
	{
		this.printProjection = mapBean.getProjection().makeClone();
		
		Component[] mapChildren = mapBean.getComponents();
		ArrayList mapLayerArrayList = new ArrayList();
		
		for(int i=0; i<mapChildren.length; i++)
			if(mapChildren[i] instanceof Layer)
				mapLayerArrayList.add(mapChildren[i]);
		
		this.layersToBePrinted = convertToLayers(mapLayerArrayList.toArray());
    }
	
	/**
	 * Typecasts an Object[] to a Layer[].  This function does not type check,
	 * so it assumes that each object is a valid Layer object.
	 *
	 * @param    objs                an Object[]
	 *
	 * @return   a Layer[]
	 *
	 * @version  9/24/2004
	 */
	private Layer[] convertToLayers(Object[] objs)
	{
		Layer[] mapLayerArray = new Layer[objs.length];
		
		for(int i=0; i<objs.length; i++)
			mapLayerArray[i] = (Layer)objs[i];
		
		return mapLayerArray;
	}
	
	/**
	 * Sends the print job to the printer
	 *
	 * @author Brian Sperlongano
	 */
    public void print()
	{
		PrinterJob printJob = PrinterJob.getPrinterJob();
		printJob.setPrintable(this);
		if (printJob.printDialog())
			try
			{
				printJob.print();
			}
		catch(PrinterException pe)
		{
			System.out.println("Error printing: " + pe);
		}
    }
	
	/**
	 * Aligns the Graphics object to the page's printable area.
	 *
	 * @author Brian Sperlongano
	 */
	public void alignPaper(Graphics g, PageFormat pageFormat)
	{
		g.translate((int)(pageFormat.getImageableX()),
						(int)(pageFormat.getImageableY()));
	}
	
	/**
	 * Draws a MapBean onto a Graphics object for printing.
	 *
	 * @param    g                   Graphics object to draw to
	 * @param    pageFormat          Format of the page to print to
	 * @param    x                   Image X position, percentage
	 * @param    y                   Image Y position, precentage
	 * @param    width               Image width, percentage
	 * @param    height              Image height, percentage
	 * @param    proportional        if true, aspect ratio of the MapBean will
	 * 								be maintained and will leave whitespace
	 * 								beneath the image or to the right if the
	 * 								aspect ratios are dissimilar.  If false, the
	 * 								image will scale completely
	 */
	public void drawMap(
		Graphics g, PageFormat pf, double x, double y,
		double width, double height, boolean proportional)
	{
		
		double pageHeight = pf.getImageableHeight();
		double pageWidth = pf.getImageableWidth();
		
		int imgX = (int)(x * pageWidth);
		int imgY = (int)(y * pageHeight);
		int imgW = (int)(width * pageWidth);
		int imgH = (int)(height * pageHeight);
		
		float mapRatio = (float)printProjection.getHeight() / (float)printProjection.getWidth();
		
		if(proportional)
			if(mapRatio < imgH / imgW)
				imgH *= mapRatio; //is this OK??
			else
				imgW /= mapRatio;
		
		g.drawImage
			(new ImageIcon
				 (new ImageServer
					  (layersToBePrinted, new AcmeGifFormatter())
					  .createImage
					  (ProjectionFactory.makeProjection(
						   printProjection.getProjectionType(),
						   printProjection.getCenter().getLatitude(),
						   printProjection.getCenter().getLongitude(),
						   printProjection.getScale()
							   *(float)printProjection.getHeight() / imgH,
						   imgW, imgH)))
				 .getImage(),imgX,imgY,null);
	}
}