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

  * SampleMaker.java - Make a Mosaic that shows all of the pics available in the set

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2008 - Dick Balaska

  * 

  */

 package com.buckosoft.PicMan.business.mosaic.engine;

 import java.awt.Graphics2D;

 import java.awt.image.BufferedImage;

 import java.util.Arrays;

 import java.util.List;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import com.buckosoft.PicMan.business.mosaic.MosaicEngine;

 import com.buckosoft.PicMan.domain.MosaicTile;

 import com.buckosoft.PicMan.domain.Pic;

 /** Build a mosaic that contains all of the pics in the set.  

  * This ignores the masterPic, which is just used for sizing the final.

  * @author Dick Balaska

  * @since 2008/05/28

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

  */

 public class SampleMaker extends MosaicEngine {

         private static final boolean DEBUG = true;

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

         private        int                mosaicId = 6;

         private        int                curRow = 0;

 //        private        int[]        curCols;

         private        int                curCol;

         private        int                maxRow;

         private        int                maxCol;

         private        int                p;

         private        List<Pic>        picList;

         private        String        info = "N/A";

 //        private        int[]        used;

         private        int                tileRows;

         private        String        buildStep = "Idle";

         private        int                pass = -1;

         /** Return our current build status

          * @return The status

          */

         public        String        getStatus() {

                 StringBuilder sb = new StringBuilder();

                 sb.append(buildStep);

                 sb.append(": pass=");

                 sb.append(pass);

                 if (!buildStep.equals("Calc")) {

                         sb.append(" curRow = ");

                         sb.append(curRow);

                         sb.append(" curCol = ");

                         sb.append(curCol);

                 }

                 sb.append(" p=");

                 sb.append(p);

                 return(sb.toString());

         }

         public String getInfo() {

                 return(info);

         }

         private class PicWeight implements Comparable<PicWeight> {

                 public        int                index;

                 public        long        value;

                 public int compareTo(PicWeight arg0) {

                         PicWeight pw = (PicWeight)arg0;

                         return((int)(this.value - pw.value));

                 }

         }

         protected boolean _build() {

                 Graphics2D        gd = bi.createGraphics();

                 // 75, pull from this size set even though the size calc should be able to deal with, say, a 50 and figure it out.

                 picList = pmf.getDB().getPics(this.mosaicSet, 75);

 //                LinkedList<PicWeight> lpw = new LinkedList<PicWeight>();

                 PicWeight[]        pwArray = new PicWeight[picList.size()];

                 if (DEBUG)

                         logger.info("Working from " + picList.size() + " pics");

                 maxRow = this.masterPic.getHeight();

                 maxCol = this.masterPic.getWidth();

                 tileRows = maxRow / tileHeight;

                 if (tileRows * tileHeight < maxRow)

                         tileRows++;

 //                curCols = new int[tileRows];

 //                long[]        rate = new long[picList.size()];                // rate each pic for this location

 //                                used = new int[picList.size()];                // number of times each pic is used

                 info = "tileRows=" + tileRows + " maxCol=" + maxCol + " pics=" + picList.size();

                 if (DEBUG)

                         logger.info("tileRows=" + tileRows + " rowHeight=" + tileHeight);

                 boolean workDone = true;

                 while (workDone) {

                         pass++;

                         workDone = false;

                         BufferedImage mbi;

                         int        x,y;

                         buildStep = "Calc";

                         for (p=0; p<picList.size(); p++) {

                                 pwArray[p] = new PicWeight();

                                 pwArray[p].index = p;

                                 mbi = pmf.getThumbNail(picList.get(p), tileHeight).getImage();

                                 for (x=0; x<mbi.getWidth(); x++) {

                                         for (y=0; y<mbi.getHeight(); y++) {

                                                 int mpx = mbi.getRGB(x, y);

                                                 int        ppx = 0;

                                                 pwArray[p].value += Math.abs(((mpx)&0xFF)     - ((ppx)&0xFF))     * 30;

                                                 pwArray[p].value += Math.abs(((mpx>>8)&0xFF)  - ((ppx>>8)&0xFF))  * 59;

                                                 pwArray[p].value += Math.abs(((mpx>>16)&0xFF) - ((ppx>>16)&0xFF)) * 11;

                                         }

                                 }

                         }

                         Arrays.sort(pwArray);

                         buildStep = "Draw";

                         p = 0;

                         for (curRow=0; curRow<tileRows; curRow++) {

                                 for (curCol=0; curCol<maxCol; ) {

                                         int        cr = curRow * tileHeight;

                                         int curPic = pwArray[p].index;

                                         mbi = pmf.getThumbNail(picList.get(curPic), tileHeight).getImage();

                                         if (!mosaic.isBatch()) {

                                                 MosaicTile        tile = new MosaicTile(mosaicId, picList.get(curPic).getPid(), curCol, cr, mbi.getWidth(), mbi.getHeight());

                                                 pmf.getDB().storeMosaicTile(tile);

                                         }

                                         gd.drawImage(mbi, null, curCol, cr);

                                         curCol += mbi.getWidth();

                                         setLastMosaicUpdate();

                                         if (++p >= picList.size())

                                                 p = 0;

                                 }

                         }

                 }

                 buildStep = "Done";

                 return(false);

         }

 }