package org.webslinger.io;

 import java.io.File;

 import java.io.IOException;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.atomic.AtomicInteger;

 import net.contentobjects.jnotify.JNotify;

 import net.contentobjects.jnotify.JNotifyListener;

 public class JNotifyFileMonitor extends AbstractMonitor<File, JNotifyFileMonitor, JNotifyFileMonitor.WatchedFile, FileMonitor.FileListener> implements FileMonitor {

     public static final JNotifyFileMonitor SINGLETON = new JNotifyFileMonitor();

     public JNotifyFileMonitor() {

         super();

     }

     protected void activate(WatchedFile watched) throws IOException {

         File parent = watched.file.getParentFile();

         if (parent != null) {

             add(parent, watched);

             getWatched(parent).children.put(watched.file.getName(), watched);

         }

         if (watched.file.exists()) watched.startWatch();

     }

     protected void deactivate(WatchedFile watched) throws IOException {

         File parent = watched.file.getParentFile();

         if (parent != null) {

             getWatched(parent).children.remove(watched.file.getName());

             remove(parent, watched);

         }

         watched.stopWatch();

     }

     protected WatchedFile createWatched(File item) {

         return new WatchedFile(this, item);

     }

     public static final class WatchedFile extends AbstractMonitor.Watched<File, JNotifyFileMonitor, WatchedFile, FileMonitor.FileListener> implements JNotifyListener, FileMonitor.FileListener {

         protected final File file;

         protected AtomicInteger watchId = new AtomicInteger(-1);

         protected ConcurrentHashMap<String, WatchedFile> children = new ConcurrentHashMap<String, WatchedFile>();

         public WatchedFile(JNotifyFileMonitor monitor, File file) {

             super(monitor);

             this.file = file;

         }

         public int hashCode() {

             return WatchedFile.class.hashCode() ^ file.hashCode();

         }

         public boolean equals(Object o) {

             if (!(o instanceof WatchedFile)) return false;

             WatchedFile other = (WatchedFile) o;

             return file.equals(other.file);

         }

         protected void startWatch() throws IOException {

             int oldWatchId, newWatchId;

             do {

                 oldWatchId = watchId.get();

                 if (oldWatchId != -1) break;

                 newWatchId = JNotify.addWatch(file.getPath(), JNotify.FILE_CREATED | JNotify.FILE_DELETED | JNotify.FILE_MODIFIED | JNotify.FILE_RENAMED, false, this);

                 if (watchId.compareAndSet(oldWatchId, newWatchId)) {

                     if (oldWatchId == -1) break;

                     JNotify.removeWatch(oldWatchId);

                 }

             } while (true);

         }

         protected void stopWatch() throws IOException {

             int oldWatchId, newWatchId;

             do {

                 oldWatchId = watchId.get();

                 if (oldWatchId == -1) break;

                 if (watchId.compareAndSet(oldWatchId, -1)) {

                     JNotify.removeWatch(oldWatchId);

                     break;

                 }

             } while (true);

         }

         // sent when the parent notices something

         public void acceptEvent(File parent, Listener.Event event) {

         }

         protected void processEvent(Listener.Event event) throws IOException {

             switch (event) {

                 case CHANGE:

                     monitor.fireEvent(file, event);

                     break;

                 case CREATE:

                     monitor.fireEvent(file, event);

                     do {

                         boolean isEmpty = children.isEmpty();

                         if (isEmpty) break;

                         startWatch();

                         if (isEmpty == children.isEmpty()) break;

                         stopWatch();

                     } while (true);

                     break;

                 case DELETE:

                     monitor.fireEvent(file, event);

                     stopWatch();

                     break;

             }

         }

         protected void fireChildEvent(int watchId, String name, Listener.Event event) {

             int thisId = this.watchId.get();

             if (thisId != watchId) return;

             WatchedFile watched = children.get(name);

             if (watched == null) return;

             try {

                 watched.processEvent(event);

             } catch (IOException e) {

                 e.printStackTrace();

             }

         }

         public void fileRenamed(int watchId, String rootPath, String oldName, String newName) {

             assert file.getPath() == rootPath;

             fireChildEvent(watchId, oldName, Listener.Event.DELETE);

             fireChildEvent(watchId, newName, Listener.Event.CREATE);

         }

         public void fileModified(int watchId, String rootPath, String name) {

             assert file.getPath() == rootPath;

             fireChildEvent(watchId, name, Listener.Event.CHANGE);

         }

         public void fileDeleted(int watchId, String rootPath, String name) {

             assert file.getPath() == rootPath;

             fireChildEvent(watchId, name, Listener.Event.DELETE);

         }

         public void fileCreated(int watchId, String rootPath, String name) {

             assert file.getPath() == rootPath;

             fireChildEvent(watchId, name, Listener.Event.CREATE);

         }

     }

 }