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

  * MosaicsDaoJdbc.java - Implement the Dao interface for the Mosaics

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2006 - Dick Balaska

  * 

  */ 

 package com.buckosoft.PicMan.db;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.sql.Types;

 import java.util.List;

 import javax.sql.DataSource;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.springframework.dao.DataAccessException;

 import org.springframework.jdbc.core.SqlParameter;

 import org.springframework.jdbc.object.MappingSqlQuery;

 import org.springframework.jdbc.object.SqlFunction;

 import org.springframework.jdbc.object.SqlUpdate;

 import com.buckosoft.PicMan.domain.Mosaic;

 /** Implement the Dao Interface for the {@link com.buckosoft.PicMan.domain.Mosaic}s.

  * @author Dick Balaska

  * @since 2008/02/14

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

  */

 public class MosaicsDaoJdbc implements MosaicsDao {

         private static final boolean DEBUG = true;

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

         private DataSource ds;

         /** Set the reference to the JDBC datasource.

          * @param ds The datasource as configured by Spring.

          * @see <a href="http://cvs.buckosoft.com/Projects/java/PicMan/PicMan/WebContent/WEB-INF/picManDatabase/picManDatabase.xml">picManDatabase.xml</a>

          */ 

         public void setDataSource(DataSource ds) {

                 this.ds = ds;

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.MosaicsDao#getMosaic(int)

          */

         public Mosaic getMosaic(int mid) {

                 if (DEBUG)

                         logger.info("getMosaic: " + mid);

                 if (sql_getMosaicQUERY == null)

                         sql_getMosaicQUERY = new MosaicsQuery(ds, mid);

         Mosaic m = (Mosaic)sql_getMosaicQUERY.findObject(mid);

                getMosaicConfig(m);

         return(m);

         }

         private        MosaicsQuery        sql_getMosaicQUERY = null;

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.MosaicsDao#getMosaic(java.lang.String, java.lang.String, int, int)

          */

         public Mosaic getMosaic(String masterPic, String engine, int sid, int tileHeight) {

                 if (sql_getMosaicUniQUERY == null)

                         sql_getMosaicUniQUERY = new MosaicsQuery(ds, masterPic, engine, sid, tileHeight);

                 Mosaic m = (Mosaic)sql_getMosaicUniQUERY.findObject(new Object[] {masterPic, engine, new Integer(sid), new Integer(tileHeight)});

                getMosaicConfig(m);

         return(m);

         }

         private        MosaicsQuery        sql_getMosaicUniQUERY = null;

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.MosaicsDao#getMosaics()

          */

         @SuppressWarnings("unchecked")

         public List<Mosaic> getMosaics() {

                 if (DEBUG)

                         logger.info("GetMosaicsList");

                 if (sql_getMosaicsListQUERY == null)

                         sql_getMosaicsListQUERY = new MosaicsQuery(ds);

                 List<Mosaic> mosaicList = (List<Mosaic>)sql_getMosaicsListQUERY.execute();

                 for (Mosaic m : mosaicList)

                         this.getMosaicConfig(m);

                 return(mosaicList);

         }

         private        MosaicsQuery        sql_getMosaicsListQUERY = null;

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.MosaicsDao#deleteMosaic(int)

          */

         public void deleteMosaic(int mid) {

                 if (DEBUG)

                         logger.info("deleteMosaic");

                 // TODO deleteMosaic not implemented

                 throw new RuntimeException("Not implemented");

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.MosaicsDao#storeMosaic(com.buckosoft.PicMan.domain.Mosaic)

          */

         public void storeMosaic(Mosaic mosaic) {

                 if (DEBUG)

                         logger.info("storeMosaic " + mosaic.getMid());

                 if (mosaic.getMid() <= 0) {

                         MosaicsInsert mi = new MosaicsInsert(ds);

                         mi.insert(mosaic);

                         int c = getMosaicCount();

                         mosaic.setMid(c);

                 } else {

                         MosaicsUpdate mu = new MosaicsUpdate(ds);

                         mu.update(mosaic);

                 }

                 deleteMosaicConfigs(mosaic.getMid());

                 if (sql_storeMosaicConfigsINSERT == null)

                         sql_storeMosaicConfigsINSERT = new MosaicConfigsInsert(ds);

                 for (String key : mosaic.getEngineConfig().keySet()) {

                         sql_storeMosaicConfigsINSERT.insert(mosaic.getMid(), key, mosaic.getEngineConfig().get(key));

                 }

         }

         private        MosaicConfigsInsert        sql_storeMosaicConfigsINSERT = null;

         /** Get the number of Virgins in the database

          * @return the count

          */

         public int        getMosaicCount() {

                 if (DEBUG)

                         logger.info("getVirginCount:");

                 if (sql_getMosaicCountQUERYr == null)

                         sql_getMosaicCountQUERYr = new MosaicsCount(ds);

                 return(sql_getMosaicCountQUERYr.run());

         }

         private MosaicsCount        sql_getMosaicCountQUERYr;

         @SuppressWarnings("unchecked")

         private        void getMosaicConfig(Mosaic mosaic) {

                 if (mosaic == null)

                         return;

                 if (sql_getMosaicConfigQUERY == null)

                         sql_getMosaicConfigQUERY = new MosaicConfigsQuery(ds, 0);

                 List<KeyValue>kvlist = (List<KeyValue>)sql_getMosaicConfigQUERY.execute(mosaic.getMid());

                 for (KeyValue kv : kvlist) {

                         mosaic.getEngineConfig().put(kv.key, kv.value);

                 }

         }

         private        MosaicConfigsQuery        sql_getMosaicConfigQUERY = null;

         private void deleteMosaicConfigs(int sid) throws DataAccessException {

                 MosaicConfigsDelete msd = new MosaicConfigsDelete(ds);

                 msd.delete(sid);

         }

         /**

          * Object to Query for Mosaics

          */

         private class MosaicsQuery extends MappingSqlQuery {

                 MosaicsQuery(DataSource ds) {

                         super(ds, "SELECT * from mosaics");

                         compile();

                 }

                 MosaicsQuery(DataSource ds, int mid) {

                         super(ds, "SELECT * from mosaics where mid = ?");

                         declareParameter(new SqlParameter(Types.INTEGER));

                         compile();

                 }

                 MosaicsQuery(DataSource ds, String masterPic, String engine, int sid, int tileHeight) {

                         super(ds, "SELECT * from mosaics where masterPic = ? AND engine = ? AND sid = ? AND tileHeight = ? LIMIT 1");

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.INTEGER));

                         declareParameter(new SqlParameter(Types.INTEGER));

                         compile();

                 }

                 protected Object mapRow(ResultSet rs, int rowNum) throws SQLException {

                         Mosaic m = new Mosaic();

                         m.setMid(rs.getInt("mid"));

                         m.setBatch(rs.getBoolean("isBatch"));

                         m.setName(rs.getString("name"));

                         m.setEngine(rs.getString("engine"));

                         m.setMasterPic(rs.getString("masterPic"));

                         m.setOutPic(rs.getString("outPic"));

                         m.setSid(rs.getInt("sid"));

                         m.setTileHeight(rs.getInt("tileHeight"));

                         try {

                                 m.setStartTime(rs.getDate("startTime"));

                         } catch (Exception e) {logger.info(e);}

                         return(m);

                 }

         }

         /**

          * <code>Virgin</code> Count Object.

          */

         class MosaicsCount extends SqlFunction {

                 MosaicsCount(DataSource ds) {

                         super(ds, "SELECT COUNT(*) from mosaics");

                         compile();

                 }                

         }

         /**

          * <code>Mosaic</code> Insert Object.

          */

         private class MosaicsInsert extends SqlUpdate {

                 /**

                  * Create a new instance of MosaicsInsert.

                  * @param ds the DataSource to use for the insert

                  */

                 protected MosaicsInsert(DataSource ds) {

                         super(ds, "INSERT INTO mosaics VALUES(?,?,?,?,?,?,?,?,?)");

                         declareParameter(new SqlParameter(Types.INTEGER));

                         declareParameter(new SqlParameter(Types.TINYINT));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.INTEGER));

                         declareParameter(new SqlParameter(Types.INTEGER));

                         declareParameter(new SqlParameter(Types.TIMESTAMP));

                         compile();

                 }

                 protected void insert(Mosaic m) {

                         Object[] objs = new Object[] {

                                 null,

                                 new Integer(m.isBatch() ? 1 : 0), m.getName(),

                                 m.getEngine(), m.getMasterPic(), m.getOutPic(),

                                 new Integer(m.getSid()), new Integer(m.getTileHeight()),

                                 m.getStartTime()

                         };

                         super.update(objs);

                 }

         }

         ///////////////////////////////////////////////////////////////////////////////////////////////

         /**

          * <code>Mosaic</code> Update Object.

          */

         private class MosaicsUpdate extends SqlUpdate {

                 //private        DataSource        ds;

                 /**

                  * Create a new instance of MosaicsUpdate.

                  * @param ds the DataSource to use for the update

                  */

                 protected MosaicsUpdate(DataSource ds) {

                         super(ds, "UPDATE mosaics SET name=?, isBatch=?, engine=?, masterPic=?, outPic=?, sid=?, tileHeight=?, startTime=? WHERE mid = ? LIMIT 1");

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.TINYINT));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.INTEGER));

                         declareParameter(new SqlParameter(Types.INTEGER));

                         declareParameter(new SqlParameter(Types.TIMESTAMP));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         compile();

                 }

                 /**

                  * Method to update the <code>Set</code>'s data.

                  * @param List sets The sets that should be stored

                  * @return 0

                  */

                 protected int update(Mosaic m) {

                         return this.update(new Object[] {

                                         m.getName(),  new Integer(m.isBatch() ? 1 : 0),

                                         m.getEngine(), m.getMasterPic(), m.getOutPic(),

                                         new Integer(m.getSid()), new Integer(m.getTileHeight()),

                                         m.getStartTime(),

                                         new Integer(m.getMid())

                         });

                 }

         }

         private class KeyValue {

                 public String        key;

                 public String        value;

         }

         private class MosaicConfigsQuery extends MappingSqlQuery {

                 MosaicConfigsQuery(DataSource ds, int mid) {

             super(ds, "SELECT * from mosaicConfigs where mid=?");

                         declareParameter(new SqlParameter(Types.INTEGER));

             compile();

         }

         protected Object mapRow(ResultSet rs, int rowNum) throws SQLException {

                 KeyValue k = new KeyValue();

                 k.key = rs.getString("key");

                 k.value = rs.getString("value");

                 return(k);

         }

         }

         /**

          * <code>MetaSet</code> Delete Object.

          */

         protected class MosaicConfigsDelete extends SqlUpdate {

                 /**

                  * Create a new instance of MetaSetRemove.

                  * @param ds the DataSource to use for the delete

                  */

                 protected MosaicConfigsDelete(DataSource ds) {

                         super(ds, "DELETE FROM mosaicConfigs WHERE mid = (?)");

                         declareParameter(new SqlParameter(Types.INTEGER));

                         compile();

                 }

                 protected void delete(int sid) {

                         super.update(sid);

                 }

         }

         /**

          * <code>MosaicConfigs</code> Insert Object.

          */

         protected class MosaicConfigsInsert extends SqlUpdate {

                 /**

                  * Create a new instance of MetaSetInsert.

                  * @param ds the DataSource to use for the insert

                  */

                 protected MosaicConfigsInsert(DataSource ds) {

                         super(ds, "INSERT INTO mosaicConfigs VALUES(?,?,?)");

                         declareParameter(new SqlParameter(Types.INTEGER));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         declareParameter(new SqlParameter(Types.VARCHAR));

                         compile();

                 }

                 protected void insert(int sid, String key, String value) {

                         Object[] objs = new Object[] {

                                         new Integer(sid),

                                         key,

                                         value,

                         };

                         super.update(objs);

                         // retrieveIdentity(owner);

                 }

         }

 }