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

  * DatabaseImpl.java - Implement the API into the PicMan database

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2005 - Dick Balaska

  * 

  */

 package com.buckosoft.PicMan.db;

 import java.text.DecimalFormat;

 import java.util.Calendar;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 import java.util.LinkedList;

 import java.util.List;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.hibernate.HibernateException;

 import org.hibernate.Session;

 import org.springframework.dao.DataAccessException;

 import com.buckosoft.PicMan.business.SetChangedListener;

 import com.buckosoft.PicMan.business.common.PicManCommonFacade;

 import com.buckosoft.PicMan.db.logic.MetaSetFilter;

 import com.buckosoft.PicMan.domain.Chain;

 import com.buckosoft.PicMan.domain.Contact;

 import com.buckosoft.PicMan.domain.Filter;

 import com.buckosoft.PicMan.domain.FilterMicroSet;

 import com.buckosoft.PicMan.domain.MetaSet;

 import com.buckosoft.PicMan.domain.MetaSetRule;

 import com.buckosoft.PicMan.domain.Mosaic;

 import com.buckosoft.PicMan.domain.MosaicBatch;

 import com.buckosoft.PicMan.domain.MosaicTile;

 import com.buckosoft.PicMan.domain.Pic;

 import com.buckosoft.PicMan.domain.Poster;

 import com.buckosoft.PicMan.domain.Root;

 import com.buckosoft.PicMan.domain.Set;

 import com.buckosoft.PicMan.domain.SetSize;

 import com.buckosoft.PicMan.domain.SyncClient;

 import com.buckosoft.PicMan.domain.SyncServer;

 import com.buckosoft.PicMan.domain.System;

 import com.buckosoft.PicMan.domain.User;

 import com.buckosoft.PicMan.domain.Virgin;

 import com.buckosoft.PicMan.domain.mosaic.MosaicVector;

 /** Implement the API into the PicMan database

  * @author Dick Balaska

  * @since 2006/07/17

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

  */

 public class DatabaseImpl implements DatabaseFacade, SetChangedListener {

         private static boolean DEBUG = false;

 //        private static boolean DEBUGMETASETS = false;

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

         private        String                        dbUser;

         private        String                        dbUrl;

         private        List<Integer>        sizes;                        // totally unflexible size list (should be a database)

         private        int[]                        sizeArray;                // easier to deal with totally unflexible size array

         private        ChainsDao                chainsDao;

         private        ContactsDao                contactsDao;

         private        FiltersDao                filtersDao;

         private        FiltersMicroSetsDao filtersMicroSetsDao;

         private        MetaSetsDao                metaSetsDao;

         private        MosaicsDao                mosaicsDao;

         private        MosaicBatchesDao mosaicBatchesDao;

         private        MosaicTilesDao        mosaicTilesDao;

         private        MosaicVectorsDao mosaicVectorsDao;

         private        PicsDao                        picsDao;

         private        PostersDao                postersDao;

         private        RootsDao                rootsDao;

         private        Server_SyncDao        server_SyncDao;

         private        SystemDao                systemDao;

         private        SetsDao                        setsDao;

         private        SetTimestampsDao setTimestampsDao;

         private        UsersDao                usersDao;

         private VirginsDao                virginsDao;

         private        MetaSetFilter        metaSetFilter = new MetaSetFilter();

         // XXX: This should be extended to support multiple users

         private class HomeThumbAttr {

                 String                        homeThumbsForUserSetCached = "";

                 List<String>        homeThumbsForUser = null;

                 User                        homeThumbsUser = null;

                 int                                homeThumbsUserIndex = 0;

         }

         HomeThumbAttr homeThumbAttr = new HomeThumbAttr();

         PicManCommonFacade pmcf;

         DatabaseImpl() {

                 this.metaSetFilter.setDatabase(this);

                 sizes = new LinkedList<Integer>();

                 sizes.add(new Integer(75));

                 sizes.add(new Integer(100));

                 sizes.add(new Integer(150));

                 sizes.add(new Integer(200));

                 sizes.add(new Integer(300));

                 sizeArray = new int[5];

                 sizeArray[0] = 75;

                 sizeArray[1] = 100;

                 sizeArray[2] = 150;

                 sizeArray[3] = 200;

                 sizeArray[4] = 300;

         }

         public void setPicManCommonFacade(PicManCommonFacade picManCommonFacade) {

                 this.pmcf = picManCommonFacade;

                 this.pmcf.addSetChangedListener(this);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#setDEBUG(boolean)

          */

         public void setDEBUG(boolean debugFlag) {

                 DEBUG = debugFlag;

         }

         //-------------------------------------------------------------------------

         // Setter methods for dependency injection

         //-------------------------------------------------------------------------

         /** AOP setter for the ChainsDao

          * @param chainsDao The ChainsDao from the Spring Database Setup

          */

         public void setChainsDao(ChainsDao chainsDao) {

                 this.chainsDao = chainsDao;

         }

         /** AOP setter for the ContactsDao

          * @param contactsDao The ContactsDao from the Spring Database Setup

          */

         public void setContactsDao(ContactsDao contactsDao) {

                 this.contactsDao = contactsDao;

         }

         /** AOP setter for the FiltersDao

          * @param filtersDao The FiltersDao from the Spring Database Setup

          */

         public void setFiltersDao(FiltersDao filtersDao) {

                 this.filtersDao = filtersDao;

         }

         /** AOP setter for the FiltersMicroSetsDao

          * @param filtersMicroSetsDao The FiltersMicroSetsDao from the Spring Database Setup

          */

         public void setFiltersMicroSetsDao(FiltersMicroSetsDao filtersMicroSetsDao) {

                 this.filtersMicroSetsDao = filtersMicroSetsDao;

         }

         /** AOP setter for the MetaSetsDao

          * @param metaSetsDao The MetaSetsDao from the Spring Database Setup

          */

         public void setMetaSetsDao(MetaSetsDao metaSetsDao) {

                 this.metaSetsDao = metaSetsDao;

         }

         /** AOP setter for the MosaicTilesDao

          * @param mosaicTilesDao The MosaicTilesDao from the Spring Database Setup

          */

         public void setMosaicTilesDao(MosaicTilesDao mosaicTilesDao) {

                 this.mosaicTilesDao = mosaicTilesDao;

         }

         /** AOP setter for the MosaicsDao

          * @param mosaicsDao The MosaicsDao from the Spring Database Setup

          */

         public void setMosaicsDao(MosaicsDao mosaicsDao) {

                 this.mosaicsDao = mosaicsDao;

         }

         /** AOP setter for the MosaicsDao

          * @param mosaicBatchesDao The MosaicsBatchDao from the Spring Database Setup

          */

         public void setMosaicBatchesDao(MosaicBatchesDao mosaicBatchesDao) {

                 this.mosaicBatchesDao = mosaicBatchesDao;

         }

         /** AOP setter for the MosaicVectorsDao

          * @param mosaicVectorsDao The MosaicVectorsDao from the Spring Database Setup

          */

         public void setMosaicVectorsDao(MosaicVectorsDao mosaicVectorsDao) {

                 this.mosaicVectorsDao = mosaicVectorsDao;

         }

         /** AOP setter for the PicsDao

          * @param picsDao The PicsDao from the Spring Database Setup

          */

         public void setPicsDao(PicsDao picsDao) {

                 this.picsDao = picsDao;

         }

         /** AOP setter for the PostersDao

          * @param postersDao The PostersDao from the Spring Database Setup

          */

         public void setPostersDao(PostersDao postersDao) {

                 this.postersDao = postersDao;

         }

         /** AOP setter for the RootsDao

          * @param rootsDao The RootsDao from the Spring Database Setup

          */

         public void setRootsDao(RootsDao rootsDao) {

                 this.rootsDao = rootsDao;

         }

         /** AOP setter for the Server's SyncDao

          * @param server_SyncDao The Server_SyncDao from the Spring Database Setup

          */

         public void setServer_SyncDao(Server_SyncDao server_SyncDao) {

                 this.server_SyncDao = server_SyncDao;

         }

         /** AOP setter for the SystemDao

          * @param systemDao The SystemDao from the Spring Database Setup

          */

         public void setSystemDao(SystemDao systemDao) {

                 this.systemDao = systemDao;

         }

         /** AOP setter for the SetsDao

          * @param setsDao The SetsDao from the Spring Database Setup

          */

         public void setSetsDao(SetsDao setsDao) {

                 this.setsDao = setsDao;

         }

         /** AOP setter for the SetTimestampsDao

          * @param setTimestampsDao The SetTimestampsDao from the Spring Database Setup

          */

         public void setSetTimestampsDao(SetTimestampsDao setTimestampsDao) {

                 this.setTimestampsDao = setTimestampsDao;

         }

         /** AOP setter for the UsersDao

          * @param usersDao The UsersDao from the Spring Database Setup

          */

         public void setUsersDao(UsersDao usersDao) {

                 this.usersDao = usersDao;

         }

         /** AOP setter for the VirginsDao

          * @param virginsDao The VirginsDao from the Spring Database Setup

          */

         public void setVirginsDao(VirginsDao virginsDao) {

                 this.virginsDao = virginsDao;

         }

         /** Why is this public?  Because Spring was freaking out trying to reflect the type.

          * @return Our kinda private ChainsDao

          */

         public ChainsDao getChainsDao() { return(chainsDao); }

         //-------------------------------------------------------------------------

         // Operation methods, implementing the PicManFacade interface

         //-------------------------------------------------------------------------

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#setDbUser(java.lang.String)

          */

         @Override

         public void setDbUser(String dbUser) {

                 this.dbUser = dbUser;

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getDbUser()

          */

         @Override

         public String getDbUser() {

                 return(this.dbUser);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#setDbUrl(java.lang.String)

          */

         @Override

         public void setDbUrl(String dbUrl) {

                 this.dbUrl = dbUrl;

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getDbUrl()

          */

         @Override

         public String getDbUrl() {

                 return(this.dbUrl);

         }

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

          * System Management

          */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSystem()

          */

         public System getSystem() {

                 return(this.systemDao.getSystem());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#saveSystem(com.buckosoft.PicMan.domain.System)

          */

         public void saveSystem(System sys) {

                 this.systemDao.setSystem(sys);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getPicExtensions()

          */

         public List<String> getPicExtensions() {

                 return(systemDao.getSystem().getPicExtensions());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getThumbHeight()

          */

         public int        getThumbHeight() {

                 return(systemDao.getSystem().getThumbHeight());

         }

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

         /* Roots Management */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getRoots()

          */

         public List<Root> getRoots() {

                 return(rootsDao.getRoots());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getRootCount()

          */

         public        int                getRootCount() {

                 return(rootsDao.getRootCount());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getRoot(int)

          */

         public Root getRoot(int rid) {

                 return(rootsDao.getRoot(rid));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getRoot(java.lang.String)

          */

         public Root getRoot(String name) {

                 return(rootsDao.getRoot(name));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#setRoots(java.util.List)

          */

         public void setRoots(List<Root> roots) {

                 this.rootsDao.setRoots(roots);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#addRoot(com.buckosoft.PicMan.domain.Root)

          */

         public void addRoot(Root r) {

                 int count = rootsDao.getRootCount();

                 r.setRid(count+1);

                 rootsDao.addRoot(r);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#storeRoot(com.buckosoft.PicMan.domain.Root)

          */

         public        void        storeRoot(Root root) {

                 rootsDao.storeRoot(root);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#deleteRoot(com.buckosoft.PicMan.domain.Root)

          */

         public void deleteRoot(Root root) {

                 rootsDao.deleteRoot(root);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getInactiveRoots()

          */

         public List<Root> getInactiveRoots() {

                 return(rootsDao.getInactiveRoots());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getActiveRoots()

          */

         public List<Root> getActiveRoots() {

                 return(rootsDao.getActiveRoots());

         }

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

         /* Sets Management */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSets()

          */

         public List<Set> getSets() {

                 return(setsDao.getSets());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSetsClone()

          */

         public List<Set> getSetsClone() {

                 return(setsDao.getSetsClone());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSetCount()

          */

         public        int                getSetCount() {

                 return(setsDao.getSetCount());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSet(int)

          */

         public        Set                getSet(int sid) {

                 return(setsDao.getSet(sid));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSet(java.lang.String)

          */

         public        Set                getSet(String setName) {

                 return(setsDao.getSet(setName));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#setSets(java.util.List)

          */

         public void setSets(List<Set> sets) {

                 this.setsDao.setSets(sets);

         }

         /** Add a new set to the database.

          * @param s The Set to add.  The sid should be 0.

          */

         public void addSet(Set s) {

 //                int count = setsDao.getSetCount();

 //                s.setSid(count+1);

                 s.setSid(0);

                 setsDao.addSet(s);

                 s = setsDao.getSet(s.getName());

                 if (!s.isMetaSet() && !s.isMicroSet() && !s.isNanoSet()) {

                         List<Integer> l = getSizes();

                         Iterator<Integer> it = l.iterator();

                         while (it.hasNext()) {

                                 Integer i = (Integer)it.next();

                                 filtersDao.addSet(s.getName(), i.intValue());

                         }

                 }

         }

         /** Store an existing set to the database.

          * @param set The set to store.  The sid should NOT be 0.

          */

         public        void        storeSet(Set set) {

                 if (!set.isMetaSet() && !set.isMicroSet() && !set.isNanoSet()) {

                         Set s1 = getSet(set.getSid());

                         if (!set.getName().equals(s1.getName())) {                // renaming a set...

                                 List<Integer> l = getSizes();

                                 Iterator<Integer> it = l.iterator();

                                 while (it.hasNext()) {

                                         Integer i = (Integer)it.next();

                                         filtersDao.renameSet(s1.getName(), set.getName(), i.intValue());

                                 }

                         }

                 }

                 setsDao.storeSet(set);

         }

         /** Delete this set from the database.

          * @param s The set to delete.

          */

         public void deleteSet(Set s) {

                 List<Integer> l = getSizes();

                 Iterator<Integer> it = l.iterator();

                 while (it.hasNext()) {

                         Integer i = (Integer)it.next();

                         filtersDao.deleteSet(s.getName(), i.intValue());

                 }

                 setsDao.deleteSet(s);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#renameSet(java.lang.String, java.lang.String)

          */

         public void renameSet(String oldName, String newName) {

                 Set set = this.getSet(oldName);

                 List<Chain> clist = this.getChains();

                 for (Chain c : clist) {

                         boolean modified = false;

                         List<SetSize> slist = c.getSetSizes();

                         Iterator<SetSize> siter = slist.iterator();

                         while (siter.hasNext()) {

                                 SetSize ss = siter.next();

                                 if (ss.getSetName().equals(oldName)) {

                                         modified = true;

                                         ss.setSetName(newName);

                                 }

                         }

                         if (modified) {

                                 this.storeChain(c);

                         }

                 }

                 List<Set> slist = this.getSets();

                 for (Set s : slist) {

                         boolean modified = false;

                         if (!s.isMetaSet())

                                 continue;

                         MetaSet ms = this.getMetaSet(s.getSid());

                         for (MetaSetRule msr : ms.getRules()) {

                                 if (msr.getType() == MetaSet.NAME) {

                                         if (msr.getValue().equals(oldName)) {

                                                 msr.setValue(newName);

                                                 modified = true;

                                         }

                                 }

                         }

                         if (modified)

                                 this.storeMetaSet(ms);

                 }

                 set.setName(newName);

                 this.storeSet(set);

         }

         /** Build a list of inactive sets

          * @return A List of Sets

          */

         public List<Set> getInactiveSets() {

                 return(setsDao.getInactiveSets());

         }

         /** Build a list of active sets

          * @return A List of Sets

          */

         public List<Set> getActiveSets() {

                 return(setsDao.getActiveSets());

         }

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

         /** 

          * MetaSet Management

          */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.domain.logic.PicManFacade#getMetaSet(int)

          */

         public MetaSet getMetaSet(int sid) {

                 return(this.metaSetsDao.getMetaSet(sid));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.domain.logic.PicManFacade#storeMetaSet(com.buckosoft.PicMan.domain.MetaSet)

          */

         public void storeMetaSet(MetaSet mset) {

                 this.metaSetsDao.storeMetaSet(mset);

         }

         /** Get a List of Column names for the MetaSets.

          * @return a List of "columns" for the known metasets

          */

         public        List<String>        getMetaSetColumns() {

                 List<String> columns = new LinkedList<String>();

                 List<Integer> sizes = getSizes();

                 List<Set> sets = getSets();

                 SetSize        ss = new SetSize();

                 Iterator<Set> setIter = sets.iterator();

                 while (setIter.hasNext()) {

                         Set set = (Set)setIter.next();

                         if (set.isMetaSet()) {

                                 ss.setSetName(set.getName());

                                 Iterator<Integer> sizeIter = sizes.iterator();

                                 while (sizeIter.hasNext()) {

                                         ss.setSize(((Integer)sizeIter.next()).intValue());

                                         columns.add(ss.getGuiSetSize());

                                 }

                         }

                 }

                 return(columns);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getMetaSetFilter()

          */

         public MetaSetFilter getMetaSetFilter() {

                 return(this.metaSetFilter);

         }

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

         /* 

          * Mosaic Management

          */

         /* (non-Javadoc)

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

          */

         public Mosaic getMosaic(int mid) {

                 return(this.mosaicsDao.getMosaic(mid));

         }

         /* (non-Javadoc)

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

          */

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

                 return(this.mosaicsDao.getMosaic(masterPic, engine, sid, tileHeight));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getMosaicTileCount(int)

          */

         public int getMosaicTileCount(int mid) {

                 return(this.mosaicTilesDao.getTileCount(mid));

         }

         /* (non-Javadoc)

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

          */

         public List<Mosaic> getMosaics() {

                 return(this.mosaicsDao.getMosaics());

         }

         /* (non-Javadoc)

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

          */

         public void storeMosaic(Mosaic mosaic) {

                 this.mosaicsDao.storeMosaic(mosaic);

         }

         /* (non-Javadoc)

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

          */

         public void deleteMosaic(int mid) {

                 this.mosaicsDao.deleteMosaic(mid);

         }

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

         /*

          * MosaicBatch Management

          */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getMosaicBatch(int)

          */

         public MosaicBatch getMosaicBatch(int mbid) {

                 return(this.mosaicBatchesDao.getMosaicBatch(mbid));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getMosaicBatches()

          */

         public List<MosaicBatch> getMosaicBatches() {

                 return(this.mosaicBatchesDao.getMosaicBatches());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#storeMosaicBatch(com.buckosoft.PicMan.domain.MosaicBatch)

          */

         public void storeMosaicBatch(MosaicBatch mbatch) {

                 this.mosaicBatchesDao.storeMosaicBatch(mbatch);

         }

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

         /*

          * MosaicTile Management

          */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#deleteMosaicTiles(int)

          */

         public void deleteMosaicTiles(int mid) {

                 this.mosaicTilesDao.deleteMosaicTiles(mid);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getMosaicTiles(int)

          */

         public List<MosaicTile> getMosaicTiles(int mid) {

                 return(this.mosaicTilesDao.getMosaicTiles(mid));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#storeMosaicTile(com.buckosoft.PicMan.domain.MosaicTile)

          */

         public void storeMosaicTile(MosaicTile tile) {

                 this.mosaicTilesDao.storeMosaicTile(tile);

         }

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

         /* 

          * MosaicVector Management

          */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#updateMosaicVectors(com.buckosoft.PicMan.domain.MosaicVector)

          */

         public void updateMosaicVectors(MosaicVector mv) {

                 this.mosaicVectorsDao.updateMosaicVector(mv);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getMosaicVectors(java.util.List)

          */

         public List<MosaicVector> getMosaicVectors(List<Pic> picList) {

                 return(this.mosaicVectorsDao.getMosaicVectors(picList));

         }

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

         /* 

          * Poster Management

          */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getPoster(int)

          */

         public Poster getPoster(int pid) {

                 return(this.postersDao.getPoster(pid));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getPosters()

          */

         public List<Poster> getPosters() {

                 return(this.postersDao.getPosters());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#storePoster(com.buckosoft.PicMan.domain.Poster)

          */

         public void storePoster(Poster poster) {

                 this.postersDao.storePoster(poster);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#deletePoster(int)

          */

         public void deletePoster(int pid) {

                 this.postersDao.deletePoster(pid);

         }

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

         /*

          * Size Management

          */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSizes()

          */

         public        List<Integer>        getSizes() {

                 return(sizes);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSizeArray()

          */

         public        int[]        getSizeArray() {

                 return(sizeArray);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSizeCount()

          */

         public        int                getSizeCount() {

                 return(5);

         }

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

         /* Chains Management */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getChains()

          */

         public        List<Chain>        getChains() {

                 return(chainsDao.getChains());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getChainCount()

          */

         public        int                getChainCount() {

                 return(chainsDao.getChainCount());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getChain(java.lang.String)

          */

         public        Chain        getChain(String chainName) {

                 return(chainsDao.getChain(chainName));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getChain(int)

          */

         public        Chain        getChain(int cid) {

                 return(chainsDao.getChain(cid));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#storeChain(com.buckosoft.PicMan.domain.Chain)

          */

         public        void        storeChain(Chain chain) {

                 chainsDao.storeChain(chain);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#deleteChain(com.buckosoft.PicMan.domain.Chain)

          */

         public        void        deleteChain(Chain chain) {

                 chainsDao.deleteChain(chain);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSetsInChain(int)

          */

         public List<Set>        getSetsInChain(int cid) {

                 Chain c = getChain(cid);

                 LinkedList<Set> theList = new LinkedList<Set>();

                 Iterator<SetSize> iter = c.getSetSizes().iterator();

                 while (iter.hasNext()) {

                         SetSize ss = (SetSize)iter.next();

                         boolean match = false;

                         Iterator<Set> iterThe = theList.iterator();

                         while (iterThe.hasNext()) {

                                 Set s = iterThe.next();

                                 if (DEBUG) {

                                         if (s == null || ss == null) {

                                                 logger.info("s or ss == null");

                                         }

                                 }

                                 if (s.getName().equals(ss.getSetName())) {

                                         match = true;

                                         break;

                                 }

                         }

                         if (match == false) {

                                 if (DEBUG)

                                         logger.info("Add set \"" + ss.getSetName() + "\"");

                                 Set set = setsDao.getSet(ss.getSetName());

                                 if (set == null) {

                                         RuntimeException e = new RuntimeException("getSetsInChain can't find set \"" + ss.getSetName() + "\" in chain \"" + c.getName() + "\"");

                                         pmcf.addError(e);

                                 } else

                                         theList.add(set);

                         }

                 }

                 return(theList);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getSetSizesInChain(int, int)

          */

         @SuppressWarnings("unchecked")

         public List<SetSize> getSetSizesInChain(int cid, int sid) {

                 Chain c = getChain(cid);

                 Set set = getSet(sid);

                 LinkedList<SetSize> theList = (LinkedList<SetSize>) c.getSetSizes().clone();

                 Iterator<SetSize> iter = theList.iterator();

                 while (iter.hasNext()) {

                         SetSize ss = (SetSize)iter.next();

                         if (!set.getName().equals(ss.getSetName())) {

                                 iter.remove();

                         }

                 }

                 return(theList);

         }

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

         /* Contacts */

         /* (non-Javadoc)

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

          */

         public        Contact        getContact(int cid, String name) {

                 return(contactsDao.getContact(cid, name));

         }

         /* (non-Javadoc)

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

          */

         public        Contact        getContact(int cid, String setName, int size, int item) {

                 return(contactsDao.getContact(cid, setName, size, item));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#addContact(com.buckosoft.PicMan.domain.Contact)

          */

         public        void        addContact(Contact c) {

                 contactsDao.addContact(c);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getNewestContact()

          */

         public        Contact                getNewestContact() {

                 return(contactsDao.getNewestContact());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getContactOldestMap(com.buckosoft.PicMan.domain.Chain)

          */

         public HashMap<String, Date>                getContactOldestMap(Chain chain) {

                 return(contactsDao.getContactOldestMap(chain));

         }

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

         /*

          * Filter management 

          */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getFilterCount()

          */

         public        int                getFilterCount() {

                 return(this.filtersDao.getFilterCount());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getFilterColumns()

          */

         public        List<String>        getFilterColumns() {

                 if (DEBUG)

                         logger.info("getFilterColumns()");

                 return(this.filtersDao.getFilterColumns());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getFilters()

          */

         public        List<Filter>        getFilters() {

                 return(this.filtersDao.getFilters());

         }

         /* (non-Javadoc)

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

          */

         public         List<Filter>        getFiltersBySet(String set, int size) {

                 return(this.filtersDao.getFiltersBySet(set, size));

         }

         /* (non-Javadoc)

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

          */

         public        List<String>        getPicNamesBySet(String setName, int size) {

                 Set set = getSet(setName);

                 return(getPicNamesBySet(set, size));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getPicNamesBySet(com.buckosoft.PicMan.domain.Set, int)

          */

         public List<String> getPicNamesBySet(Set set, int size) {

                 if (set.isMetaSet())

                         return(this.metaSetFilter.getListOfPicNamesInMetaSet(set, size, MetaSet.NONE, 0));

                 if (set.isMicroSet() || set.isNanoSet())

                         return(this.getMicroSetPicNamesInSet(set.getSid()));

                 return(this.filtersDao.getPicNamesBySet(set, size));

         }

         @Override

         public List<String> getPicNamesBySet(MetaSet set, int size, int rateOp, int rateVal) {

                 return(this.metaSetFilter.getListOfPicNames(set, size, rateOp, rateVal));

         }

         /* (non-Javadoc)

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

          */

         public List<String> getPicNamesBySet(String setName, int size, int rateOp, int rateVal) {

                 Set set = getSet(setName);

                 return(getPicNamesBySet(set, size, rateOp, rateVal));

         }

         /* (non-Javadoc)

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

          */

         public        List<String>        getPicNamesBySet(Set set, int size, int rateOp, int rateVal) {

                 if (set.isMetaSet())

                         return(this.metaSetFilter.getListOfPicNamesInMetaSet(set, size, rateOp, rateVal));

                 if (set.isMicroSet() || set.isNanoSet())

                         return(this.getMicroSetPicNamesInSet(set.getSid()));

 //                if (set.isFuncSet())

 // aborted:        return(this.getPicNamesByFunc(set.getSid(), size, rateOp, rateVal));

                 return(this.filtersDao.getPicNamesBySet(set, size, rateOp, rateVal));

         }

         public List<String>        getPicNamesByFunc(int func, int size, int rateOp, String operand) {

                 switch (func) {

                 case Set.FUNC_SID_DATE:

                         if (rateOp == 0)

                                 return(this.picsDao.getPicNames());

                         if (operand == null)

                                 operand = "1900-01-01";

                         return(this.picsDao.getPicNamesByDateFunc(MetaSet.rateOps[rateOp], operand));

 //                        return(new LinkedList<String>());

                 case Set.FUNC_SID_ROOT:

                         return(this.picsDao.getPicNamesByRootFunc(MetaSet.rateOps[rateOp], Integer.parseInt(operand)));

                 default:

                         RuntimeException e = new RuntimeException("unknown func: " + func);

                         throw e;

                 }

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getFilterDates()

          */

         public        HashMap<String, Date>        getSetTimestamps() {

                 HashMap<String, Date> hm = this.setTimestampsDao.getSetTimestamps();

                 return(hm);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#addFilter(com.buckosoft.PicMan.domain.Filter)

          */

         public        void        addFilter(Filter filter) {

 //                Filter oldFilter = this.filtersDao.getFilter(filter.getPicName());

                 this.filtersDao.addFilter(filter);

                 this.updateMicroFilters(filter);

 //                this.processFilterDates(filter);

 /*

                 // build a list of changed metaSets

                 LinkedHashMap<String, String> changed = new LinkedHashMap<String, String>();

                 List<Set> sets = this.getSets();

                 Iterator<Set> iter = sets.iterator();

                 int                i;

                 while (iter.hasNext()) {

                         Set set = iter.next();

                         if (!set.isMetaSet())

                                 continue;

                         if (DEBUGMETASETS) {

                                 if (set.getName().equals("DickB"))

                                         logger.info("DickB");

                         }

                         boolean[] reto = this.metaSetFilter.isFilterInSet(this.getMetaSet(set.getSid()), oldFilter);

                         boolean[] retn = this.metaSetFilter.isFilterInSet(this.getMetaSet(set.getSid()), filter);

                         if (DEBUGMETASETS) {

                                 String        s = "";

                                 for (i=0; i<sizeArray.length; i++)

                                         s += reto[i] ? "T" : "F";

                                 logger.info("reto=" + s + "  - " + set.getName());

                                 s = "";

                                 for (i=0; i<sizeArray.length; i++)

                                         s += retn[i] ? "T" : "F";

                                 logger.info("retn=" + s + "  - " + set.getName());

                         }

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

                                 if (reto[i] ^ retn[i]) {

                                         if (DEBUG)

                                                 logger.info("set updated: " + set.getName() + " ro=" + reto[i] + " rn=" + retn[i]);

                                         changed.put(set.getName() + "_" + sizeArray[i], "");

                                 }

                         }

                 }

 //                if (!changed.isEmpty()) {

 //                        this.setTimestampsDao.updateFilterDates(changed);

 //                }

 */        }

 /*

         @SuppressWarnings("unchecked")

         public        void processFilterDates(Filter f) {

                 if (f != null) {

                         LinkedHashMap<String, Integer> oldf = this.getFilter(f.getPicName()).getFilters();

                         LinkedHashMap<String, Integer> newf = (LinkedHashMap<String, Integer>)f.getFilters().clone();

                         LinkedHashMap<String, String> changed = new LinkedHashMap<String, String>();

                         Iterator<String> it = oldf.keySet().iterator();

                         while (it.hasNext()) {

                                 String        oldKey = it.next();

                                 if (!newf.containsKey(oldKey)) {

                                         if (DEBUG)

                                                 logger.info("newf !key" + oldKey);

                                         if (((Integer)oldf.get(oldKey)).intValue() != 0) {

                                                 if (DEBUG)

                                                         logger.info("Add newf" + oldKey);

                                                 changed.put(oldKey, "");

                                         }

                                 } else {

                                         if (DEBUG)

                                                 logger.info("comparing: " + oldKey + " old:" + ((Integer)oldf.get(oldKey)).intValue() + " new: " + ((Integer)newf.get(oldKey)).intValue());

                                         if (((Integer)oldf.get(oldKey)).intValue() != ((Integer)newf.get(oldKey)).intValue()) {

                                                 changed.put(oldKey, "");

                                                 if (DEBUG)

                                                         logger.info("keys different");

                                         }

                                         newf.remove(oldKey);

                                 }

                         }

                         it = newf.keySet().iterator();

                         while (it.hasNext()) {                        // These are in new, but not old, so update

                                 String newKey = (String)it.next();

                                 if (DEBUG)

                                         logger.info("newf has key: " + newKey);

                                 changed.put(newKey, "");

                         }

 //                        this.setTimestampsDao.updateFilterDates(changed);

                 }

         }

 */        

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getFilter(java.lang.String)

          */

         public        Filter        getFilter(String picName) {

                 Filter f = this.filtersDao.getFilter(picName);

                 Pic pic = this.getPic(picName);

                 if (pic == null) {

                         throw new RuntimeException("No pic for " + picName);

                 }

                 List<FilterMicroSet>        li = this.filtersMicroSetsDao.getFiltersInPid(pic.getPid());

                 Iterator<FilterMicroSet> iter = li.iterator();

                 while (iter.hasNext()) {

                         FilterMicroSet fms = iter.next();

                         f.addFilter(this.setsDao.getSet(fms.getSid()).getName(), fms.getValue());

                 }

                 return(f);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getPicFromFilterMicroSet(int)

          */

         public FilterMicroSet getPicFromFilterMicroSet(int pid, int sid) {

                 return(this.filtersMicroSetsDao.getFilterMicroSet(pid, sid));

         }

         private        List<String>        getMicroSetPicNamesInSet(int sid) {

                 List<FilterMicroSet>        ll = this.filtersMicroSetsDao.getPicsInSet(sid);

                 List<String>        list = new LinkedList<String>();

                 Iterator<FilterMicroSet>        iter = ll.iterator();

                 while (iter.hasNext()) {

                         FilterMicroSet fms = iter.next();

                         if (fms.getValue() != 0)

                                 list.add(this.getPic(fms.getPid()).getName());

                 }

                 return(list);

         }

         private        void        updateMicroFilters(Filter filter) {

                 Pic pic = this.getPic(filter.getPicName());

                 this.filtersMicroSetsDao.deleteFilters(pic.getPid());

                 LinkedHashMap<String, Integer> map = filter.getFilters();

                 Iterator<String> it = map.keySet().iterator();

                 String        key;

                 Set set;

                 while (it.hasNext()) {

                         key = (String)it.next();

 //                        if (DEBUG)

 //                                logger.info("key=" + key);

                         if (key.indexOf('_') != -1)

                                 continue;

                         set = this.getSet(key);

                         this.filtersMicroSetsDao.storeFilter(set.getSid(), pic.getPid(), map.get(key));

                 }

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getUser(int)

          */

         public User getUser(int userid) throws DataAccessException {

                 return(this.usersDao.getUser(userid));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#storeUser(com.buckosoft.PicMan.domain.User)

          */

         public void storeUser(User user) {

                 this.usersDao.storeUser(user);

         }

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

         /* Virgin management */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getVirgins()

          */

         public        List<Virgin>        getVirgins() {

                 return(this.virginsDao.getVirgins());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getVirgins(int)

          */

         public        List<Virgin>        getVirgins(int max) {

                 return(this.virginsDao.getVirgins(max));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#isVirgin(java.lang.String)

          */

         public        boolean        isVirgin(String pic) {

                 return(this.virginsDao.isVirgin(pic));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#addVirgin(java.lang.String)

          */

         public        void        addVirgin(String pic) {

                 this.virginsDao.addVirgin(pic);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#deleteVirgin(java.lang.String)

          */

         public        void        deleteVirgin(String pic) {

                 this.virginsDao.deleteVirgin(pic);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getVirginCount()

          */

         public        int                getVirginCount() {

                 return(this.virginsDao.getVirginCount());

         }

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

         /* Pic management */

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#addPic(com.buckosoft.PicMan.domain.Pic)

          */

         public        void        addPic(Pic pic) {

                 this.picsDao.addPic(pic);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#updatePic(com.buckosoft.PicMan.domain.Pic)

          */

         public        void        updatePic(Pic pic) {

                 this.picsDao.updatePic(pic);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getPic(java.lang.String)

          */

         public        Pic                getPic(String picName) {

                 return(this.picsDao.getPic(picName));

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getPic(int)

          */

         public        Pic                getPic(int pid) {

                 return(this.picsDao.getPic(pid));

         }

         /*

          * (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getNewestPic()

          */

         public Pic getNewestPic() {

                 return(this.picsDao.getNewestPic());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getRandomPic()

          */

         public Pic getRandomPic() {

                 return(this.picsDao.getRandomPic());

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.db.DatabaseFacade#getPicsByMD5Sum(long)

          */