source: branches/CoreData/SapphireFrappliance/MetaData/SapphireMObjects/SapphireCategoryDirectory.m @ 588

#import "SapphireCategoryDirectory.h"
#import "SapphireBasicDirectoryFunctionsImports.h"

@implementation SapphireCategoryDirectory

- (id)initWithEntity:(NSEntityDescription *)entity insertIntoManagedObjectContext:(NSManagedObjectContext *)context
{
        self = [super initWithEntity:entity insertIntoManagedObjectContext:context];
        if(self == nil)
                return self;
        
        cachedLookup = [[NSMutableDictionary alloc] init];
        cachedFiles = [[NSMutableArray alloc] init];
        cachedDirs = [[NSMutableArray alloc] init];
        cachedMetaFiles = [[NSMutableArray alloc] init];
        Basic_Directory_Function_Inits

        return self;
}

- (void) dealloc
{
        [cachedLookup release];
        [cachedFiles release];
        [cachedDirs release];
        [cachedMetaFiles release];
        Basic_Directory_Function_Deallocs
        [super dealloc];
}


- (NSString *)metaFilesValue;
{
        return nil;
}

- (NSString *)dirsValue
{
        return nil;
}

- (NSString *)fileNameValue
{
        return nil;
}

- (NSString *)dirNameValue
{
        return nil;
}

- (NSPredicate *)metaFileFetchPredicate
{
        return nil;
}

- (void)defaultFileSort:(NSMutableArray *)files
{
        [files sortUsingSelector:@selector(compare:)];
}

- (void)defaultDirectorySort:(NSMutableArray *)dirs
{
        [dirs sortUsingSelector:@selector(compare:)];
}

- (NSMutableArray *)internalFileFetch
{
        NSString *metaFilesKey = [self metaFilesValue];
        if(metaFilesKey == nil)
                return nil;
        
        NSMutableArray *files = [[[self valueForKeyPath:metaFilesKey] allObjects] mutableCopy];
        if(filterPredicate != nil)
                [files filterUsingPredicate:filterPredicate];
        
        return [files autorelease];
}

- (NSArray *)files
{
        return cachedFiles;
}

- (NSMutableArray *)internalDirectoryFetch
{
        NSString *dirsKey = [self dirsValue];
        if(dirsKey == nil)
                return nil;
        
        NSMutableArray *dirs = [[[self valueForKeyPath:dirsKey] allObjects] mutableCopy];
        if(filterPredicate != nil)
        {
                int i, count = [dirs count];
                for(i=0; i<count; i++)
                {
                        id <SapphireDirectory> dir = [dirs objectAtIndex:i];
                        if(![dir containsFileMatchingFilterPredicate:filterPredicate])
                        {
                                [dirs removeObjectAtIndex:i];
                                i--;
                                count--;
                        }
                }
        }

        [cachedMetaFiles setArray:dirs];
        return [dirs autorelease];
}

- (NSArray *)directories
{
        return cachedDirs;
}

- (SapphireFileMetaData *)metaDataForFile:(NSString *)file
{
        return [cachedLookup objectForKey:file];
}

- (id <SapphireDirectory>)metaDataForDirectory:(NSString *)directory
{
        return [cachedLookup objectForKey:directory];
}

- (void)reloadDirectoryContents
{
        [[self managedObjectContext] refreshObject:self mergeChanges:YES];
        [cachedLookup removeAllObjects];
        [cachedFiles removeAllObjects];
        [cachedDirs removeAllObjects];
        
        NSString *fileNameKey = [self fileNameValue];
        NSMutableArray *files = [self internalFileFetch];
        int sortValue = self.sortMethodValue;
        if(sortValue == 0)
                [self defaultFileSort:files];

        NSEnumerator *fileEnum = [files objectEnumerator];
        SapphireFileMetaData *file;
        while((file = [fileEnum nextObject]) != nil)
        {
                NSString *name = [file valueForKeyPath:fileNameKey];
                [cachedLookup setObject:file forKey:name];
                [cachedFiles addObject:name];
        }
        
        NSString *dirNameKey = [self dirNameValue];
        NSMutableArray *dirs = [self internalDirectoryFetch];
        if(sortValue == 0)
                [self defaultDirectorySort:dirs];

        NSEnumerator *dirEnum = [dirs objectEnumerator];
        SapphireDirectoryMetaData *dir;
        while((dir = [dirEnum nextObject]) != nil)
        {
                NSString *name = [dir valueForKeyPath:dirNameKey];
                [cachedLookup setObject:dir forKey:name];
                [cachedDirs addObject:name];
        }
        
        [delegate directoryContentsChanged];
}

- (NSString *)path
{
        return [@"@MOVIES" stringByAppendingPathComponent:[[self entity] name]];
}

- (NSString *)coverArtSearch:(NSString *)path PathUpToParents:(int)parents
{
        NSString *ret = searchCoverArtExtForPath([path stringByAppendingPathComponent:@"cover"]);
        if(ret != nil)
                return ret;
        
        if(parents != 0)
                return [self coverArtSearch:[path stringByDeletingLastPathComponent] PathUpToParents:parents-1];
        return nil;
}

- (NSString *)coverArtPath
{
        NSString *path = [self path];
        int count = [[path pathComponents] count];
        return [self coverArtSearch:[[SapphireMetaDataSupport collectionArtPath] stringByAppendingPathComponent:path] PathUpToParents:count];
}

- (void)refreshAllObjects
{
        NSManagedObjectContext *moc = [self managedObjectContext];
        NSEnumerator *objEnum;
        NSManagedObject *obj;
        
        objEnum = [cachedLookup objectEnumerator];
        while((obj = [objEnum nextObject]) != nil)
        {
                [moc refreshObject:obj mergeChanges:YES];
        }

        [moc refreshObject:self mergeChanges:YES];
}

- (id <SapphireDirectory>)parentDirectory
{
        return nil;
}

- (void)invokeOnAllFiles:(NSInvocation *)fileInv
{
        NSArray *files = cachedMetaFiles;
        if(![files count])
                files = [self internalFileFetch];
        if([files count])
        {
                SapphireFileMetaData *file;
                NSEnumerator *fileEnum = [files objectEnumerator];
                while((file = [fileEnum nextObject]) != nil)
                {
                        [fileInv invokeWithTarget:file];
                }
        }
}

- (BOOL)checkPredicate:(NSPredicate *)pred
{
        NSPredicate *fetchPred = [self metaFileFetchPredicate];
        if(fetchPred != nil)
        {
                NSPredicate *final = [NSCompoundPredicate andPredicateWithSubpredicates:[NSArray arrayWithObjects:pred, fetchPred, filterPredicate, nil]];
                return entityExists(SapphireFileMetaDataName, [self managedObjectContext], final);      
        }
        
        NSArray *files = cachedMetaFiles;
        if(![files count])
                files = [self internalFileFetch];
        int i, count = [files count];
        for(i=0; i<count; i++)
                if([pred evaluateWithObject:[files objectAtIndex:i]])
                        return YES;
        
        return NO;
}

- (void)getSubFileMetasWithDelegate:(id <SapphireMetaDataScannerDelegate>)subDelegate skipDirectories:(NSMutableSet *)skip
{
}

- (void)scanForNewFilesWithDelegate:(id <SapphireMetaDataScannerDelegate>)subDelegate skipDirectories:(NSMutableSet *)skip
{
}

- (void)cancelImport
{
}

- (void)resumeImport
{
}

#define RECURSIVE_FUNCTIONS_ALREADY_DEFINED

#include "SapphireBasicDirectoryFunctions.h"

@end