BrowserViewController.m #2

//
//  BrowserViewController.m
//  Perforce
//
//  Created by Adam Czubernat on 07.06.2013.
//  Copyright (c) 2013 Perforce Software, Inc. All rights reserved.
//

#import "BrowserViewController.h"

#import "P4UnifiedItem.h"
#import "P4ChangelistItem.h"
#import "P4UnreadItem.h"
#import "P4SearchItem.h"

#import "ErrorPanelController.h"
#import "SubmitPanelController.h"

NSString * const P4PasteboardTypeFile = @"com.perforce.P4PasteboardTypeFile";
NSString * const P4PasteboardTypeFolder = @"com.perforce.P4PasteboardTypeFolder";

@interface BrowserViewController () {

	NSArray *selectionPaths;
	
	NSString *loadingPath;
	NSArray *loadingSelection;
	
	NSString *searchQuery;
	NSString *searchDirectory;
	
	// Search
	__weak IBOutlet NSBox *searchBar;
	__weak IBOutlet NSTextField *searchLabel;
	__weak IBOutlet NSButton *searchOptionsButton;
	
	__weak IBOutlet NSButton *searchAllFilesButton;
	__weak IBOutlet NSButton *searchWorkspaceButton;
	__weak IBOutlet NSButton *searchDirectoryButton;
	
	__weak IBOutlet NSPopUpButton *searchFilterPopUp;
	__weak IBOutlet NSPopUpButton *searchTagsPopUp;
}

- (void)filteredTagsNotification:(NSNotification *)notification;
- (void)reloadSearchBar;
// Search bar actions
- (IBAction)searchOptionsPressed:(id)sender;
- (IBAction)searchAllFilesPressed:(id)sender;
- (IBAction)searchWorkspacePressed:(id)sender;
- (IBAction)searchDirectoryPressed:(id)sender;
- (IBAction)searchFilterPopUpAction:(id)sender;
- (IBAction)searchFilterTagsAction:(id)sender;

@property (strong, nonatomic) NSMutableArray *alertsArray;

@end

@implementation BrowserViewController
@synthesize delegate;
@synthesize searchBar;
@synthesize alertsArray;

- (id)init {
	return self = [self initWithNibName:NSStringFromClass([self class]) bundle:nil];
}

- (void)dealloc {
	[[NSNotificationCenter defaultCenter] removeObserver:self];
	[[rootItem class] removeObserver:self];
}

- (void)loadView {
	[super loadView];

	[[NSNotificationCenter defaultCenter]
	 addObserver:self selector:@selector(filteredTagsNotification:)
	 name:P4WorkspaceDefaultsTagFilterNotification
	 object:nil];
	
	NSNib *nib = [[NSNib alloc] initWithNibNamed:@"BrowserSearchBar" bundle:nil];
	[nib instantiateNibWithOwner:self topLevelObjects:NULL];

	[self setBackgroundColor:[NSUserDefaults colorForKey:kColorBackgroundColumn]];

	// Imitate click to hide more options
	[self searchOptionsPressed:searchOptionsButton];
}

#pragma mark - Private

- (void)filteredTagsNotification:(NSNotification *)notification {
	filteredTags = [[P4WorkspaceDefaults sharedInstance] filteredTags];
	[self refresh];
}

- (void)reloadSearchBar {
	P4SearchItem *item = (id)rootItem;
	
	// Label
	searchLabel.stringValue = [NSString stringWithFormat:@"\"%@\"", searchQuery];
	
	// Buttons
	searchAllFilesButton.state = !item.searchWorkspaceOnly;
	searchWorkspaceButton.state = item.searchWorkspaceOnly;
	[searchDirectoryButton setState:item.searchDirectory != nil];
	[searchDirectoryButton setHidden:!searchDirectory];
	[searchDirectoryButton setTitle:[NSString stringWithFormat:@"\"%@\"",
									 [searchDirectory lastPathComponent]]];
	[searchDirectoryButton sizeToFit];
	
	// Filter
	NSPopUpButton *popup = searchFilterPopUp;
	NSMutableArray *terms = [NSMutableArray array];
	if (([popup itemAtIndex:1].state = item.searchFilenames))
		[terms addObject:[popup itemAtIndex:1].title];
	if (([popup itemAtIndex:2].state = item.searchContents))
		[terms addObject:[popup itemAtIndex:2].title];
	if (([popup itemAtIndex:3].state = item.searchTags))
		[terms addObject:[popup itemAtIndex:3].title];
	
	[popup itemAtIndex:0].title = [terms componentsJoinedByString:@", "];
	
	// Tags filter
	popup = searchTagsPopUp;
	[popup removeAllItems];
	[popup addItemWithTitle:@"-"];
	[[popup itemAtIndex:0] setHidden:YES];
	
	NSArray *searchTags = [item searchResultTags];
	NSArray *searchFilteredTags = [item searchFilteredTags];
	[popup addItemsWithTitles:searchFilteredTags];
	[popup addItemsWithTitles:searchTags];
	
	for (NSString *tag in searchFilteredTags)
		[[popup itemWithTitle:tag] setState:NSOnState];
	
	if (searchFilteredTags.count)
		[popup itemAtIndex:0].title = [searchFilteredTags componentsJoinedByString:@", "];
	else if (!searchTags.count)
		[popup itemAtIndex:0].title = @"< No Tags >";
}

#pragma mark - Actions

- (IBAction)searchOptionsPressed:(NSButton *)sender {	
	CGRect frame = searchBar.frame;
	frame.size.height = sender.state ? 92.0f : 30.0f;
	searchBar.frame = frame;
}

- (IBAction)searchAllFilesPressed:(NSButton *)sender {
	if (!sender.state && (sender.state = NSOnState))
		return;
	P4SearchItem *item = (id)rootItem;
	item.searchWorkspaceOnly = NO;
	[self search:searchQuery];
}

- (IBAction)searchWorkspacePressed:(NSButton *)sender {
	if (!sender.state && (sender.state = NSOnState))
		return;
	P4SearchItem *item = (id)rootItem;
	item.searchWorkspaceOnly = YES;
	[self search:searchQuery];
}

- (IBAction)searchDirectoryPressed:(NSButton *)sender {
	P4SearchItem *item = (id)rootItem;
	item.searchDirectory = sender.state ? searchDirectory : nil;
	[self search:searchQuery];
}

- (IBAction)searchFilterPopUpAction:(NSPopUpButton *)sender {
	P4SearchItem *item = (id)rootItem;

	NSInteger index = [sender indexOfSelectedItem];
	if (index == 1)
		item.searchFilenames = !item.searchFilenames;
	else if (index == 2)
		item.searchContents = !item.searchContents;
	else if (index == 3)
		item.searchTags	= !item.searchTags;
	
	[self search:searchQuery];
}

- (IBAction)searchFilterTagsAction:(id)sender {
	P4SearchItem *item = (id)rootItem;
	
	NSString *tag = [sender titleOfSelectedItem];
	
	NSMutableArray *tags;
	tags = [NSMutableArray arrayWithArray:[item searchFilteredTags]];
	if ([tags containsObject:tag])
		[tags removeObject:tag];
	else
		[tags addObject:tag];
	[item setSearchFilteredTags:tags];
	
	[self search:searchQuery];
}

#pragma mark - Public

- (P4Item *)rootItem { return rootItem; }

- (P4Item *)workingItem { return workingItem; }

- (void)setRootItem:(P4Item *)item {
	filteredTags = [[P4WorkspaceDefaults sharedInstance] filteredTags];
	[[rootItem class] removeObserver:self];
	rootItem = item;
	[self setWorkingItem:item];
	[[rootItem class] addObserver:self];

	if ([item isKindOfClass:[P4SearchItem class]]) {
		if (!searchQuery) {
			searchQuery = ((P4SearchItem *)item).searchQuery;
			searchDirectory = ((P4SearchItem *)item).searchDirectory;
		}
		[self reloadSearchBar];
	}
}

- (void)setWorkingItem:(P4Item *)item {
	
	if (workingItem == item)
		return;
	
	workingItem = item;

	if (loadingPath)
		return;
	
	if ([delegate respondsToSelector:@selector(browserView:didChangeWorkingItem:)])
		[delegate browserView:self didChangeWorkingItem:workingItem];
	
	NSArray *selection = [NSArray arrayWithObjects:item, nil];
	if (item == rootItem) // Don't select root item
		selection = nil;
	[self selectionChanged:selection];
}

- (void)setSelectedItems:(NSArray *)selectedItems {
	
	P4Item *item = [selectedItems firstObject];
	if (!item)
		return;
	
	P4Item *parent = [item parent];
	BOOL directory = [item isDirectory];
	
	// Set current working item
	[self setWorkingItem:directory ? item : parent];
	
	if (!directory) {
		NSIndexSet *indexes = [parent.children indexesOfObjectsPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop) {
			return [selectedItems indexOfObjectIdenticalTo:obj] != NSNotFound;
		}];
		[self setSelectedIndexes:indexes];
	}
}

- (void)setSelectedIndexes:(NSIndexSet *)indexes PS_ABSTRACT_METHOD

- (void)loadPath:(NSString *)path {

	NSString *workingPath = workingItem.remotePath;
	
	// Reset root path if new path isn't descendant
	if (rootPath && ![path isSubpath:rootPath])
		rootPath = nil;
	
	// Check if root is compatible with path
	P4Item *newRoot = nil;
	if ([path hasPrefix:@"/"]) {
		if (![rootItem isKindOfClass:[P4UnifiedItem class]])
			newRoot = [[P4UnifiedItem alloc] initWithParent:nil];
	} else if ([path hasPrefix:@"unread://"]) {
		if (![rootItem isKindOfClass:[P4UnreadItem class]])
			newRoot = [[P4UnreadItem alloc] initWithParent:nil];
	} else if ([path hasPrefix:@"changelist://nondeleted"]) {
		if (![rootItem.path hasPrefix:@"changelist://nondeleted"])
			newRoot = [[P4ChangelistItem alloc] initWithParent:nil];
		[(P4ChangelistItem *)newRoot setType:@"nondeleted"];
		[(P4ChangelistItem *)newRoot setPredicate:
		 [NSPredicate predicateWithFormat:@"isDeleted == NO"]];
	} else if ([path hasPrefix:@"changelist://deleted"]) {
		if (![rootItem.path hasPrefix:@"changelist://deleted"])
			newRoot = [[P4ChangelistItem alloc] initWithParent:nil];
		[(P4ChangelistItem *)newRoot setType:@"deleted"];
		[(P4ChangelistItem *)newRoot setPredicate:
		 [NSPredicate predicateWithFormat:@"isDeleted == YES"]];
	} else if ([path hasPrefix:@"search://"]) {
		if (![rootItem isKindOfClass:[P4SearchItem class]])
			newRoot = [[P4SearchItem alloc] initWithParent:nil];
	}
	
	// Set new root
	if (newRoot) {
		[[rootItem class] removeObserver:self];
		[[newRoot class] addObserver:self];
		rootItem = newRoot;
	}
	
	// Load search
	NSString *search = ([path hasPrefix:@"search://"] ?
						[path substringFromIndex:@"search://".length] : nil);
	if (search || searchQuery) {
		searchQuery = search;
		if (!search)
			searchDirectory = nil;
		else if (!searchDirectory && ![workingPath isEqualTo:@"//"])
			searchDirectory = workingPath;
		if (search) {
			[(P4SearchItem *)rootItem setSearchQuery:search];
			loadingPath = path;
			[rootItem reload];
			[self reloadSearchBar];
		}
		if ([delegate respondsToSelector:@selector(browserView:didChangeSearchQuery:)])
			[delegate browserView:self didChangeSearchQuery:search];
	}
	
	P4Item *cachedItem = [rootItem itemAtPath:path];
	if (!cachedItem || loadingPath) {
		loadingPath = path;
		[self willLoadPath:path];
		if (![path hasSuffix:@"/"])
			path = [path stringByDeletingPath];
		path = [path directoryPath];
		[rootItem loadPath:path];
	} else if (rootItem == cachedItem) {
		[self setRootItem:rootItem];
	} else if (cachedItem) {
		[self setSelectedItems:@[ cachedItem ]];
	}
}

- (void)loadRootPath:(NSString *)path {
	rootPath = path;
	[self loadPath:path];
}

- (void)search:(NSString *)query {
	PSLog(@"Searching \"%@\"", query);
	[self loadPath:[@"search://" stringByAppendingString:query]];
}

- (void)reload {

	// Retain current working item information
	NSString *path = workingItem.path;
	NSArray *selection = [[self selectedItems] valueForKey:@"path"];
	P4SearchItem *searchItem = [rootItem isKindOfClass:[P4SearchItem class]] ? (id)rootItem : nil;
	
	// Reload root
	rootItem = nil;
	workingItem = nil;

	loadingPath = path;
	loadingSelection = selection;
	[self loadPath:path];
	
	// Retrieve search information
	if (searchItem) {
		P4SearchItem *item = (id)rootItem;
		item.searchDirectory = searchItem.searchDirectory;
		item.searchWorkspaceOnly = searchItem.searchWorkspaceOnly;
		item.searchFilenames = searchItem.searchFilenames;
		item.searchContents = searchItem.searchContents;
		item.searchTags = searchItem.searchTags;
		item.searchFilteredTags = searchItem.searchFilteredTags;
		[self reloadSearchBar];
	}		
}

- (void)refresh PS_ABSTRACT_METHOD

- (NSArray *)selectedItems PS_ABSTRACT_METHOD

- (void)willLoadPath:(NSString *)path PS_ABSTRACT_METHOD

- (void)showVersions:(P4Item *)item PS_ABSTRACT_METHOD

- (void)showFolderHistory:(P4Item *)item PS_ABSTRACT_METHOD

- (void)editItemName:(P4Item *)item PS_ABSTRACT_METHOD

- (void)setBackgroundColor:(NSColor *)color PS_ABSTRACT_METHOD

- (void)setDraggingSourceOperationMask:(NSDragOperation)mask forLocal:(BOOL)isLocal PS_ABSTRACT_METHOD

#pragma mark - NSResponder

- (BOOL)validateMenuItem:(NSMenuItem *)menuItem {
	SEL action = menuItem.action;
	
	if (action == @selector(copy:)) {
		if (selectionPaths.count > 0) {
			// Check if any item is deleted
			for (P4Item *item in [self selectedItems])
				if (item.isDeleted)
					return NO;
			return YES;
		}
	} else if (action == @selector(paste:)) {
		// Check if can paste into working item
		if (workingItem.isDirectory && workingItem.isEditable) {
			NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
			if ([pasteboard availableTypeFromArray:
				 @[ NSFilenamesPboardType, P4PasteboardTypeFile ]])
				return YES;
		}
	} else if (action == @selector(delete:)) {
		if (selectionPaths.count > 0) {
			// Check if all items can be deleted
			for (P4Item *item in [self selectedItems])
				if (!item.isEditable)
					return NO;
			return YES;
		}
	} else if (action == @selector(toggleQuickLookPreviewPanel:)) {
		if (selectionPaths.count > 0)
			return YES;
	}
		
	return NO;
}

- (void)copy:(id)sender {
	NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
	[self writeItems:[self selectedItems] toPasteboard:pasteboard];
}

- (void)paste:(id)sender {
	NSPasteboard *pasteboard = [NSPasteboard generalPasteboard];
	NSMutableArray *files = [NSMutableArray array];
	[files addObjectsFromArray:[pasteboard propertyListForType:NSFilenamesPboardType]];
	[files addObjectsFromArray:[pasteboard propertyListForType:P4PasteboardTypeFile]];
	if (!files.count)
		return;
	
	[workingItem performAction:@selector(pasteFiles:)
						 object:files
					  delegate:[self.view.window windowController]];
}

- (void)delete:(id)sender {
	if (!selectionPaths.count)
		return;
	
	[rootItem performAction:@selector(deleteItems:)
					 object:[self selectedItems]
				   delegate:[self.view.window windowController]];
}

- (void)toggleQuickLookPreviewPanel:(id)sender {
	
	QLPreviewPanel *previewPanel = [QLPreviewPanel sharedPreviewPanel];
	// Dismiss if visible
	if ([QLPreviewPanel sharedPreviewPanelExists] && [previewPanel isVisible]) {
		[previewPanel orderOut:nil];
		return;
	}
	
	if (!selectionPaths)
		return;
	
	[previewPanel updateController];
	[previewPanel makeKeyAndOrderFront:nil];
}

#pragma mark - Protected

- (void)selectionChanged:(NSArray *)items {
	
	// Check if last selection changed
	NSArray *paths = [items valueForKey:@"path"];
	if ([selectionPaths isEqualToArray:paths])
		return;
	
	selectionPaths = paths;
	
	if ([delegate respondsToSelector:@selector(browserView:didChangeSelectedItems:)])
		[delegate browserView:self didChangeSelectedItems:items];
}

- (void)renameItem:(P4Item *)item name:(NSString *)newName {
	
	if ([item.name isEqualToString:newName])
		return;
	
	[item performAction:@selector(rename:) object:newName delegate:[self.view.window windowController]];
}

- (BOOL)insertFiles:(NSArray *)paths intoItem:(P4Item *)item copy:(BOOL)copy {
	
	if (!item.isDirectory || !item.isEditable)
		return NO;
	
	if (!copy) {
		// Check if moving into the same directory
		NSString *itemPath = [item.localPath stringByRemovingSuffix:@"/"];
		for (NSString *path in paths) {
			if ([[path stringByDeletingLastPathComponent] isEqualCaseInsensitive:itemPath])
				return NO;
		}
	}
	
	// Insert files
	SEL selector = copy ? @selector(copyFiles:) : @selector(moveFiles:);
	[item performAction:selector object:paths delegate:[self.view.window windowController]];
	return YES;
}

- (BOOL)hasFilteredTagsForItem:(P4Item *)item {
	for (NSString *tag in filteredTags)
		if ([item hasTag:tag])
			return YES;
	return NO;
}

- (BOOL)alertWithErrorDescriptionAlreadyExists:(NSString *)erorDescription
{
    for (ErrorPanelController *alert in self.alertsArray) {
        if ([alert.message isEqualToString:erorDescription]) {
            return YES;
        }
    }
    
    return NO;
}

- (void)createAlertWithError:(NSError *)error
{
    if (!self.alertsArray) {
        self.alertsArray = [NSMutableArray new];
    }
    
    ErrorPanelController *alert = [[ErrorPanelController alloc] init];
    if([error.localizedDescription rangeOfString:@"Connect to server failed"].location != NSNotFound) {
        [alert setTitle:@"\nCommunication Error"];
        [alert setMessage:@"It seems like we lost connection to the server. Please ensure that you are on the network."];
    } else {
        [alert setTitle:@"\nLoading failed"];
        [alert setMessage:error.localizedDescription];
    }
    // only display the dialog if it isn't already displayed
    if(![self alertWithErrorDescriptionAlreadyExists:alert.message]) {
        [alert presentWithMainWindow];
        __weak typeof(alert) weakAlert = alert;
        __weak typeof(self) weakSelf = self;
        [alert setCompletionBlock:^{
            [weakSelf.alertsArray removeObject:weakAlert];
        }];
        [self.alertsArray addObject:alert];
    }
}

- (void)failWithError:(NSError *)error {
    // Don't show alert for session expiration
    if (error.code == P4ErrorSessionExpired)
        return;
    
    if (![self alertWithErrorDescriptionAlreadyExists:error.localizedDescription]) {
        [self createAlertWithError:error];
    }
}

#pragma mark Drag and Drop

- (BOOL)acceptDrop:(id<NSDraggingInfo>)info target:(P4Item *)target {
	if (!target)
		return NO;

	BOOL copy = info.draggingSourceOperationMask == NSDragOperationCopy;

	NSPasteboard *pasteboard = [info draggingPasteboard];
	NSMutableArray *files = [NSMutableArray array];
	[files addObjectsFromArray:[pasteboard propertyListForType:NSFilenamesPboardType]];
	[files addObjectsFromArray:[pasteboard propertyListForType:P4PasteboardTypeFile]];
	if (!files.count)
		return NO;
	
	[target performAction:copy ? @selector(pasteFiles:) : @selector(moveFiles:)
				   object:files
				 delegate:[self.view.window windowController]];
	return YES;
//	return [self insertFiles:files intoItem:target copy:copy];
}

- (BOOL)writeItems:(NSArray *)items toPasteboard:(NSPasteboard *)pasteboard {

	NSMutableArray *localFiles = [NSMutableArray array];
	NSMutableArray *depotFiles = [NSMutableArray array];
	NSMutableDictionary *pboardTypes = [NSMutableDictionary dictionary];
	
	for (P4Item *item in items) {
		if (!item.metadata || item.isTracked) {
			if (!localFiles.count) {
				[pboardTypes setObject:localFiles forKey:NSFilenamesPboardType];
				[self setDraggingSourceOperationMask:NSDragOperationEvery forLocal:NO];
				[self setDraggingSourceOperationMask:NSDragOperationEvery forLocal:YES];
			}
			[localFiles addObject:item.localPath];
			
		} else if ([item isKindOfClass:[P4UnifiedItem class]]) {
			if (!depotFiles.count) {
				[pboardTypes setObject:depotFiles forKey:P4PasteboardTypeFile];
				[pboardTypes setObject:depotFiles forKey:NSFilesPromisePboardType];
				[self setDraggingSourceOperationMask:NSDragOperationEvery forLocal:NO];
				[self setDraggingSourceOperationMask:NSDragOperationEvery forLocal:YES];
			}
			[depotFiles addObject:item.remotePath];
		}
	};

	if (!pboardTypes.count)
		return NO;
	
	if (items.count == 1 && [[items firstObject] isDirectory])
		[pboardTypes setObject:[[items firstObject] path] forKey:P4PasteboardTypeFolder];
	
	[pasteboard declareTypes:pboardTypes.allKeys owner:self];
	for (NSString *type in pboardTypes)
		[pasteboard setPropertyList:[pboardTypes objectForKey:type] forType:type];
	
    return YES;
}

- (NSArray *)namesOfPromisedItems:(NSArray *)items droppedAtDestination:(NSURL *)destination {
	
	// Insert files
	P4ItemAction *action = [P4ItemAction actionForItem:rootItem name:nil selector:nil];
	action.delegate = [self.view.window windowController];
	[action performAction];
	
	return [rootItem downloadItems:items destination:destination.path];
}

#pragma mark - Keyboard support

- (void)moveToBeginningOfDocument:(id)sender {
	P4Item *parent = workingItem.parent;
	if (parent)
		[self loadPath:parent.path];
	else
		[self.nextResponder doCommandBySelector:_cmd];
}

- (void)moveToEndOfDocument:(id)sender {
	NSArray *selection = [self selectedItems];
	if (selection.count == 1) {
		P4Item *item = [selection lastObject];
		if ([item isDirectory]) {
			[self loadPath:[item path]];
			return;
		}
	}
	[self.nextResponder doCommandBySelector:_cmd];
}

#pragma mark - P4Item delegate

- (void)itemDidLoad:(P4Item *)item {
	
	if ([item isKindOfClass:[P4SearchItem class]])
		[self reloadSearchBar];
	
	// Item loaded path
	if (loadingPath) {
		
		NSString *path = loadingPath;
		NSArray *selection = loadingSelection;
		loadingPath = nil, loadingSelection = nil;
		
		P4Item *item = [rootItem itemAtPath:path];
		if (item) {
			
			// Change working item
			workingItem = nil;
			[self setSelectedItems:@[ item ]];
			
			// Find items for previously selected paths
			if (selection) {
                NSIndexSet *indexes = nil;
                if([item isDirectory]) {
                    indexes = [item.children indexesOfObjectsPassingTest:^BOOL(P4Item *child, NSUInteger idx, BOOL *stop) {
					return [selection containsObject:child.path];
				}];
                }
				
				[self setSelectedIndexes:indexes];
			
			}
		} else {
			[self setSelectedItems:@[ rootItem ]];
			[self failWithError:[NSError errorWithFormat:@"Couldn't find file at %@", path]];
		}
	}
}

- (void)itemDidInvalidate:(id)item PS_ABSTRACT_METHOD

- (void)item:(id)item didFailWithError:(NSError *)error PS_ABSTRACT_METHOD

@end