package org.RConsortium.RangeWare.AppWare.AppWareApplication.OpenMapApplication.PrintUtilties;

import com.bbn.openmap.omGraphics.*;
import java.awt.*;

import com.bbn.openmap.Layer;
import com.bbn.openmap.MapBean;
import com.bbn.openmap.MapHandler;
import com.bbn.openmap.event.ProjectionEvent;
import com.bbn.openmap.layer.OMGraphicHandlerLayer;
import com.bbn.openmap.layer.link.LinkConstants;
import com.bbn.openmap.omGraphics.labeled.LabeledOMPoly;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.proj.ProjectionFactory;
import java.awt.geom.AffineTransform;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.JOptionPane;
import javax.swing.RepaintManager;

/**
 * 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 mapProjection;
	protected Container bufferContainer;
	
	/**
	 * Constructor
	 *
	 * @param    layersToBePrinted   Layers to print
	 * @param    printProj           Projection to print
	 *
	 */
    public AbstractMapBeanPrinter(Layer[] layersToBePrinted, Projection mapProj)
	{
		this.layersToBePrinted = layersToBePrinted;
		this.mapProjection = mapProj;
    }
	
	/**
	 * Constructor
	 *
	 * @param    mapHandlerToBePrinted MapHandler which contains the MapBean and
	 * 									Layers to be printed.
	 *
	 */
    public AbstractMapBeanPrinter(MapHandler mapHandlerToBePrinted)
	{
		bufferContainer = (MapBean)(
			mapHandlerToBePrinted.getAll("com.bbn.openmap.MapBean")
			.toArray()[0]);
		
		mapProjection =
			((MapBean)bufferContainer)
			.getProjection().makeClone();
		
		layersToBePrinted =
			convertToLayers
			(mapHandlerToBePrinted.getAll("com.bbn.openmap.Layer").toArray());
		
    }
	
	/**
	 * Constructor
	 *
	 * @param    mapBean             MapBean to be printed
	 *
	 */
    public AbstractMapBeanPrinter(MapBean mapBean)
	{
		bufferContainer = mapBean;
		mapProjection = 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]);
		
		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;
	}
	
	/**
	 * Aligns the Graphics object to the page's printable area.
	 *
	 * @author Brian Sperlongano
	 */
	public void alignPaper(Graphics g, PageFormat pageFormat)
	{
		((Graphics2D)g).translate(
			pageFormat.getImageableX(), 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 boolean drawMap(
		Graphics g, Rectangle bounds, boolean clip)
	{
		boolean isThisOperationOK = true;
		
		disableDoubleBuffering(bufferContainer);
		
		Projection[] projSave = new Projection[layersToBePrinted.length];
		OMGraphicList[] listSave = new OMGraphicList[layersToBePrinted.length];
		
		double imgW = bounds.getWidth();
		double imgH = bounds.getHeight();
		
		float printScale = 1.0f;
		
		float mapRatio = (float)mapProjection.getHeight() /
			(float)mapProjection.getWidth();
		
		if(clip)
			if(mapRatio < imgH / imgW)
				imgH *= mapRatio; //is this OK??
			else
				imgW /= mapRatio;
		
		try
		{
			printScale
				= Math.min((float)imgH / (float)mapProjection.getHeight(),
							  (float)imgW / (float)mapProjection.getWidth());
			
			Projection printProjection =
				ProjectionFactory.makeProjection(
				mapProjection.getProjectionType(),
				mapProjection.getCenter().getLatitude(),
				mapProjection.getCenter().getLongitude(),
				mapProjection.getScale() / printScale, (int)imgW, (int)imgH);
			
			for(int i=0; i<layersToBePrinted.length; i++)
			{
				projSave[i] = layersToBePrinted[i].getProjection();
				
				if((layersToBePrinted[i] instanceof OMGraphicHandlerLayer))
				{
					OMGraphicHandlerLayer thisLayer =
						(OMGraphicHandlerLayer)layersToBePrinted[i];
					
					layersToBePrinted[i].projectionChanged(
						new ProjectionEvent(this, printProjection));
					
					thisLayer.doPrepare();
					
					OMGraphicList thisList =
						thisLayer.prepare();
					
					if(thisList != null)
						scaleGraphics(thisList, printProjection, printScale);
					
					thisLayer.setList(thisList);
				}
				
				layersToBePrinted[i].renderDataForProjection(printProjection, g);
			}
		}
		
		catch(OutOfMemoryError e)
		{
			isThisOperationOK = false;
			System.gc();
			JOptionPane.showMessageDialog(null, "Out of memory.  Print aborted.");
		}
		
		finally
		{
			for(int i=0; i<layersToBePrinted.length; i++)
			{
				if((layersToBePrinted[i] instanceof OMGraphicHandlerLayer))
				{
					OMGraphicHandlerLayer thisLayer =
						(OMGraphicHandlerLayer)layersToBePrinted[i];
					
					OMGraphicList thisList = thisLayer.prepare();
					
					thisLayer.doPrepare();
					
					if(thisList != null)
						scaleGraphics(thisList, mapProjection, 1/printScale);
					
					thisLayer.doPrepare();
					
					if(listSave[i] != null)
						thisLayer.setList(listSave[i]);
					
					thisLayer.projectionChanged(
						new ProjectionEvent(this, projSave[i]));
				}
			}
			enableDoubleBuffering(bufferContainer);
		}
		return isThisOperationOK;
	}
	
	/**
	 * This recursive function iterates through the elements of an OMGraphicList
	 * and applies a scale factor to all stroked OMGraphic object as well as
	 * OMText objects
	 *
	 * @param    gList               an OMGraphicList to scale
	 * @param    scale               Scale factor.  1.0 is unity
	 *
	 */
	private void scaleGraphics(OMGraphicList gList, Projection printProjection, float scale)
	{
		for(Iterator i=gList.iterator(); i.hasNext(); )
		{
			OMGraphic thisObj = (OMGraphic)i.next();
			if(thisObj instanceof OMGraphicList)
				scaleGraphics((OMGraphicList)thisObj, printProjection, scale);
				
			else
			{
				/*
				 * Since we are changing the scale from what is viewed on the
				 * screen, we also have to scale the drawn elements.
				 */
				
				BasicStroke s = (BasicStroke)thisObj.getStroke();
				
				float[] dashArray = s.getDashArray();
				
				if(dashArray != null)
					for(int j=0; j<dashArray.length; j++)
						dashArray[j] *= scale;
				
				BasicStroke newStroke =
					new BasicStroke(s.getLineWidth() * scale,
						s.getEndCap(),
						s.getLineJoin(),
						s.getMiterLimit(),
						dashArray,
						s.getDashPhase() * scale);
				thisObj.setStroke(newStroke);
				
				if(thisObj instanceof OMText)
				{
					OMText thisText = (OMText)thisObj;
					thisText.setFont(scaleFont(thisText.getFont(), scale));
				}
				
				if(thisObj instanceof LabeledOMPoly)
				{
					LabeledOMPoly thisLPoly = (LabeledOMPoly)thisObj;
					thisLPoly.setFont(scaleFont(thisLPoly.getFont(), scale));
				}

				//Re-generates Lat-lon positions
				thisObj.generate(printProjection);
					
			}
		}
	}
	
	private Font scaleFont(Font dat, float scale)
	{
		return new Font(
			dat.getName(), dat.getStyle(), (int)(dat.getSize() * scale));
	}
	
	private Point scalePoint(Point dat, float scale)
	{
		Point ret = new Point();
		ret.setLocation(dat.getX()*scale, dat.getY()*scale);
		return ret;
	}
	
	private float[] scaleArray(float[] dat, float scale)
	{
		if(dat == null) return null;
		//System.out.println("scale " + scale);
		
		float[] rdat = new float[dat.length];
		
		for(int i=0; i<rdat.length; i++)
		{
			rdat[i] = scale*dat[i];
			//System.out.println("= " + dat[i] + " -> " + rdat[i]);
		}
		
		return rdat;
	}
	
	/**
	 * Method disableDoubleBuffering
	 *
	 * @param    c                   a  Component
	 *
	 */
	public static void disableDoubleBuffering(Component c)
	{
		RepaintManager currentManager = RepaintManager.currentManager(c);
		currentManager.setDoubleBufferingEnabled(false);
	}
	
	/** Re-enables double buffering globally. */
	public static void enableDoubleBuffering(Component c)
	{
		RepaintManager currentManager = RepaintManager.currentManager(c);
		currentManager.setDoubleBufferingEnabled(true);
	}
}