//

 //  MYTask.m

 //  Murky

 //

 //  Copyright 2008 Jens Alfke. All rights reserved.

 //

 #import "MYTask.h"

 //FIX: NOTICE: This code was written assuming garbage collection. It will currently leak like a sieve without it.

 NSString* const MYTaskErrorDomain = @"MYTaskError";

 NSString* const MYTaskExitCodeKey = @"MYTaskExitCode";

 NSString* const MYTaskObjectKey = @"MYTask";

 #define MYTaskSynchronousRunLoopMode @"MYTask"

 @interface MYTask ()

 @property (readwrite,nonatomic) BOOL isRunning;

 @property (readwrite,retain,nonatomic) NSError *error;

 - (void) _finishUp;

 @end

 @implementation MYTask

 - (id) initWithCommand: (NSString*)command

              arguments: (NSArray*)arguments

 {

     Assert(command);

     self = [super init];

     if (self != nil) {

         _command = command;

         _arguments = arguments ?[arguments mutableCopy] :[NSMutableArray array];

         _modes = [NSMutableArray arrayWithObjects: NSDefaultRunLoopMode, NSModalPanelRunLoopMode, nil];

     }

     return self;

 }

 - (id) initWithCommand: (NSString*)command, ...

 {

     NSMutableArray *arguments = [NSMutableArray array];

     va_list args;

     va_start(args,command);

     id arg;

     while( nil != (arg=va_arg(args,id)) )

         [arguments addObject: [arg description]];

     va_end(args);

     return [self initWithCommand: command arguments: arguments];

 }

 - (id) initWithError: (NSError*)error

 {

     self = [super init];

     if( self ) {

         _error = error;

     }

     return self;

 }

 - (NSString*) description

 {

     return [NSString stringWithFormat: @"%@ %@", 

             _command, [_arguments componentsJoinedByString: @" "]];

 }

 - (void) addArgument: (id)argument

 {

     [_arguments addObject: [argument description]];

 }

 - (void) addArgumentsFromArray: (NSArray*)arguments

 {

     for( id arg in arguments )

         [_arguments addObject: [arg description]];

 }

 - (void) addArguments: (id)arg, ...

 {

     va_list args;

     va_start(args,arg);

     while( arg ) {

         [_arguments addObject: [arg description]];

         arg = va_arg(args,id);

     }

     va_end(args);

 }

 - (void) prependArguments: (id)arg, ...

 {

     va_list args;

     va_start(args,arg);

     int i=0;

     while( arg ) {

         [_arguments insertObject: [arg description] atIndex: i++];

         arg = va_arg(args,id);

     }

     va_end(args);

 }

 - (NSString*) commandLine {

     NSMutableString *desc = [NSMutableString stringWithString: _command];

     for (NSString *arg in _arguments) {

         [desc appendString: @" "];

         if ([arg rangeOfString: @" "].length > 0)

             arg = [NSString stringWithFormat: @"'%@'", arg];

         [desc appendString: arg];

     }

     return desc;

 }

 - (void) ignoreOutput

 {

     _ignoreOutput = YES;

 }

 - (BOOL) makeError: (NSString*)fmt, ...

 {

     va_list args;

     va_start(args,fmt);

     NSString *message = [[NSString alloc] initWithFormat: fmt arguments: args];

     LogTo(MYTask, @"Error: %@",message);

     NSMutableDictionary *info = [NSMutableDictionary dictionaryWithObject: message

                                                                    forKey: NSLocalizedDescriptionKey];

     _error = [NSError errorWithDomain: MYTaskErrorDomain code: kMYTaskError userInfo: info];

     va_end(args);

     return NO;

 }

 - (NSPipe*) _openPipeAndHandle: (NSFileHandle**)handle notifying: (SEL)selector

 {

     NSPipe *pipe = [NSPipe pipe];

     *handle = [pipe fileHandleForReading];

     [[NSNotificationCenter defaultCenter] addObserver: self selector: selector

                                                  name: NSFileHandleReadCompletionNotification

                                                object: *handle];

     [*handle readInBackgroundAndNotifyForModes: _modes];

     return pipe;

 }

 - (void) _close

 {

     // No need to call -closeFile on file handles obtained from NSPipe (in fact, it can hang)

     _outHandle = nil;

     _errHandle = nil;

     [[NSNotificationCenter defaultCenter] removeObserver: self 

                                                     name: NSFileHandleReadCompletionNotification

                                                   object: nil];

 }

 /** Subclasses can override this. */

 - (NSTask*) createTask

 {

     Assert(!_task,@"createTask called twice");

     NSTask *task = [[NSTask alloc] init];

     task.launchPath = _command;

     task.arguments = _arguments;

     if( _currentDirectoryPath )

         task.currentDirectoryPath = _currentDirectoryPath;

     return task;

 }    

 - (BOOL) start

 {

     Assert(!_task, @"Task has already been run");

     if( _error )

         return NO;

     _task = [self createTask];

     Assert(_task,@"createTask returned nil");

     LogTo(MYTask,@"$ %@", self.commandLine);

     _task.standardOutput = [self _openPipeAndHandle: &_outHandle notifying: @selector(_gotOutput:)];

     _outputData =  [[NSMutableData alloc] init];

     _task.standardError  = [self _openPipeAndHandle: &_errHandle notifying: @selector(_gotStderr:)];

     _errorData =  [[NSMutableData alloc] init];

     [[NSNotificationCenter defaultCenter] addObserver: self selector: @selector(_exited:)

                                                  name: NSTaskDidTerminateNotification

                                                object: _task];

     @try{

         [_task launch];

     }@catch( id x ) {

         Warn(@"Task failed to launch: %@",x);

         _resultCode = 666;

         [self _close];

         return [self makeError: @"Exception launching %@: %@",_task.launchPath,x];

     }

     _taskRunning = YES;

     self.isRunning = YES;

     return YES;

 }

 - (void) stop

 {

     [_task interrupt];

     [self _close];

     _taskRunning = NO;

     self.isRunning = NO;

 }

 - (BOOL) _shouldFinishUp

 {

     return !_task.isRunning && (_ignoreOutput || (!_outHandle && !_errHandle));

 }

 - (void) _gotOutput: (NSNotification*)n

 {

     NSData *data = [n.userInfo objectForKey: NSFileHandleNotificationDataItem];

     if( n.object == _outHandle ) {

         if( data.length > 0 ) {

             [_outHandle readInBackgroundAndNotifyForModes: _modes];

             LogTo(HgTaskVerbose, @"Got %u bytes of output",data.length);

             if( _outputData ) {

                 [self willChangeValueForKey: @"output"];

                 [self willChangeValueForKey: @"outputData"];

                 [_outputData appendData: data];

                 _output = nil;

                 [self didChangeValueForKey: @"outputData"];

                 [self didChangeValueForKey: @"output"];

             }

         } else {

             LogTo(HgTaskVerbose, @"Closed output");

             _outHandle = nil;

             if( [self _shouldFinishUp] )

                 [self _finishUp];

         }

     }

 }

 - (void) _gotStderr: (NSNotification*)n

 {

     if( n.object == _errHandle ) {

         NSData *data = [n.userInfo objectForKey: NSFileHandleNotificationDataItem];

         if( data.length > 0 ) {

             [_errHandle readInBackgroundAndNotifyForModes: _modes];

             LogTo(HgTaskVerbose, @"Got %u bytes of stderr",data.length);

             [self willChangeValueForKey: @"errorData"];

             [_errorData appendData: data];

             [self didChangeValueForKey: @"errorData"];

         } else {

             LogTo(HgTaskVerbose, @"Closed stderr");

             _errHandle = nil;

             if( [self _shouldFinishUp] )

                 [self _finishUp];

         }

     }

 }

 - (void) _exited: (NSNotification*)n

 {

     _resultCode = _task.terminationStatus;

     LogTo(HgTaskVerbose, @"Exited with result=%i",_resultCode);

     _taskRunning = NO;

     if( [self _shouldFinishUp] )

         [self _finishUp];

     else

         [self performSelector: @selector(_finishUp) withObject: nil afterDelay: 1.0];

 }

 - (void) _finishUp

 {

     [NSObject cancelPreviousPerformRequestsWithTarget: self selector: @selector(_finishUp) object: nil];

     [self _close];

     LogTo(HgTaskVerbose, @"Finished!");

     if( _resultCode != 0 ) {

         // Handle errors:

         NSString *errStr = nil;

         if( _errorData.length > 0 )

             errStr = [[NSString alloc] initWithData: _errorData encoding: NSUTF8StringEncoding];

         LogTo(MYTask, @"    *** task returned %i: %@",_resultCode,errStr);

         if( errStr.length == 0 )

             errStr = [NSString stringWithFormat: @"Command returned status %i",_resultCode];

         NSString *desc = [NSString stringWithFormat: @"%@ command error", _task.launchPath.lastPathComponent];

         // For some reason the body text in the alert shown by -presentError: is taken from the

         // NSLocalizedRecoverySuggestionErrorKey, not the NSLocalizedFailureReasonKey...

         NSMutableDictionary *info = [NSMutableDictionary dictionaryWithObjectsAndKeys:

                                      desc,                                  NSLocalizedDescriptionKey,

                                      errStr,                                NSLocalizedRecoverySuggestionErrorKey,

                                      [NSNumber numberWithInt: _resultCode], MYTaskExitCodeKey,

                                      self,                                  MYTaskObjectKey,

                                      nil];

         self.error = [[NSError alloc] initWithDomain: MYTaskErrorDomain 

                                                 code: kMYTaskError

                                             userInfo: info];

     }

     [self finished];

     self.isRunning = NO;

 }

 - (void) finished

 {

     // This is a hook that subclasses can override to do post-processing.

 }

 - (BOOL) _waitTillFinishedInMode: (NSString*)runLoopMode

 {

     // wait for task to exit:

     while( _task.isRunning || self.isRunning )

         [[NSRunLoop currentRunLoop] runMode: MYTaskSynchronousRunLoopMode

                                  beforeDate: [NSDate dateWithTimeIntervalSinceNow: 1.0]];

     return (_resultCode==0);

 }

 - (BOOL) waitTillFinished

 {

     return [self _waitTillFinishedInMode: _modes.lastObject];

 }

 - (BOOL) run

 {

     [_modes addObject: MYTaskSynchronousRunLoopMode];

     return [self start] && [self _waitTillFinishedInMode: MYTaskSynchronousRunLoopMode];

 }    

 - (BOOL) run: (NSError**)outError

 {

     BOOL result = [self run];

     if( outError ) *outError = self.error;

     return result;

 }

 @synthesize currentDirectoryPath=_currentDirectoryPath, outputData=_outputData, error=_error, isRunning=_isRunning;

 - (NSString*) output

 {

     if( ! _output && _outputData ) {

         _output = [[NSString alloc] initWithData: _outputData encoding: NSUTF8StringEncoding];

         // If output isn't valid UTF-8, fall back to CP1252, aka WinLatin1, a superset of ISO-Latin-1.

         if( ! _output ) {

             _output = [[NSString alloc] initWithData: _outputData encoding: NSWindowsCP1252StringEncoding];

             Warn(@"MYTask: Output of '%@' was not valid UTF-8; interpreting as CP1252",self);

         }

     }

     return _output;

 }

 - (NSString*) outputAndError

 {

     NSString *result = self.output ?: @"";

     NSString *errorStr = nil;

     if( _error )

         errorStr = [NSString stringWithFormat: @"%@:\n%@",

                     _error.localizedDescription,_error.localizedRecoverySuggestion];

     else if( _errorData.length > 0 )

         errorStr = [[NSString alloc] initWithData: _errorData encoding: NSUTF8StringEncoding];

     if( errorStr )

         result = [NSString stringWithFormat: @"%@\n\n%@", errorStr,result];

     return result;

 }

 + (NSArray*) keyPathsForValuesAffectingOutputAndError

 {

     return [NSArray arrayWithObjects: @"output", @"error", @"errorData",nil];

 }

 @end