//  CMetadataImporter.m
 //
 //  Lisp Metadata Importer
 //
 //  Created by John Wiseman on 9/1/05.
 //  Copyright 2005 John Wiseman.
 //
 //  Licensed under the MIT license--see the accompanying LICENSE.txt
 //  file.
 
 #import "CMetadataImporter.h"
 
 #import "NSString_HMext.h"
 #import "NSData_HMext.h"
 #import "DebugLog.h"
 
 @implementation CMetadataImporter
 
 

 int MaxSourceSize = 500000; // Default maximum number of bytes that will be read for indexing purposes.

 long NO_MAXIMUM = -1;
 
 
 // All sorts of static data that we initialize once, then use many many times.
 
 static BOOL StaticDataIsInitialized = NO;
 
 // Lots of regexes in string form, waiting to be compiled.
 
 static NSString *LispDef1_pat = @"(?i)^\\(def[^\\s]*[\\s\\']+(\\(setf\\s+[^\\s]+\\))";

 static NSRegularExpression *LispDef1_RE = nil;

 
 static NSString *LispDef2_pat = @"(?i)^\\(def[^\\s]*[\\s\\']+([^\\s\\)]+)";

 static NSRegularExpression *LispDef2_RE = nil;

 
 static NSString *LispDefun_pat = @"(?i)^\\(defun\\s+([^\\s\\)\\(]+)";

 static NSRegularExpression *LispDefun_RE = nil;

 
 static NSString *LispDefunsetf_pat = @"(?i)^\\(defun\\s+(\\(setf\\s+[^\\s]+\\))";

 static NSRegularExpression *LispDefunsetf_RE = nil;

 
 static NSString *LispDefmethod_pat = @"(?i)^\\(defmethod\\s+([^\\s\\)\\(]+)";

 static NSRegularExpression *LispDefmethod_RE = nil;

 
 static NSString *LispDefmethodsetf_pat = @"(?i)^\\(defmethod\\s+(\\(setf\\s+[^\\s]+\\))";

 static NSRegularExpression *LispDefmethodsetf_RE = nil;

 
 static NSString *LispDefgeneric_pat = @"(?i)^\\(defgeneric\\s+((?:[^\\s\\)\\(]+|\\(setf\\s+[^\\s]+\\)))";

 static NSRegularExpression *LispDefgeneric_RE = nil;

 
 static NSString *LispDefgenericsetf_pat = @"(?i)^\\(defgeneric\\s+(\\(setf\\s+[^\\s]+\\))";

 static NSRegularExpression *LispDefgenericsetf_RE = nil;

 
 static NSString *LispDefmacro_pat = @"(?i)^\\(defmacro\\s+([^\\s\\)]+)";

 static NSRegularExpression *LispDefmacro_RE = nil;

 
 static NSString *LispDefclass_pat = @"(?i)^\\(defclass\\s+([^\\s\\)]+)";

 static NSRegularExpression *LispDefclass_RE = nil;

 
 static NSString *LispDefstruct_pat = @"(?i)^\\(defstruct\\s+\\(?([^\\s\\)]+)";

 static NSRegularExpression *LispDefstruct_RE = nil;

 
 static NSString *LispDefvar_pat = @"(?i)^\\((?:defvar|defparameter|defconstant)\\s+([^\\s\\)]+)";

 static NSRegularExpression *LispDefvar_RE = nil;

 static NSError *err = nil;

 
 - (void)initStaticData
 {
     NSLog(@"Import Lisp");

     if (StaticDataIsInitialized)
     {
         return;
     }
     
     StaticDataIsInitialized = YES;
     
     // Find the bundle, and Info.plist.  Set the debug level specified
     // there, as well as the maximum file length to index.
     NSBundle *theBundle = [NSBundle bundleForClass:[self class]];
     
     NSObject *debugLevelObj = [theBundle objectForInfoDictionaryKey:@"DebugLevel"];
     if (debugLevelObj != nil)
     {
         SetDebugLogLevel(DebugLevelNameToValue((NSString*)debugLevelObj));
     }
     
     NSObject *maxSourceSizeObj = [theBundle objectForInfoDictionaryKey:@"MaxSourceSizeToIndex"];
     int max = [(NSNumber*)maxSourceSizeObj intValue];
     if (max != 0)
     {
         DebugLog(DEBUG_LEVEL_DEBUG, @"Using MaxSourceSize=%d", max);
         MaxSourceSize = max;
     }
     else
     {
         NSLog(@"Error parsing MaxSourceSizeToIndex, using %d", MaxSourceSize);
     }
     
     // Precompile our regexes.

     LispDef1_RE = [NSRegularExpression regularExpressionWithPattern:LispDef1_pat
                                                             options:NSRegularExpressionCaseInsensitive
                                                               error:&err];
     LispDef2_RE = [NSRegularExpression regularExpressionWithPattern:LispDef2_pat
                                                             options:NSRegularExpressionCaseInsensitive
                                                               error:&err];
     LispDefun_RE = [NSRegularExpression regularExpressionWithPattern:LispDefun_pat
                                                              options:NSRegularExpressionCaseInsensitive
                                                                error:&err];
     LispDefunsetf_RE = [NSRegularExpression regularExpressionWithPattern:LispDefunsetf_pat
                                                                  options:NSRegularExpressionCaseInsensitive
                                                                    error:&err];
     LispDefmethod_RE = [NSRegularExpression regularExpressionWithPattern:LispDefmethod_pat
                                                                  options:NSRegularExpressionCaseInsensitive
                                                                    error:&err];
     LispDefmethodsetf_RE = [NSRegularExpression regularExpressionWithPattern:LispDefmethodsetf_pat
                                                                      options:NSRegularExpressionCaseInsensitive
                                                                        error:&err];
     LispDefgeneric_RE = [NSRegularExpression regularExpressionWithPattern:LispDefgeneric_pat
                                                                   options:NSRegularExpressionCaseInsensitive
                                                                     error:&err];
     LispDefgenericsetf_RE = [NSRegularExpression regularExpressionWithPattern:LispDefgenericsetf_pat
                                                                       options:NSRegularExpressionCaseInsensitive
                                                                         error:&err];
     LispDefclass_RE = [NSRegularExpression regularExpressionWithPattern:LispDefclass_pat
                                                                 options:NSRegularExpressionCaseInsensitive
                                                                   error:&err];
     LispDefstruct_RE = [NSRegularExpression regularExpressionWithPattern:LispDefstruct_pat
                                                                  options:NSRegularExpressionCaseInsensitive
                                                                    error:&err];
     LispDefvar_RE = [NSRegularExpression regularExpressionWithPattern:LispDefvar_pat
                                                               options:NSRegularExpressionCaseInsensitive
                                                                 error:&err];
     LispDefmacro_RE = [NSRegularExpression regularExpressionWithPattern:LispDefmacro_pat
                                                                 options:NSRegularExpressionCaseInsensitive
                                                                   error:&err];

     
     DebugLog(DEBUG_LEVEL_DEBUG, @"Static data has been initialized.");

 }
 
 
 
 static NSStringEncoding PossibleSourceTextEncodings[] = {	NSUTF8StringEncoding,

     NSMacOSRomanStringEncoding,
     NSISOLatin1StringEncoding,
     NSWindowsCP1252StringEncoding };

 
 // Tries to read the file using the encodings specified in
 // PossibleSourceTextEncodings, in order, until one succeeds.
 //
 // There's probably a better way to do this (TEC Sniffers?).  The
 // seemingly obvious way, stringWithContentsOfFile:usedEncoding:error,
 // doesn't work--apparently it just does something minimal, like
 // decide between UTF-8 and UCS-16 or something.
 
 - (NSString*)readContentsOfFile:(NSString*)pathToFile error:(NSError**)theError
 {

     int i;
     NSStringEncoding theEncoding;
     NSString *theSource = nil;
     NSData *data;
     
     DebugLog(DEBUG_LEVEL_DEBUG, @"Indexing %@", pathToFile);
     
     // Read the file.
     if (MaxSourceSize == NO_MAXIMUM)
     {
         data = [NSData dataWithContentsOfFile:pathToFile options:0 error:theError];
     }
     else
     {
         data = [NSData dataWithContentsOfFile:pathToFile maxSize:MaxSourceSize error:theError];
         if ([data length] == MaxSourceSize)
         {
             // This is not absolutely certain to be correct, since the file might just have been
             // MaxSourceSize bytes long.
             DebugLog(DEBUG_LEVEL_DEBUG, @"Truncated indexing of '%@' to %d bytes", pathToFile, MaxSourceSize);
         }
     }
     
     if (data == nil)
     {
         return nil;
     }
     
     // Try to convert the file contents to a string by trying the candidate
     // encodings, in order.
     for (i = 0; i < sizeof(PossibleSourceTextEncodings); i++)
     {
         theEncoding = PossibleSourceTextEncodings[i];
         DebugLog(DEBUG_LEVEL_VERBOSE, @"Trying encoding %d", theEncoding);
         theSource = [[[NSString alloc] initWithData:data encoding:theEncoding] autorelease];
         if (theSource != nil)
         {
             break;
         }
         else
         {
             DebugLog(DEBUG_LEVEL_DEBUG, @"Reading with encoding %d failed.", theEncoding);
         }
     }
     return theSource;

 }
 
 
 // Adds metadata values to the specified dictionary under the
 // specified key, using the specified regular expression.
 

 - (BOOL)addMatchesTo:(NSMutableDictionary *)attributes fromLine:(NSString *)line usingRE:(NSRegularExpression *)regex forKey:(NSString *)key

 {

     NSTextCheckingResult *match = [regex firstMatchInString:line options:NSMatchingAnchored range:NSMakeRange(0, [line length])];

     if (match)
     {

         NSLog(@"%s", [line UTF8String]);

         NSString *name = [line substringWithRange: [match rangeAtIndex:1]];

         [[attributes objectForKey:key] addObject:name];
         return YES;
     }
     else
     {
         return NO;
     }

 }
 
 
 // This is the method that does all the importing and indexing work.
 // It stuffs attributes into the specified dictionary.
 
 - (BOOL)importFile:(NSString *)inPathToFile contentType:(NSString *)inContentType attributes:(NSMutableDictionary *)inAttributes
 {

     BOOL theResult = NO;
     
     @try
     {
         NSAutoreleasePool *theAutoreleasePool = [[NSAutoreleasePool alloc] init];
         NSError *error = nil;
         NSString *source;
         
         [self initStaticData];
         
         source = [self readContentsOfFile:inPathToFile error:&error];
         if (source == nil)
         {
             if (error)
             {
                 NSLog(@"Lisp Metadata Importer: Could not process file '%@': %@", inPathToFile, error);
             }
             else
             {
                 NSLog(@"Lisp Metadata Importer: Could not process file '%@': unknown error", inPathToFile);
             }	
             return NO;
         }
         
         // Only process the first MaxSourceSize of the file.  To try to do more
         // invites the swapping death.
         if ([source length] > MaxSourceSize)
         {
             source = [source substringToIndex:MaxSourceSize];
         }
         
         NSMutableDictionary *moreAttributes = [[[NSMutableDictionary alloc] initWithCapacity:10] autorelease];
         [moreAttributes setObject:[NSMutableArray arrayWithCapacity:100] forKey:@"org_lisp_definitions"];
         [moreAttributes setObject:[NSMutableArray arrayWithCapacity:100] forKey:@"org_lisp_defuns"];
         [moreAttributes setObject:[NSMutableArray arrayWithCapacity:100] forKey:@"org_lisp_defmethods"];
         [moreAttributes setObject:[NSMutableArray arrayWithCapacity:100] forKey:@"org_lisp_defgenerics"];
         [moreAttributes setObject:[NSMutableArray arrayWithCapacity:100] forKey:@"org_lisp_defmacros"];
         [moreAttributes setObject:[NSMutableArray arrayWithCapacity:100] forKey:@"org_lisp_defvars"];
         [moreAttributes setObject:[NSMutableArray arrayWithCapacity:100] forKey:@"org_lisp_defclasses"];
         [moreAttributes setObject:[NSMutableArray arrayWithCapacity:100] forKey:@"org_lisp_defstructs"];
         
         
         // Divide the file contents into lines, using either CR or LF to end a line.
         NSCharacterSet *eol = [NSCharacterSet characterSetWithCharactersInString:@"\n\r"];
         NSArray *lines = [source componentsSeparatedByCharacterFromSet:eol];
         
         NSEnumerator *theEnum = [lines objectEnumerator];
         NSString *theLine;
         
         while (nil != (theLine = [theEnum nextObject]))
         {
             // The following check speeds the indexer up by roughly 6x.
             if (([theLine length] > 0) && ([theLine characterAtIndex:0] == '('))
             {
                 if (![self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDef1_RE forKey:@"org_lisp_definitions"])
                 {
                     // The first expression didn't fire, try the second one.
                     [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDef2_RE forKey:@"org_lisp_definitions"];
                 }
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefun_RE forKey:@"org_lisp_defuns"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefunsetf_RE forKey:@"org_lisp_defuns"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefmethod_RE forKey:@"org_lisp_defmethods"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefmethodsetf_RE forKey:@"org_lisp_defmethods"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefgeneric_RE forKey:@"org_lisp_defgenerics"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefgenericsetf_RE forKey:@"org_lisp_defgenerics"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefmacro_RE forKey:@"org_lisp_defmacros"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefvar_RE forKey:@"org_lisp_defvars"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefclass_RE forKey:@"org_lisp_defclasses"];
                 [self addMatchesTo:moreAttributes fromLine:theLine usingRE:LispDefstruct_RE forKey:@"org_lisp_defstructs"];
             }
             
         }
         
         // Add the complete source code as metadata.
         [moreAttributes setObject:source forKey:@"kMDItemTextContent"];
         
         [inAttributes addEntriesFromDictionary:moreAttributes];
         theResult = YES;
         [theAutoreleasePool release];
     }
     @catch (NSException *localException)
     {
         NSLog(@"Lisp Metadata Importer: Could not process file '%@' (Exception: %@)", inPathToFile, localException);
     }
     @finally
     {
     }
     return(theResult);

 }
 
 @end