//

//  AIContactMenu.m

//  Adium

//

//  Created by Adam Iser on 5/31/05.

//  Copyright 2006 The Adium Team. All rights reserved.

//

#import <Adium/AIContactControllerProtocol.h>

#import <Adium/AISortController.h>

#import <Adium/AIContactMenu.h>

#import <AIUtilities/AIMenuAdditions.h>

#import <AIUtilities/AIParagraphStyleAdditions.h>

#import <Adium/AIListContact.h>

#import <Adium/AIListGroup.h>

#import <Adium/AIContactList.h>

@interface AIContactMenu ()

- (id)initWithDelegate:(id<AIContactMenuDelegate>)inDelegate forContactsInObject:(AIListObject *)inContainingObject;

- (NSArray *)contactMenusForListObjects:(NSArray *)listObjects;

- (NSArray *)listObjectsForMenuFromArrayOfListObjects:(NSArray *)listObjects;

- (void)_updateMenuItem:(NSMenuItem *)menuItem;

@end

@implementation AIContactMenu

/*!

 * @brief Create a new contact menu

 * @param inDelegate Delegate in charge of adding menu items

 * @param inContainingObject Containing contact whose contents will be displayed in the menu, nil for all contacts/groups

 */

+ (id)contactMenuWithDelegate:(id<AIContactMenuDelegate>)inDelegate forContactsInObject:(AIListObject *)inContainingObject

{

	return [[[self alloc] initWithDelegate:inDelegate forContactsInObject:inContainingObject] autorelease];

}

/*!

 * @brief Init

 * @param inDelegate Delegate in charge of adding menu items

 * @param inContainingObject Containing contact whose contents will be displayed in the menu, nil for all contacts/groups

 */

- (id)initWithDelegate:(id<AIContactMenuDelegate>)inDelegate forContactsInObject:(AIListObject *)inContainingObject

{

	if ((self = [super init])) {

		[self setDelegate:inDelegate];

		containingObject = [inContainingObject retain];

		// Register as a list observer

		[[AIContactObserverManager sharedManager] registerListObjectObserver:self];

		// Register for contact list order notifications (so we can update our sorting)

		[[NSNotificationCenter defaultCenter] addObserver:self

									   selector:@selector(contactOrderChanged:)

										   name:Contact_OrderChanged

										 object:nil];

		[self rebuildMenu];

	}

	return self;

}

- (void)dealloc

{

	[[AIContactObserverManager sharedManager] unregisterListObjectObserver:self];

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	[containingObject release]; containingObject = nil;

	delegate = nil;

	[super dealloc];

}

/*!

 * @brief Set the containing object

 *

 * Updates the containing object, and rebuilds the menu items.

 */

- (void)setContainingObject:(AIListObject *)inContainingObject

{

	[containingObject release];

	containingObject = [inContainingObject retain];

	[self rebuildMenu];

}

/*!

 * @brief Returns the existing menu item for a specific contact

 *

 * @param contact AIListContact whose menu item to return

 * @return NSMenuItem instance for the contact

 */

- (NSMenuItem *)existingMenuItemForContact:(AIListContact *)contact

{

	return (menuItems ? [self menuItemWithRepresentedObject:contact] : nil);

}

- (void)contactOrderChanged:(NSNotification *)notification

{

	AIListObject *changedObject = [notification object];

	if (changedObject && changedObject == containingObject) {

		[self rebuildMenu];

	}

}

//Delegate -------------------------------------------------------------------------------------------------------------

#pragma mark Delegate

/*!

 * @brief Set our contact menu delegate

 */

- (void)setDelegate:(id<AIContactMenuDelegate>	)inDelegate

{

	delegate = inDelegate;

	//Ensure the the delegate implements all required selectors and remember which optional selectors it supports.

	if (delegate) NSParameterAssert([delegate respondsToSelector:@selector(contactMenu:didRebuildMenuItems:)]);

	delegateRespondsToDidSelectContact = [delegate respondsToSelector:@selector(contactMenu:didSelectContact:)];

	delegateRespondsToShouldIncludeContact = [delegate respondsToSelector:@selector(contactMenu:shouldIncludeContact:)];

	delegateRespondsToValidateContact = [delegate respondsToSelector:@selector(contactMenu:validateContact:)];

	shouldUseUserIcon = ([delegate respondsToSelector:@selector(contactMenuShouldUseUserIcon:)] &&

								 [delegate contactMenuShouldUseUserIcon:self]);

	shouldUseDisplayName = ([delegate respondsToSelector:@selector(contactMenuShouldUseDisplayName:)] &&

							[delegate contactMenuShouldUseDisplayName:self]);

	shouldDisplayGroupHeaders = ([delegate respondsToSelector:@selector(contactMenuShouldDisplayGroupHeaders:)] &&

								 [delegate contactMenuShouldDisplayGroupHeaders:self]);

	shouldSetTooltip = ([delegate respondsToSelector:@selector(contactMenuShouldSetTooltip:)] &&

								 [delegate contactMenuShouldSetTooltip:self]);	

}

- (id<AIContactMenuDelegate>	)delegate

{

	return delegate;

}

/*!

 * @brief Inform our delegate when the menu is rebuilt

 */

- (void)rebuildMenu

{

	[super rebuildMenu];

	// Update our values for display name and group header options.

	shouldUseDisplayName = ([delegate respondsToSelector:@selector(contactMenuShouldUseDisplayName:)] &&

							[delegate contactMenuShouldUseDisplayName:self]);

	shouldDisplayGroupHeaders = ([delegate respondsToSelector:@selector(contactMenuShouldDisplayGroupHeaders:)] &&

								 [delegate contactMenuShouldDisplayGroupHeaders:self]);

	[delegate contactMenu:self didRebuildMenuItems:[self menuItems]];

}

/*!

 * @brief Inform our delegate of menu selections

 */

- (void)selectContactMenuItem:(NSMenuItem *)menuItem

{

	if (delegateRespondsToDidSelectContact) {

		[delegate contactMenu:self didSelectContact:[menuItem representedObject]];

	}

}

//Contact Menu ---------------------------------------------------------------------------------------------------------

#pragma mark Contact Menu

/*!

 * @brief Build our contact menu items

 */

- (NSArray *)buildMenuItems

{

	NSArray *listObjects = nil;

	// If we're not given a containing object, use all the contacts

	if (containingObject == nil) {

		listObjects = adium.contactController.useContactListGroups ? adium.contactController.allGroups : adium.contactController.allContacts;

		/* The contact controller's -allContacts gives us an array with meta contacts expanded

		 * Let's put together our own list if we need to. This also gives our delegate an opportunity

		 * to decide if the contact should be included.

		 */

		if (!shouldDisplayGroupHeaders) {

			listObjects = [self listObjectsForMenuFromArrayOfListObjects:listObjects];

		}

		// Sort what we're given

		//XXX is this container right?

		listObjects = [listObjects sortedArrayUsingActiveSortControllerInContainer:adium.contactController.contactList];

	} else {

		// We can assume these are already sorted

		listObjects = [self listObjectsForMenuFromArrayOfListObjects:([containingObject conformsToProtocol:@protocol(AIContainingObject)] ?

																	  [(AIListObject<AIContainingObject> *)containingObject uniqueContainedObjects] :

																	  [NSArray arrayWithObject:containingObject])];

	}

	// Create menus for them

	return [self contactMenusForListObjects:listObjects];

}

/*!

* @brief Creates an array of list objects which should be presented in the menu, expanding any containing objects

 */

- (NSArray *)listObjectsForMenuFromArrayOfListObjects:(NSArray *)listObjects

{

	NSMutableArray	*listObjectArray = [NSMutableArray array];

	for (AIListObject *listObject in [[listObjects copy] autorelease]) {

		if ([listObject isKindOfClass:[AIListContact class]]) {

			/* Include if the delegate doesn't specify, or if the delegate approves the contact.

			 * Note that this includes a metacontact itself, not its contained objects.

			 */

			if (!delegateRespondsToShouldIncludeContact || [delegate contactMenu:self shouldIncludeContact:(AIListContact *)listObject]) {

				if (delegateRespondsToValidateContact)

					listObject = [delegate contactMenu:self validateContact:(AIListContact *)listObject];

				if (listObject)

					[listObjectArray addObject:listObject];

			}

		} else if ([listObject isKindOfClass:[AIListGroup class]]) {

			[listObjectArray addObjectsFromArray:[self listObjectsForMenuFromArrayOfListObjects:[(AIListGroup *)listObject uniqueContainedObjects]]];

		}

	}

	return listObjectArray;

}

/*!

* @brief Creates an array of NSMenuItems for each AIListObject

 */

- (NSArray *)contactMenusForListObjects:(NSArray *)listObjects

{

	NSMutableArray	*menuItemArray = [NSMutableArray array];

	for (AIListObject *listObject in listObjects) {

		// Display groups inline

		if ([listObject isKindOfClass:[AIListGroup class]]) {

			NSArray			*containedListObjects = [self listObjectsForMenuFromArrayOfListObjects:[(AIListObject<AIContainingObject> *)listObject uniqueContainedObjects]];

			// If there's any contained list objects, add ourself as a group and add the contained objects.

			if ([containedListObjects count] > 0) {

				// Create our menu item

				NSMenuItem *menuItem = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:@""

																							target:self

																							action:nil

																					 keyEquivalent:@""

																				 representedObject:listObject];

				// The group isn't clickable.

				[menuItem setEnabled:NO];

				[self _updateMenuItem:menuItem];

				// Add the group and contained objects to the array.

				[menuItemArray addObject:menuItem];

				[menuItemArray addObjectsFromArray:[self contactMenusForListObjects:containedListObjects]];

				[menuItem release];

			}

		} else {

			// Just add the menu item.

			NSMenuItem *menuItem = [[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:@""

																						target:self

																						action:@selector(selectContactMenuItem:)

																				 keyEquivalent:@""

																			 representedObject:listObject];

			[self _updateMenuItem:menuItem];

			[menuItemArray addObject:menuItem];

			[menuItem release];

		}

	}

	return menuItemArray;

}

/*!

 * @brief Update a menu item to reflect its contact's current status

 */

- (void)_updateMenuItem:(NSMenuItem *)menuItem

{

	AIListObject	*listObject = [menuItem representedObject];

	if (listObject) {

		[[menuItem menu] setMenuChangedMessagesEnabled:NO];

		if ([listObject isKindOfClass:[AIListContact class]]) {

			[menuItem setImage:[self imageForListObject:listObject usingUserIcon:shouldUseUserIcon]];

		}

		NSString *displayName = listObject.displayName;

		if (!displayName || (!shouldUseDisplayName && listObject.formattedUID)) {

			displayName = listObject.formattedUID;

		}

		if (displayName)

			[menuItem setTitle:displayName];

		[menuItem setToolTip:(shouldSetTooltip ? [listObject.statusMessage string] : nil)];

		[[menuItem menu] setMenuChangedMessagesEnabled:YES];

	}

}

/*!

 * @brief Update menu when a contact's status changes

 */

- (NSSet *)updateListObject:(AIListObject *)inObject keys:(NSSet *)inModifiedKeys silent:(BOOL)silent

{

	if ([inObject isKindOfClass:[AIListContact class]]) {

		//Update menu items to reflect status changes

		if ([inModifiedKeys containsObject:@"Online"] ||

			[inModifiedKeys containsObject:@"Connecting"] ||

			[inModifiedKeys containsObject:@"Disconnecting"] ||

			[inModifiedKeys containsObject:@"IdleSince"] ||

			[inModifiedKeys containsObject:@"StatusType"]) {

			//Note that this will return nil if we don't ahve a menu item for inObject

			NSMenuItem	*menuItem = [self existingMenuItemForContact:(AIListContact *)inObject];

			//Update the changed menu item (or rebuild the entire menu if this item should be removed or added)

			if (delegateRespondsToShouldIncludeContact) {

				BOOL shouldIncludeContact = [delegate contactMenu:self shouldIncludeContact:(AIListContact *)inObject];

				BOOL menuItemExists		  = (menuItem != nil);

				//If we disagree on item inclusion and existence, rebuild the menu.

				if (shouldIncludeContact != menuItemExists) {

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

					if (silent) {

						//If it's silent, wait for a pause before performing the actual rebuild

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

					} else {

						[self rebuildMenu];

					}

				} else { 

					[self _updateMenuItem:menuItem];

				}

			} else {

				[self _updateMenuItem:menuItem];

			}

		}

	}

    return nil;

}

@end