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

  * MosaicSetupFormController.java - The Spring controller to edit PicMan's Mosaic setup

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2008 - Dick Balaska

  * 

  */

 package com.buckosoft.PicMan.web;

 import java.text.DecimalFormat;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Map;

 import java.util.StringTokenizer;

 import javax.servlet.http.HttpServletRequest;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.springframework.validation.BindException;

 import org.springframework.web.servlet.ModelAndView;

 import com.buckosoft.BSAccount.web.BSAccountSimpleFormController;

 import com.buckosoft.BSAccount.web.BSAccountUserWebSession;

 import com.buckosoft.PicMan.business.PicManFacade;

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

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

 import com.buckosoft.PicMan.db.DatabaseFacade;

 import com.buckosoft.PicMan.domain.Mosaic;

 import com.buckosoft.PicMan.domain.MosaicBatch;

 import com.buckosoft.PicMan.domain.User;

 import com.buckosoft.PicMan.web.MosaicSetupForm.MosaicConfig;

 /** The Spring controller to edit PicMan's Batch Mosaic setup

  * @author Dick Balaska

  * @since 2008/09/16

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

  */

 public class MosaicBatchSetupFormController extends BSAccountSimpleFormController {

         private        final static boolean DEBUG = true;

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

         private DatabaseFacade dbf;

         private PicManFacade pmf;

         /** Set the reference to the PicMan Database

          * @param dbf The DatabaseFacade

          */

         public void setDatabase(DatabaseFacade dbf) { this.dbf = dbf; }

         //public DatabaseFacade getDatabase() { return(dbf); }

         /** Set the reference to the PicMan API.

          * @param pmf The PicManFacade

          */

         public void setPicMan(PicManFacade pmf) { this.pmf = pmf; }

         //public PicManFacade getPicMan() { return(pmf); }

         public MosaicBatchSetupFormController() {

                 setSessionForm(true);

                 setValidateOnBinding(false);

                 setCommandName("mosaicSetupForm");

                 setFormView("MosaicSetupForm");

         }

         protected Object formBackingObject(HttpServletRequest request) throws Exception {

             BSAccountUserWebSession userWebSession = this.bsAccountMan.getUserWebSession(request);

             User user = (User)userWebSession.getUser();

                 if (DEBUG)

                         logger.info("formBackingObject mosaicForm with session " + userWebSession);

                 MosaicSetupForm mf = new MosaicSetupForm();

                 mf.setUserWebSession(userWebSession);

                 mf.setBatchMode(true);

                 mf.setMosaic(new Mosaic());

                 mf.setMasterPic(user.getMosaicTestPic());

                 mf.setMosaicHeight(user.getMosaicTileHeight());

                 mf.setMosaicOutputFile(user.getMosaicOutputFile());

                 mf.setSets(dbf.getSets());

 //                mf.setMosaicSetName(user.getMosaicSetName());

                 List<MosaicBatch> list = dbf.getMosaicBatches();

 /*                Iterator<Mosaic> iter = list.iterator();

                 while (iter.hasNext()) {

                         Mosaic m = iter.next();

                         if (!m.isBatch())

                                 iter.remove();

                 }

 */                Collections.sort(list);

                 mf.setMosaicBatches(list);

                 List<Mosaic> list1 = new LinkedList<Mosaic>();

                 for (MosaicBatch mb : list)

                         list1.add(mb);

                 MosaicConfig mc = MosaicSetupForm.getConfigs(list1);

                 mf.setMosaicConfigs(mc.mosaicConfig);

                 mf.setMosaicEngineConfig(mc.engineConfig);

                 mf.setEngines(mc.engines);

                 return(mf);

         }

         protected void onBindAndValidate(HttpServletRequest request, Object command, BindException errors)

                         throws Exception {

                 MosaicSetupForm msf = (MosaicSetupForm)command;

        if (DEBUG)

                 logger.info("onBindAndValidate");

                 if (request.getParameter("startBuilding") == null) {

                         msf.setStartBuilding(false);

                 } else

                         msf.setStartBuilding(true);

         }

         protected Map<String, Object> referenceData(HttpServletRequest request) throws Exception {

             BSAccountUserWebSession userWebSession = this.bsAccountMan.getUserWebSession(request);

                 Map<String, Object> myModel = new HashMap<String, Object>();

         myModel.put("userWebSession", userWebSession);

         if (DEBUG)

                 logger.info("referenceData mosaicForm with session " + userWebSession);

                 return myModel;

         }

         protected ModelAndView onSubmit(

                         HttpServletRequest request, HttpServletResponse response, Object command, BindException errors)

                         throws Exception {

                 String v;

             BSAccountUserWebSession userWebSession = this.bsAccountMan.getUserWebSession(request);

             User user = (User)userWebSession.getUser();

                 MosaicSetupForm msf = (MosaicSetupForm)command;

                 boolean userSettingsModified = false;

                 boolean success = true;

                 MosaicBatch mbatch = pmf.getDB().getMosaicBatch(msf.getMosaic().getMid());

                 if (mbatch == null)

                         mbatch = new MosaicBatch();

                 mbatch.setName(msf.getMosaic().getName());

                 mbatch.setMasterPic(msf.getMasterPic());

                 mbatch.setSid(msf.getMosaicSid());

                 mbatch.setEngine(msf.getMosaicEngineName());

                 mbatch.setSizes(msf.getMosaicSizes());

                 //mosaic.setTileHeight(msf.getMosaicHeight());

                 mbatch.setOutPic(msf.getMosaicOutputFile());

                 mbatch.setBatch(true);

                 HashMap<String, String> engineConfig = mbatch.getEngineConfig();

                 engineConfig.clear();

                 String n = msf.getMosaicEngineName();

                 if (n != null && n.length() > 0) {

                         MosaicEngine mosaicEngine = null;

                         try {

                                 mosaicEngine = (MosaicEngine)Class.forName("com.buckosoft.PicMan.business.mosaic.engine."

                                                                 + n).newInstance();

                         } catch (Exception e) {

                                 Exception ex = new Exception("Can't instantiate Mosaic Engine: " + n, e);

                                 pmf.addError(ex);

                                 logger.error(ex);

                         }

                         if (mosaicEngine != null) {

                                 HashMap<String, ConfigItem> configMap = mosaicEngine.getConfigMap();

                                 if (!configMap.isEmpty()) {

                                         for (String key : configMap.keySet()) {

                                                 //ConfigItem item = configMap.get(key);

                                                 if ((v = request.getParameter(key)) != null) {

                                                         engineConfig.put(key, v);

                                                         logger.info("put k=" + key + " v=" + v);

                                                 }

                                         }

                                 }

                         }

                 }

                 pmf.getDB().storeMosaicBatch(mbatch);

                 if (user.getMosaicTestPic() != msf.getMasterPic()) {

                         user.setMosaicTestPic(msf.getMasterPic());

                         userSettingsModified = true;

                 }

                 if (userSettingsModified)

                         this.dbf.storeUser(user);

                 if (msf.isStartBuilding()) {

                         //pmf.getMosaicMan().queueForBuilding(mbatch);

                         success = startBuilding(mbatch, errors);

                 }

                 if (success && !response.isCommitted()) {

                         response.sendRedirect("mosaicBatchSetup.do");

                         return(null);

                 }

                 else

                         return(showForm(request, response, errors));

         }

         DecimalFormat df3 = new DecimalFormat("000");

         private        boolean startBuilding(MosaicBatch mbatch, BindException errors) {

                 StringTokenizer st = new StringTokenizer(mbatch.getSizes(), ",\n\r");

                 if (DEBUG)

                         logger.info("startBuilding: sizes='" + mbatch.getSizes() + "'");

                 String range;

                 String start;

                 String end;

                 String increment;

                 ArrayList<Integer> list = new ArrayList<Integer>();

                 while (st.hasMoreTokens()) {

                         range = st.nextToken().trim();

                         increment = "1";

                         if (DEBUG)

                                 logger.info("parsing token '" + range + "'");

                         if (range.indexOf('/') != -1) {

                                 StringTokenizer sst = new StringTokenizer(range,"/");

                                 String s = sst.nextToken().trim();

                                 increment = sst.nextToken().trim();

                                 range = s.trim();

                         }

                         if (range.indexOf('-') != -1) {

                                 StringTokenizer sst = new StringTokenizer(range,"-");

                                 start = sst.nextToken().trim();

                                 end = sst.nextToken().trim();

                         } else {

                                 start = range;

                                 end = range;

                         }

                         int istart = -1;

                         int iend = -1;

                         int inc = -1;

                         try {

                                 istart = Integer.parseInt(start);

                                 iend = Integer.parseInt(end);

                                 inc = Integer.parseInt(increment);

                         } catch (NumberFormatException e) {

                                 e.printStackTrace();

                                 pmf.addError(e);

                                 errors.reject("XXX", e.getLocalizedMessage());

                                 return(false);

                         }

                         if (istart == -1 || iend == -1 || inc == -1) {

                                 errors.reject("XXX", "Nothing parsed?");

                                 return(false);

                         }

                         if (DEBUG) {

                                 logger.info("istart= " + istart);

                                 logger.info("iend  = " + iend);

                                 logger.info("inc   = " + inc);

                         }

                         if (istart <= iend) {

                                 for (int i=istart; i<=iend; i += inc)

                                         list.add(new Integer(i));

                         } else {

                                 for (int i=istart; i>=iend; i -= inc)

                                         list.add(new Integer(i));

                         }

                 }

                 Integer[] a = new Integer[list.size()];

                 list.toArray(a);

                 for (int i=0; i<a.length; i++) {

                         if (DEBUG)

                                 logger.info("Process size: " + a[i]);

 //                        Mosaic mosaic = pmf.getDB().getMosaic(mbatch.getMasterPic(), mbatch.getEngine(),

 //                          mbatch.getSid(), a[i]);

                         Mosaic mosaic = null;

                         if (mosaic == null) {

                                 mosaic = new Mosaic();

                                 mosaic.setMasterPic(mbatch.getMasterPic());

                                 mosaic.setEngine(mbatch.getEngine());

                                 mosaic.setSid(mbatch.getSid());

                                 mosaic.setTileHeight(a[i]);

                                 mosaic.setOutPic(mbatch.getOutPic() + df3.format(a[i]) + ".jpg");

                                 mosaic.setName(mbatch.getName() + df3.format(a[i]));

                                 mosaic.setEngineConfig(mbatch.getEngineConfig());

                                 mosaic.setBatch(true);

                         }

                         if (mosaic.getMid() != 0)

                                 pmf.getDB().deleteMosaicTiles(mosaic.getMid());

                         pmf.getMosaicMan().queueForBuilding(mosaic);

                 }

                 return(true);

         }

 }