/******************************************************************************

  * PosterEngine.java - Base class for the plugin contact making engines

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2012 - Dick Balaska

  * 

  */

 package com.buckosoft.PicMan.business.contact;

 import java.awt.BasicStroke;

 import java.awt.Color;

 import java.awt.Font;

 import java.awt.Graphics2D;

 import java.awt.RenderingHints;

 import java.awt.geom.Rectangle2D;

 import java.awt.image.BufferedImage;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.LinkedList;

 import java.util.List;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import com.buckosoft.PicMan.domain.MosaicTile;

 import com.buckosoft.PicMan.domain.Pic;

 import com.buckosoft.PicMan.domain.Poster;

 import com.buckosoft.PicMan.domain.PosterParams;

 import com.buckosoft.PicMan.domain.Thumbnail;

 /** Extend ContactEngine to build Posters

  * @author Dick Balaska

  * @since 2012/08/17

  * @see <a href="http://cvs.buckosoft.com/Projects/PicMan/PicMan/src/main/java/com/buckosoft/PicMan/business/contact/PosterEngine.java">PosterEngine.java</a>

  */

 public class PosterEngine extends ContactEngine {

         private final Log log = LogFactory.getLog(getClass());

         private        PosterParams pp;

         protected class WorkTile implements Comparable<WorkTile> {

                 WorkTile(int pid, double x, double y, double w, double h) {

                         this.pid = pid; this.x = x; this.y = y; this.w = w; this.h = h;

                 }

                 int pid;

                 double        x;

                 double        y;

                 double        w;

                 double        h;

                 @Override

                 public int compareTo(WorkTile wt) {

                         if (wt.x > this.x) return -1;

                         if (wt.x < this.x) return 1; 

                         return(0);

                 }

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.business.contact.ContactEngine#_makeContact()

          */

         @Override

         protected boolean _makeContact() {

                 pp = (PosterParams)contactParams;

                 Poster p = pp.getPoster();

                 int prWidth  = (int)(p.getPaperWidth()  * p.getDpi());

                 int prHeight = (int)(p.getPaperHeight() * p.getDpi());

                 log.info("_makeContact: prWidth = " + prWidth + " prHeight = " + prHeight);

 //                int        leftMargin = p.getMarginL();

                 int        topMargin = p.getMarginT();

                 BufferedImage bi = new BufferedImage(prWidth+p.getOverSprayL()+p.getOverSprayR(), prHeight+p.getOverSprayT()+p.getOverSprayB(), BufferedImage.TYPE_3BYTE_BGR);

                 Graphics2D         g = bi.createGraphics();

                 log.info("_makeContact: actual width = " + bi.getWidth() + " height = " + bi.getHeight());

                 g.setColor(Color.white);

                 g.fillRect(0, 0, bi.getWidth(), bi.getHeight());

                 if (pp.isCalibration()) {

                         return(makeCalibrationSheet(pp, bi, g));

                 }

                 cPath = p.getOutputPath() + pp.getSheetXY().y + "_" + pp.getSheetXY().x;

                 List<MosaicTile> mtList = pmf.getDB().getMosaicTiles(p.getMasterMid());

                 List<WorkTile> workList = new LinkedList<WorkTile>();

                 for (MosaicTile mt : mtList)

                         workList.add(new WorkTile(mt.getPid(), mt.getX()* p.getMultiplier(), mt.getY()*p.getMultiplier(),

                                                                           mt.getWidth()*p.getMultiplier(), mt.getHeight()*p.getMultiplier()));

                 double tileHeight = workList.get(0).h;                        // All tiles are the same height

                 pmf.setupMosaicThumbCache(0, (int)tileHeight);

                 int startX = pp.getGeneratedOffsetXY().x;

                 int endX = pp.getGeneratedOffsetXY().x + (int)((p.getPaperWidth() * p.getDpi()));

                 int startY = pp.getGeneratedOffsetXY().y;

                 int endY = pp.getGeneratedOffsetXY().y + (int)((p.getPaperHeight() * p.getDpi()));

                 log.info("startXY=" + startX + "/" + startY + "  endXY=" + endX + "/" + endY);

 //                boolean firstRow = true;

                 int        x;

                 int        y;

                 int debugY;

                 for (y = 0, debugY=0; y<prHeight+tileHeight; debugY++) {

                         log.debug("************ row " + debugY);

                         List<WorkTile> wlist = getListForY(workList, y+startY+topMargin);

                         Iterator<WorkTile> iter = wlist.iterator();

                         WorkTile wt = null;

 //                        x = leftMargin;

                         x = 0;

                         log.debug("Check x = " + startX);

                         while (iter.hasNext()) {

                                 WorkTile w = iter.next();

                                 log.debug("tile? " + w.pid + " " + w.x + "/" + w.y);

                                 if (w.x <= startX && w.x+w.w >= startX

                                  || startX < 0) {

                                         wt = w;

                                         x = (int)(w.x-startX);

                                         log.debug("Got one " + w.pid);

                                         break;

                                 }

                         }

                         while (wt != null) {

                                 Pic pic = this.pmf.getDB().getPic(wt.pid);

                                 Thumbnail tn = this.pmf.getMosaicThumbNail(pic, (int)tileHeight);

                                 g.drawImage(tn.getImage(), null, (int)wt.x-startX, (int)wt.y-startY);

                                 log.debug("draw " + wt.pid + " (x=" + x + ") " + (wt.x-startX) + "/" + (wt.y-startY) + " tW=" + tn.getImage().getWidth() + " " + pic.getName());

                                 x += tn.getImage().getWidth();

                                 if ((wt.x-startX+tn.getImage().getWidth()) > (p.getPaperWidth() * p.getDpi())+ p.getMarginR())

                                         break;

                                 if (!iter.hasNext())

                                         break;

                                 wt = iter.next();

                         }

                         y+=tileHeight;

                 }

                 // trim the pic with a border

                 g.setColor(Color.white);

                 if (startX < 0) {        // left border

                         g.fillRect(0, 0, -startX, bi.getHeight());

                 }

                 if (startY < 0) {        // top border

                         g.fillRect(0, 0, bi.getWidth(), -startY);

                 }

                 x = (int)(p.getProjectWidth()*p.getDpi());

                 if (x < endX ) {        // right border

                         g.fillRect(prWidth-(endX-x), 0, endX-x+p.getMarginR(), bi.getHeight());

                 }

                 y = (int)(p.getProjectHeight()*p.getDpi());

                 if (y < endY) {                // bottom border

                         g.fillRect(0, prHeight-(endY-y), bi.getWidth(), endY-y);

                 }

                 boolean success = writePic(bi, true);

                 return(success);

         }

         private        List<WorkTile> getListForY(List<WorkTile> wlist, double y) {

                 List<WorkTile> l = new LinkedList<WorkTile>();

                 for (WorkTile wt : wlist) {

                         if (wt.y <= y && wt.y+wt.h >y)

                                 l.add(wt);

                 }

                 Collections.sort(l);

                 return(l);

         }

         /* ======================================================================================== */

         final static float dash1[] = {20.0f};

     final static BasicStroke dashed =

         new BasicStroke(1.0f,

                         BasicStroke.CAP_BUTT,

                         BasicStroke.JOIN_MITER,

                         20.0f, dash1, 0.0f);

         private        boolean makeCalibrationSheet(PosterParams pp, BufferedImage bi, Graphics2D g) {

                 Poster p = pp.getPoster();

                 cPath = p.getOutputPath() + "calibration";

                 int cWidth  = bi.getWidth();

                 int cHeight = bi.getHeight();

                 int        lMargin = p.getMarginL();

                 int        tMargin = p.getMarginT();

                 int        rMargin = p.getMarginR();

                 int        bMargin = p.getMarginB();

                 g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);

                 g.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);

                 g.setColor(Color.red);

                 drawRect(p, bi, g, 0);

                 g.setColor(Color.green);

                 drawRect(p, bi, g, 3);

                 int        lowHint = 0;

                 int        highHint = 100;

                 int        step = 5;

                 int        numSteps = (highHint-lowHint)/step;

                 int stepHeight = cHeight/2/numSteps;

                 int        stepWidth = cWidth/2/numSteps;

                 log.info("numSteps=" + numSteps + " stepHeight=" + stepHeight + " stepWidth=" + stepWidth);

                 Font font = new Font(Font.SANS_SERIF, Font.PLAIN, 48);

                 Rectangle2D frect = font.getStringBounds("00", g.getFontRenderContext());

 //                LineMetrics lm = font.getLineMetrics("00", g.getFontRenderContext());

 //                int baseline = (int)Math.round(lm.getHeight()/2);

                 int baseline = (int)Math.round(frect.getHeight()/2);

                 int fWidth = (int)Math.round(frect.getHeight()+3);

                 g.setFont(font);

                 for (int curStep = 0; curStep<numSteps; curStep++) {

                         int curX = curStep*step;

                         int startY = stepHeight*curStep;

                         int endY =  startY+stepHeight;

                         g.setColor(Color.black);

                         g.drawLine(curX, startY, curX, endY);

                         g.drawString("" + curX, curX+3, endY-baseline);

                         g.drawLine(curX, cHeight-startY, curX, cHeight-endY);

                         g.drawString("" + curX, curX+3, cHeight-startY-baseline);

                         g.drawLine(cWidth-curX, startY, cWidth-curX, endY);

                         g.drawString("" + curX, cWidth-curX-fWidth, endY-baseline);

                         g.drawLine(cWidth-curX, cHeight-startY, cWidth-curX, cHeight-endY);

                         g.drawString("" + curX, cWidth-curX-fWidth, cHeight-startY-baseline);

                         int y = curX;

                         int x = curStep*stepWidth;

                         g.drawLine(x, y, x+stepWidth, y);

                         g.drawString("" + y, (int)(x+(stepWidth/2)-frect.getCenterX()), (int)(y+frect.getHeight() + 3));

                         g.drawLine(cWidth-x, y, cWidth-x-stepWidth, y);

                         g.drawString("" + y, (int)(cWidth-x-(stepWidth/2)-frect.getCenterX()), (int)(y+frect.getHeight() + 3));

                         g.drawLine(x, cHeight-y, x+stepWidth, cHeight-y);

                         g.drawString("" + y, (int)(x+(stepWidth/2)-frect.getCenterX()), (int)(cHeight-y-3));

                         g.drawLine(cWidth-x, cHeight-y, cWidth-x-stepWidth, cHeight-y);

                         g.drawString("" + y, (int)(cWidth-x-(stepWidth/2)-frect.getCenterX()), (int)(cHeight-y-3));

                 }

                 g.setStroke(dashed);

                 g.setColor(Color.black);

                 g.drawLine(lMargin, tMargin,                         cWidth-rMargin, cHeight-bMargin);

                 g.drawLine(lMargin, cHeight-bMargin,        cWidth-rMargin, tMargin);

                 boolean success = writePic(bi, true);

                 return(success);

         }

         private void drawRect(Poster p, BufferedImage bi, Graphics2D g, int offset) {

                 int cWidth  = bi.getWidth();

                 int cHeight = bi.getHeight();

                 int        lMargin = p.getMarginL();

                 int        tMargin = p.getMarginT();

                 int        rMargin = p.getMarginR();

                 int        bMargin = p.getMarginB();

                 g.drawRect(lMargin + offset, tMargin+offset, cWidth-lMargin-rMargin-(offset*2)-1, cHeight-tMargin-bMargin-(offset*2)-1);

         }

 }