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

  * NewPicScannerImpl.java - Implement the Scan for new pictures interface

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2005 - Dick Balaska

  * 

  */

 package com.buckosoft.PicMan.business;

 import java.awt.Dimension;

 import java.io.File;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.HashMap;

 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.business.util.MD5SumUpdater;

 import com.buckosoft.PicMan.domain.Pic;

 import com.buckosoft.PicMan.domain.Root;

 /** Implement the Scan For New Pictures Interface. <br>

  * Scan the Root directories looking for pictures that haven't been catalogued.

  * Add any found pics to the database and create a virgin entry.

  * @author Dick Balaska

  * @since 2005/07/28

  */

 public class NewPicScannerImpl implements NewPicScanner {

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

         private static final boolean DEBUG = false;

         private        LinkedList<String>        picExtensions;

         private        Root                                currentRoot;

         private        ArrayList<File>                newPics;

         private        PicManFacade                pmf;

         private        String                                processErrorMessage = "";

         private        HashMap<String, Date>                                existingPicsMap;

         public NewPicScannerImpl(){

                 newPics = new ArrayList<File>();

         }

         /** Constructor that sets the reference to PicManFacade

          * @param pmf The PicManFacade primary interface

          */

         public NewPicScannerImpl(PicManFacade pmf) {

                 newPics = new ArrayList<File>();

                 this.pmf = pmf;

                 setPicExtensions(pmf.getDB().getPicExtensions());

         }

         /** Set the pic extensions that are known pics

          * @param list A list of file extensions, typically just "jpg"

          */

         public void setPicExtensions(List<String> list) {picExtensions = new LinkedList<String>(list); }

         /** Return the newPics array

          * @return The list of pics that we've found after scanning

          */

         public ArrayList<File>        getNewPics() { return(newPics); }

         /** Scan the root directories and build a list of pics found.

          * @return The number of new pics found.

          */

         public int getNewPicCount() throws Exception {

                 if (DEBUG)

                         logger.info("getNewPicCount()");

                 int        newCount = 0;

                 newPics.clear();

                 Iterator<Root>        it;

                 existingPicsMap = pmf.getDB().getPicsMap();

                 if (DEBUG)

                         logger.info("existingPicsMap= " + existingPicsMap.size());

                 List<Root> roots = pmf.getDB().getRoots();

                 it = roots.iterator();

                 while(it.hasNext()) {

                         currentRoot = (Root)it.next();

                         if (currentRoot.isActive() == false)

                                 continue;

                         File f = new File(currentRoot.getPath());

                         newCount = processFile(f, newCount);

                 }

                 existingPicsMap = null;

                 return(newCount);

         }

         private int processFile(File f, int newCount) throws Exception

         {

                 if (f.isFile()) {

 //                        if (DEBUG)

 //                                logger.info("processFile() check '" + f.getName() + "'");

                         String        s = f.getName();

                         Iterator<String> it = picExtensions.iterator();

                         boolean match = false;

                         while (it.hasNext()) {

                                 if (s.endsWith((String)it.next())) {

                                         match = true;

                                         break;

                                 }

                         }

                         if (match) {

                                 if (picExists(f))

                                         return(newCount);

                                 newPics.add(f);

                                 newCount++;

                         }

                         return(newCount);

                 }

                 if (f.isDirectory()) {

                         File[] files = f.listFiles();

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

                                 newCount = processFile(files[i], newCount);

                         return(newCount);

                 }

                 throw new Exception("file '" + f.getName() + "' is neither file nor directory");

         }

         private        boolean picExists(File f) {

                 String        s = f.getName();

                 if (s.endsWith(".jpg")) {

                         s = s.substring(0,s.length()-4);

 //                        logger.info("check '" + s + "' in map");

                         if (existingPicsMap.containsKey(s))

                                 return(true);

                 }

                 return(false);

         }

         /** Process any pics in the newPics list.

          * Add them to the Pics table and the Virgins table.

          * @return success

          */

         public boolean processNewPics() {

                 processErrorMessage = "Broken!";

                 Iterator<File> it = newPics.iterator();

                 boolean success = true;

                 List<Root>        roots = this.pmf.getDB().getRoots();

                 File        f;

                 String        s;

                 Pic        pic;

                 while (it.hasNext()) {

                         f = (File)it.next();

                         pic = new Pic();

                         s = f.getName();

                         if (s.endsWith(".jpg"))

                                 s = s.substring(0, s.length()-4);

                         pic.setName(s);

                         String        path = f.getParent().replace('\\', '/');

                         Iterator<Root> riter = roots.iterator();

                         while (riter.hasNext()) {

                                 Root root = riter.next();

                                 if (!root.isActive())

                                         continue;

                                 if (path.startsWith(root.getPath())) {

                                         pic.setRid(root.getRid());

                                         path = path.substring(root.getPath().length()+1);

                                         break;

                                 }

                         }

                         if (pic.getRid() == -1) {

                                 throw new RuntimeException("Can't match root for '" + pic.getName() + "' - '" + path + "'");

                         }

                         pic.setLocation(path);

                         pic.getDate().setTime(f.lastModified());

                         Dimension d = pmf.determinePicSize(pic);

                         if (d.height == -1) {

                                 logger.warn("Can't determine size for pic: " + pic.getName());

                                 d.height = 0;

                                 d.width = 0;

                         }

                         pic.setHeight(d.height);

                         pic.setWidth(d.width);

                         MD5SumUpdater.calculateMD5Sum(pmf, pic);

                         pmf.getDB().addPic(pic);

                         pmf.getDB().addVirgin(pic.getName());

                 }

                 return(success);

         }

         /* (non-Javadoc)

          * @see com.buckosoft.PicMan.business.NewPicScanner#getProcessNewPicsErrorMessage()

          */

         public String getProcessNewPicsErrorMessage() {

                 return(processErrorMessage);

         }

 }