//
//  MYDirectoryWatcher.m
//  Murky
//
//  Copyright 2008 Jens Alfke. All rights reserved.
//

#import "MYDirectoryWatcher.h"
#import "Test.h"
#import "Logging.h"
#import <CoreServices/CoreServices.h>


static void directoryWatcherCallback(ConstFSEventStreamRef streamRef,
                                     void *clientCallBackInfo,
                                     size_t numEvents,
                                     void *eventPaths,
                                     const FSEventStreamEventFlags eventFlags[],
                                     const FSEventStreamEventId eventIds[]);

@interface MYDirectoryEvent ()
- (id) _initWithWatcher: (MYDirectoryWatcher*)itsWatcher
                   path: (NSString*)itsPath 
                  flags: (FSEventStreamEventFlags)itsFlags
                eventID: (FSEventStreamEventId)itsEventID;
@end


@implementation MYDirectoryWatcher


- (id) initWithDirectory: (NSString*)path target: (id)target action: (SEL)action
{
    Assert(path!=nil);
    self = [super init];
    if (self != nil) {
        _path = path.copy;
        _standardizedPath = [_path stringByStandardizingPath];
        _target = target;
        _action = action;
        _latency = 5.0;
        _lastEventID = kFSEventStreamEventIdSinceNow;
    }
    return self;
}

- (void) dealloc
{
    [self stop];
    [_path release];
    [super dealloc];
}

- (void) finalize
{
    [self stop];
    [super finalize];
}


@synthesize path=_path, latency=_latency, lastEventID=_lastEventID;

- (NSString*) standardizedPath {
    return _standardizedPath;
}


- (BOOL) start
{
    if( ! _stream ) {
        FSEventStreamContext context = {0,self,NULL,NULL,NULL};
        _stream = FSEventStreamCreate(NULL, 
                                      &directoryWatcherCallback, &context,
                                      (CFArrayRef)[NSArray arrayWithObject: _path], 
                                      _lastEventID, 
                                      _latency, 
                                      kFSEventStreamCreateFlagUseCFTypes);
        if( ! _stream )
            return NO;
        FSEventStreamScheduleWithRunLoop(_stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
        if( ! FSEventStreamStart(_stream) ) {
            [self stop];
            return NO;
        }
        _historyDone = (_lastEventID == kFSEventStreamEventIdSinceNow);
        LogTo(MYDirectoryWatcher, @"Started on %@ (latency=%g, lastEvent=%llu)",_path,_latency,_lastEventID);
    }
    return YES;
}

- (void) pause
{
    if( _stream ) {
        FSEventStreamStop(_stream);
        FSEventStreamInvalidate(_stream);
        FSEventStreamRelease(_stream);
        _stream = NULL;
        LogTo(MYDirectoryWatcher, @"Stopped on %@ (lastEvent=%llu)",_path,_lastEventID);
    }
}

- (void) stop
{
    [self pause];
    _lastEventID = kFSEventStreamEventIdSinceNow;   // so events from now till next start will be dropped
    [NSObject cancelPreviousPerformRequestsWithTarget: self selector: @selector(start) object: nil];
}

- (void) stopTemporarily
{
    if( _stream ) {
        [self stop];
        [self performSelector: @selector(start) withObject: nil afterDelay: 0.0];
    }
}


- (void) _notifyEvents: (size_t)numEvents
                 paths: (NSArray*)paths
                 flags: (const FSEventStreamEventFlags[])eventFlags
              eventIDs: (const FSEventStreamEventId[])eventIDs
{
    for (size_t i=0; i<numEvents; i++) {
        NSString *path = [paths objectAtIndex: i];
        FSEventStreamEventFlags flags = eventFlags[i];
        FSEventStreamEventId eventID = eventIDs[i];
        if( flags & (kFSEventStreamEventFlagMount | kFSEventStreamEventFlagUnmount) ) {
            if( flags & kFSEventStreamEventFlagMount )
                LogTo(MYDirectoryWatcher, @"Volume mounted: %@",path);
            else
                LogTo(MYDirectoryWatcher, @"Volume unmounted: %@",path);
        } else if( flags & kFSEventStreamEventFlagHistoryDone ) {
            LogTo(MYDirectoryWatcher, @"Event #%llu History done",eventID);
            _historyDone = YES;
        } else {
            LogTo(MYDirectoryWatcher, @"Event #%llu flags=%02x path=%@",eventID,flags,path);
            if( _historyDone )
                flags |= kFSEventStreamEventFlagHistoryDone;
            
            MYDirectoryEvent *event = [[MYDirectoryEvent alloc] _initWithWatcher: self
                                                                        path: path 
                                                                       flags: flags
                                                                     eventID: eventID];
            [_target performSelector: _action withObject: event];
            [event release];
        }
        _lastEventID = eventIDs[i];
    }
}


static void directoryWatcherCallback(ConstFSEventStreamRef streamRef,
                                     void *watcher,
                                     size_t numEvents,
                                     void *eventPaths,
                                     const FSEventStreamEventFlags eventFlags[],
                                     const FSEventStreamEventId eventIDs[])
{
    [(MYDirectoryWatcher*)watcher _notifyEvents: numEvents
                                          paths: (NSArray*)eventPaths
                                          flags: eventFlags
                                       eventIDs: eventIDs];
}



@end




@implementation MYDirectoryEvent

- (id) _initWithWatcher: (MYDirectoryWatcher*)itsWatcher
                   path: (NSString*)itsPath 
                  flags: (FSEventStreamEventFlags)itsFlags
                eventID: (FSEventStreamEventId)itsEventID
{
    self = [super init];
    if (self != nil) {
        watcher = itsWatcher;
        path = itsPath.copy;
        flags = itsFlags;
        eventID = itsEventID;
    }
    return self;
}

- (void) dealloc
{
    [path release];
    [super dealloc];
}

@synthesize watcher,path,flags,eventID;

- (NSString*) relativePath
{
    NSString *base = watcher.standardizedPath;
    NSString *standardizedPath = [path stringByStandardizingPath];
    if( ! [standardizedPath hasPrefix: base] )
        return nil;
    unsigned length = base.length;
    while( length < standardizedPath.length && [standardizedPath characterAtIndex: length]=='/' )
        length++;
    return [standardizedPath substringFromIndex: length];
}

- (BOOL) mustScanSubdirectories     {return (flags & kFSEventStreamEventFlagMustScanSubDirs) != 0;}
- (BOOL) eventsWereDropped          {return (flags & (kFSEventStreamEventFlagUserDropped|kFSEventStreamEventFlagKernelDropped)) != 0;}
- (BOOL) isHistorical               {return (flags & kFSEventStreamEventFlagHistoryDone)==0;}
- (BOOL) rootChanged                {return (flags & kFSEventStreamEventFlagRootChanged)!=0;}

@end