/* 

  * Adium is the legal property of its developers, whose names are listed in the copyright file included

  * with this source distribution.

  * 

  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU

  * General Public License as published by the Free Software Foundation; either version 2 of the License,

  * or (at your option) any later version.

  * 

  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even

  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

  * Public License for more details.

  * 

  * You should have received a copy of the GNU General Public License along with this program; if not,

  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

  */

 #import "AIContactController.h"

 #import "AISCLViewPlugin.h"

 #import <Adium/AIContactHidingController.h>

 #import <Adium/AIAccountControllerProtocol.h>

 #import <Adium/AIInterfaceControllerProtocol.h>

 #import <Adium/AILoginControllerProtocol.h>

 #import <Adium/AIMenuControllerProtocol.h>

 #import <Adium/AIToolbarControllerProtocol.h>

 #import <Adium/AIContactAlertsControllerProtocol.h>

 #import <AIUtilities/AIArrayAdditions.h>

 #import <AIUtilities/AIDictionaryAdditions.h>

 #import <AIUtilities/AIFileManagerAdditions.h>

 #import <AIUtilities/AIMenuAdditions.h>

 #import <AIUtilities/AIToolbarUtilities.h>

 #import <AIUtilities/AIApplicationAdditions.h>

 #import <AIUtilities/AIImageAdditions.h>

 #import <AIUtilities/AIStringAdditions.h>

 #import <Adium/AIAccount.h>

 #import <Adium/AIChat.h>

 #import <Adium/AIContentMessage.h>

 #import <Adium/AIListContact.h>

 #import <Adium/AIListGroup.h>

 #import <Adium/AIListObject.h>

 #import <Adium/AIMetaContact.h>

 #import <Adium/AIService.h>

 #import <Adium/AISortController.h>

 #import <Adium/AIUserIcons.h>

 #import <Adium/AIServiceIcons.h>

 #import <Adium/AIListBookmark.h>

 #import <Adium/AIContactList.h>

 #define KEY_FLAT_GROUPS					@"FlatGroups"			//Group storage

 #define KEY_FLAT_CONTACTS				@"FlatContacts"			//Contact storage

 #define KEY_FLAT_METACONTACTS			@"FlatMetaContacts"		//Metacontact objectID storage

 #define KEY_BOOKMARKS					@"Bookmarks"

 #define	OBJECT_STATUS_CACHE				@"Object Status Cache"

 #define TOP_METACONTACT_ID				@"TopMetaContactID"

 #define KEY_IS_METACONTACT				@"isMetaContact"

 #define KEY_OBJECTID					@"objectID"

 #define KEY_METACONTACT_OWNERSHIP		@"MetaContact Ownership"

 #define CONTACT_DEFAULT_PREFS			@"ContactPrefs"

 #define	SHOW_GROUPS_MENU_TITLE			AILocalizedString(@"Show Groups",nil)

 #define SHOW_GROUPS_IDENTIFER			@"ShowGroups"

 #define SERVICE_ID_KEY					@"ServiceID"

 #define UID_KEY							@"UID"

 @interface AIListObject ()

 @property (readwrite, nonatomic) CGFloat orderIndex;

 @end

 @interface AIMetaContact ()

 - (void)removeObject:(AIListObject *)inObject;

 - (BOOL)addObject:(AIListObject *)inObject;

 - (AIListContact *)preferredContactForContentType:(NSString *)inType;

 @end

 @interface AIListGroup ()

 - (void)removeObject:(AIListObject *)inObject;

 - (BOOL)addObject:(AIListObject *)inObject;

 @end

 @interface AIContactList ()

 - (void)removeObject:(AIListObject *)inObject;

 - (BOOL)addObject:(AIListObject *)inObject;

 @end

 @interface AIListBookmark ()

 //Freshly minted bookmarks don't know where to restore to, since they have no serverside counterpart. This tells them.

 - (void)setInitialGroup:(AIListGroup *)inGroup;

 @end

 @interface AIContactController ()

 @property (readwrite, nonatomic) BOOL useOfflineGroup;

 - (void)saveContactList;

 - (void)_loadBookmarks;

 - (void)_didChangeContainer:(AIListObject<AIContainingObject> *)inContainingObject object:(AIListObject *)object;

 - (void)prepareShowHideGroups;

 - (void)_performChangeOfUseContactListGroups;

 //MetaContacts

 - (BOOL)_restoreContactsToMetaContact:(AIMetaContact *)metaContact;

 - (void)_restoreContactsToMetaContact:(AIMetaContact *)metaContact fromContainedContactsArray:(NSArray *)containedContactsArray;

 - (void)addContact:(AIListContact *)inContact toMetaContact:(AIMetaContact *)metaContact;

 - (BOOL)_performAddContact:(AIListContact *)inContact toMetaContact:(AIMetaContact *)metaContact;

 - (void)removeContact:(AIListContact *)inContact fromMetaContact:(AIMetaContact *)metaContact;

 - (void)_loadMetaContactsFromArray:(NSArray *)array;

 - (void)_saveMetaContacts:(NSDictionary *)allMetaContactsDict;

 - (void)_storeListObject:(AIListObject *)listObject inMetaContact:(AIMetaContact *)metaContact;

 @end

 @implementation AIContactController

 - (id)init

 {

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

 		//

 		contactDict = [[NSMutableDictionary alloc] init];

 		groupDict = [[NSMutableDictionary alloc] init];

 		metaContactDict = [[NSMutableDictionary alloc] init];

 		bookmarkDict = [[NSMutableDictionary alloc] init];

 		contactToMetaContactLookupDict = [[NSMutableDictionary alloc] init];

 		contactLists = [[NSMutableArray alloc] init];

 		contactPropertiesObserverManager = [AIContactObserverManager sharedManager];

 	}

 	return self;

 }

 - (void)controllerDidLoad

 {	

 	//Default contact preferences

 	[adium.preferenceController registerDefaults:[NSDictionary dictionaryNamed:CONTACT_DEFAULT_PREFS

 																		forClass:[self class]]

 										  forGroup:PREF_GROUP_CONTACT_LIST];

 	contactList = [[AIContactList alloc] initWithUID:ADIUM_ROOT_GROUP_NAME];

 	[contactLists addObject:contactList];

 	//Root is always "expanded"

 	[contactList setExpanded:YES];

 	//Show Groups menu item

 	[self prepareShowHideGroups];

 	//Observe content (for preferredContactForContentType:forListContact:)

     [[NSNotificationCenter defaultCenter] addObserver:self

                                    selector:@selector(didSendContent:)

                                        name:CONTENT_MESSAGE_SENT

                                      object:nil];

 	[self loadContactList];

 	[self sortContactList];

 	[adium.preferenceController registerPreferenceObserver:self forGroup:PREF_GROUP_CONTACT_LIST_DISPLAY];

 }

 - (void)controllerWillClose

 {

 	[self saveContactList];

 }

 - (void)dealloc

 {

 	[adium.preferenceController unregisterPreferenceObserver:self];

 	[contactDict release];

 	[groupDict release];

 	[metaContactDict release];

 	[contactToMetaContactLookupDict release];

 	[contactLists release];

 	[bookmarkDict release];

 	[contactPropertiesObserverManager release];

 	[super dealloc];

 }

 - (void)clearAllMetaContactData

 {

 	if (metaContactDict.count) {

 		[contactPropertiesObserverManager delayListObjectNotifications];

 		//Remove all the metaContacts to get any existing objects out of them

 		for (AIMetaContact *metaContact in [[[metaContactDict copy] autorelease] objectEnumerator]) {

 			[self explodeMetaContact:metaContact];

 		}

 		[contactPropertiesObserverManager endListObjectNotificationsDelay];

 	}

 	[metaContactDict release]; metaContactDict = [[NSMutableDictionary alloc] init];

 	[contactToMetaContactLookupDict release]; contactToMetaContactLookupDict = [[NSMutableDictionary alloc] init];

 	//Clear the preferences for good measure

 	[adium.preferenceController setPreference:nil

 										 forKey:KEY_FLAT_METACONTACTS

 										  group:PREF_GROUP_CONTACT_LIST];

 	[adium.preferenceController setPreference:nil

 										 forKey:KEY_METACONTACT_OWNERSHIP

 										  group:PREF_GROUP_CONTACT_LIST];

 	//Clear out old metacontact files

 	[[NSFileManager defaultManager] removeFilesInDirectory:[[adium.loginController userDirectory] stringByAppendingPathComponent:OBJECT_PREFS_PATH]

 												withPrefix:@"MetaContact"

 											 movingToTrash:NO];

 	[[NSFileManager defaultManager] removeFilesInDirectory:[adium cachesPath]

 												withPrefix:@"MetaContact"

 											 movingToTrash:NO];

 }

 #pragma mark Local Contact List Storage

 //Load the contact list

 - (void)loadContactList

 {

 	//We must load all the groups before loading contacts for the ordering system to work correctly.

 	[self _loadMetaContactsFromArray:[adium.preferenceController preferenceForKey:KEY_FLAT_METACONTACTS

 																			  group:PREF_GROUP_CONTACT_LIST]];

 	[self _loadBookmarks];

 }

 //Save the contact list

 - (void)saveContactList

 {

 	for (AIListGroup *listGroup in [groupDict objectEnumerator]) {

 		[listGroup setPreference:[NSNumber numberWithBool:[listGroup isExpanded]]

 						  forKey:KEY_EXPANDED

 						   group:PREF_GROUP_CONTACT_LIST];

 	}

 	NSMutableArray *bookmarks = [NSMutableArray array];

 	for (AIListBookmark *bookmark in self.allBookmarks) {

 		[bookmarks addObject:[NSKeyedArchiver archivedDataWithRootObject:bookmark]];

 	}

 	[adium.preferenceController setPreference:bookmarks

 									   forKey:KEY_BOOKMARKS

 										group:PREF_GROUP_CONTACT_LIST];

 }

 - (void)_loadBookmarks

 {

 	for (NSData *data in [adium.preferenceController preferenceForKey:KEY_BOOKMARKS group:PREF_GROUP_CONTACT_LIST]) {

 		//As a bookmark is initialized, it will add itself to the contact list in the right place

 		AIListBookmark	*bookmark = [NSKeyedUnarchiver unarchiveObjectWithData:data];

 		if(bookmark) {

 			if ([bookmarkDict objectForKey:bookmark.internalObjectID]) {

 				// In case we end up with two bookmarks with the same internalObjectID; this should be almost impossible.

 				[self removeBookmark:[bookmarkDict objectForKey:bookmark.internalObjectID]];

 			}

 			[bookmarkDict setObject:bookmark forKey:bookmark.internalObjectID];

 			[contactDict setObject:bookmark forKey:bookmark.internalObjectID];

 			//It's a newly created object, so set its initial attributes

 			[contactPropertiesObserverManager _updateAllAttributesOfObject:bookmark];

 		}

 	}

 }

 - (void)_loadMetaContactsFromArray:(NSArray *)array

 {	

 	for (NSString *identifier in array) {

 		NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

 		NSNumber *objectID = [NSNumber numberWithInteger:[[[identifier componentsSeparatedByString:@"-"] objectAtIndex:1] integerValue]];

 		[self metaContactWithObjectID:objectID];

 		[pool release];

 	}

 }

 #pragma mark Contact Grouping

 - (void)_addContactLocally:(AIListContact *)listContact toGroup:(AIListGroup *)localGroup

 {

 	BOOL			performedGrouping = NO;

 	//Protect with a retain while we are removing and adding the contact to our arrays

 	[listContact retain];

 	if (listContact.canJoinMetaContacts) {

 		AIListObject *existingObject = [localGroup objectWithService:listContact.service UID:listContact.UID];

 		if (existingObject) {

 			//If an object exists in this group with the same UID and serviceID, create a MetaContact

 			//for the two.

 			[self groupContacts:[NSArray arrayWithObjects:listContact,existingObject,nil]];

 			performedGrouping = YES;

 		} else {

 			AIMetaContact	*metaContact = [contactToMetaContactLookupDict objectForKey:listContact.internalObjectID];

 			//If no object exists in this group which matches, we should check if there is already

 			//a MetaContact holding a matching ListContact, since we should include this contact in it

 			//If we found a metaContact to which we should add, do it.

 			if (metaContact) {

 				[self addContact:listContact toMetaContact:metaContact];

 				performedGrouping = YES;

 			}

 		}

 	}

 	if (!performedGrouping) {

 		//If no similar objects exist, we add this contact directly to the list

 		[localGroup addObject:listContact];

 		//Add

 		[self _didChangeContainer:localGroup object:listContact];

 	}

 	//Cleanup

 	[listContact release];

 }

 - (void)_moveContactLocally:(AIListContact *)listContact fromGroups:(NSSet *)oldGroups toGroups:(NSSet *)groups

 {

 	//Protect with a retain while we are removing and adding the contact to our arrays

 	[listContact retain];

 	[contactPropertiesObserverManager delayListObjectNotifications];

 	//Remove this object from any local groups we have it in currently

 	for (AIListGroup *group in oldGroups) {

 		[group removeObject:listContact];

 		[self _didChangeContainer:group object:listContact];

 	}

 	for (AIListGroup *group in groups)

 		[self _addContactLocally:listContact toGroup:group];

 	[contactPropertiesObserverManager endListObjectNotificationsDelay];

 	[listContact release];

 }

 //Post a list grouping changed notification for the object and containing object

 - (void)_didChangeContainer:(AIListObject<AIContainingObject> *)inContainingObject object:(AIListObject *)object

 {

 	if ([contactPropertiesObserverManager updatesAreDelayed]) {

 		[contactPropertiesObserverManager noteContactChanged:object];

 	} else {

 		[[NSNotificationCenter defaultCenter] postNotificationName:Contact_ListChanged

 												  object:inContainingObject

 												userInfo:nil];

 	}

 }

 - (BOOL)useContactListGroups

 {

 	return useContactListGroups;

 }

 - (void)setUseContactListGroups:(BOOL)inFlag

 {

 	if (inFlag != useContactListGroups) {

 		useContactListGroups = inFlag;

 		[self _performChangeOfUseContactListGroups];

 	}

 }

 - (void)_performChangeOfUseContactListGroups

 {

 	[contactPropertiesObserverManager delayListObjectNotifications];

 	//Store the preference

 	[adium.preferenceController setPreference:[NSNumber numberWithBool:!useContactListGroups]

 										 forKey:KEY_HIDE_CONTACT_LIST_GROUPS

 										  group:PREF_GROUP_CONTACT_LIST_DISPLAY];

 	//Configure the sort controller to force ignoring of groups as appropriate

 	[[AISortController activeSortController] forceIgnoringOfGroups:(useContactListGroups ? NO : YES)];

 	//Restore the grouping of all root-level contacts

 	for (AIListContact *contact in [self contactEnumerator]) {

 		[contact restoreGrouping];

 	}

 	//Stop delaying object notifications; this will automatically resort the contact list, so we're done.

 	[contactPropertiesObserverManager endListObjectNotificationsDelay];

 }

 - (void)prepareShowHideGroups

 {

 	//Load the preference

 	useContactListGroups = ![[adium.preferenceController preferenceForKey:KEY_HIDE_CONTACT_LIST_GROUPS

 																	  group:PREF_GROUP_CONTACT_LIST_DISPLAY] boolValue];

 	//Show offline contacts menu item

     menuItem_showGroups = [[NSMenuItem alloc] initWithTitle:SHOW_GROUPS_MENU_TITLE

 													 target:self

 													 action:@selector(toggleShowGroups:)

 											  keyEquivalent:@""];

 	[menuItem_showGroups setState:useContactListGroups];

 	[adium.menuController addMenuItem:menuItem_showGroups toLocation:LOC_View_Toggles];

 	//Toolbar

 	NSToolbarItem	*toolbarItem;

     toolbarItem = [AIToolbarUtilities toolbarItemWithIdentifier:SHOW_GROUPS_IDENTIFER

 														  label:AILocalizedString(@"Show Groups",nil)

 												   paletteLabel:AILocalizedString(@"Toggle Groups Display",nil)

 														toolTip:AILocalizedString(@"Toggle display of groups",nil)

 														 target:self

 												settingSelector:@selector(setImage:)

 													itemContent:[NSImage imageNamed:(useContactListGroups ?

 																					 @"togglegroups_transparent" :

 																					 @"togglegroups")

 																		   forClass:[self class]

 																		 loadLazily:YES]

 														 action:@selector(toggleShowGroupsToolbar:)

 														   menu:nil];

     [adium.toolbarController registerToolbarItem:toolbarItem forToolbarType:@"ContactList"];

 }

 - (IBAction)toggleShowGroups:(id)sender

 {

 	//Flip-flop.

 	useContactListGroups = !useContactListGroups;

 	[menuItem_showGroups setState:useContactListGroups];

 	//Update the contact list.  Do it on the next run loop for better menu responsiveness, as it may be a lengthy procedure.

 	[self performSelector:@selector(_performChangeOfUseContactListGroups)

 			   withObject:nil

 			   afterDelay:0];

 }

 - (IBAction)toggleShowGroupsToolbar:(id)sender

 {

 	[self toggleShowGroups:sender];

 	[sender setImage:[NSImage imageNamed:(useContactListGroups ?

 										  @"togglegroups_transparent" :

 										  @"togglegroups")

 								forClass:[self class]]];

 }

 @synthesize useOfflineGroup;

 - (AIListGroup *)offlineGroup

 {

 	return [self groupWithUID:AILocalizedString(@"Offline", "Name of offline group")];

 }

 #pragma mark Meta Contacts

 /*!

  * @brief Create or load a metaContact

  *

  * @param inObjectID The objectID of an existing but unloaded metaContact, or nil to create and save a new metaContact

  */

 - (AIMetaContact *)metaContactWithObjectID:(NSNumber *)inObjectID

 {

 	BOOL			shouldRestoreContacts = YES;

 	//If no object ID is provided, use the next available object ID

 	//(MetaContacts should always have an individually unique object id)

 	if (!inObjectID) {

 		NSInteger topID = [[adium.preferenceController preferenceForKey:TOP_METACONTACT_ID

 															  group:PREF_GROUP_CONTACT_LIST] integerValue];

 		inObjectID = [NSNumber numberWithInteger:topID];

 		[adium.preferenceController setPreference:[NSNumber numberWithInteger:([inObjectID integerValue] + 1)]

 											 forKey:TOP_METACONTACT_ID

 											  group:PREF_GROUP_CONTACT_LIST];

 		//No reason to waste time restoring contacts when none are in the meta contact yet.

 		shouldRestoreContacts = NO;

 	}

 	//Look for a metacontact with this object ID.  If none is found, create one

 	//and add its contained contacts to it.

 	NSString		*metaContactDictKey = [AIMetaContact internalObjectIDFromObjectID:inObjectID];

 	AIMetaContact   *metaContact = [metaContactDict objectForKey:metaContactDictKey];

 	if (!metaContact) {

 		metaContact = [(AIMetaContact *)[AIMetaContact alloc] initWithObjectID:inObjectID];

 		//Keep track of it in our metaContactDict for retrieval by objectID

 		[metaContactDict setObject:metaContact forKey:metaContactDictKey];

 		//Add it to our more general contactDict, as well

 		[contactDict setObject:metaContact forKey:[metaContact internalUniqueObjectID]];

 		/* We restore contacts (actually, internalIDs for contacts, to be added as necessary later) if the metaContact

 		 * existed before this call to metaContactWithObjectID:

 		 */

 		if (shouldRestoreContacts)

 			[self _restoreContactsToMetaContact:metaContact];

 		/* As with contactWithService:account:UID, update all attributes so observers are initially informed of

 		 * this object's existence.

 		 */

 		[contactPropertiesObserverManager _updateAllAttributesOfObject:metaContact];

 		[metaContact release];

 	}

 	return metaContact;

 }

 /*!

  * @brief Associate the appropriate internal IDs for contained contacts with a metaContact

  *

  * @result YES if one or more contacts was associated with the metaContact; NO if none were.

  */

 - (BOOL)_restoreContactsToMetaContact:(AIMetaContact *)metaContact

 {

 	NSDictionary	*allMetaContactsDict = [adium.preferenceController preferenceForKey:KEY_METACONTACT_OWNERSHIP

 																				 group:PREF_GROUP_CONTACT_LIST];

 	NSArray			*containedContactsArray = [allMetaContactsDict objectForKey:metaContact.internalObjectID];

 	if (containedContactsArray.count) {

 		[self _restoreContactsToMetaContact:metaContact

 				 fromContainedContactsArray:containedContactsArray];

 		return YES;

 	}

 	return NO;

 }

 /*!

  * @brief Associate the internal IDs for an array of contacts with a specific metaContact

  *

  * This does not actually place any AIListContacts within the metaContact.  Instead, it updates the contactToMetaContactLookupDict

  * dictionary to have metaContact associated with the list contacts specified by containedContactsArray. This

  * allows us to add them lazily to the metaContact (in contactWithService:account:UID:) as necessary.

  *

  * @param metaContact The metaContact to which contact referneces are added

  * @param containedContactsArray An array of NSDictionary objects, each of which has SERVICE_ID_KEY and UID_KEY which together specify an internalObjectID of an AIListContact

  */

 - (void)_restoreContactsToMetaContact:(AIMetaContact *)metaContact fromContainedContactsArray:(NSArray *)containedContactsArray

 {	

 	for (NSDictionary *containedContactDict in containedContactsArray) {

 		/* Before Adium 0.80, metaContacts could be created within metaContacts. Simply ignore any attempt to restore

 		 * such erroneous data, which will have a YES boolValue for KEY_IS_METACONTACT. */

 		if (![[containedContactDict objectForKey:KEY_IS_METACONTACT] boolValue]) {

 			/* Assign this metaContact to the appropriate internalObjectID for containedContact's represented listObject.

 			 *

 			 * As listObjects are loaded/created/requested which match this internalObjectID, 

 			 * they will be inserted into the metaContact.

 			 */

 			NSString	*internalObjectID = [AIListObject internalObjectIDForServiceID:[containedContactDict objectForKey:SERVICE_ID_KEY]

 																				UID:[containedContactDict objectForKey:UID_KEY]];

 			[contactToMetaContactLookupDict setObject:metaContact

 											   forKey:internalObjectID];

 		}

 	}

 }

 //Add a list object to a meta contact, setting preferences and such

 //so the association is lasting across program launches.

 - (void)addContact:(AIListContact *)inContact toMetaContact:(AIMetaContact *)metaContact

 {

 	if (!inContact) {

 		//I can't think of why one would want to add an entire group to a metacontact. Let's say you can't.

 		NSLog(@"Warning: addContact:toMetaContact: Attempted to add %@ to %@",inContact,metaContact);

 		return;

 	}

 	if (inContact == metaContact) return;

 	//If listObject contains other contacts, perform addContact:toMetaContact: recursively

 	if ([inContact conformsToProtocol:@protocol(AIContainingObject)]) {

 		for (AIListContact *someObject in ((AIListObject<AIContainingObject> *)inContact).containedObjects) {

 			[self addContact:someObject toMetaContact:metaContact];

 		}

 	} else {

 		//Obtain any metaContact this listObject is currently within, so we can remove it later

 		AIMetaContact *oldMetaContact = [contactToMetaContactLookupDict objectForKey:[inContact internalObjectID]];

 		if ([self _performAddContact:inContact toMetaContact:metaContact] && metaContact != oldMetaContact) {

 			//If this listObject was not in this metaContact in any form before, store the change

 			//Remove the list object from any other metaContact it is in at present

 			if (oldMetaContact)

 				[self removeContact:inContact fromMetaContact:oldMetaContact];

 			[self _storeListObject:inContact inMetaContact:metaContact];

 			//Do the update thing

 			[contactPropertiesObserverManager _updateAllAttributesOfObject:metaContact];

 		}

 	}

 }

 - (void)_storeListObject:(AIListObject *)listObject inMetaContact:(AIMetaContact *)metaContact

 {

 	//we only allow group->meta->contact, not group->meta->meta->contact

 	NSParameterAssert(![listObject conformsToProtocol:@protocol(AIContainingObject)]);

 	//	AILog(@"MetaContacts: Storing %@ in %@",listObject, metaContact);

 	NSDictionary		*containedContactDict;

 	NSMutableDictionary	*allMetaContactsDict;

 	NSMutableArray		*containedContactsArray;

 	NSString			*metaContactInternalObjectID = [metaContact internalObjectID];

 	//Get the dictionary of all metaContacts

 	allMetaContactsDict = [[adium.preferenceController preferenceForKey:KEY_METACONTACT_OWNERSHIP

 																	group:PREF_GROUP_CONTACT_LIST] mutableCopy];

 	if (!allMetaContactsDict) {

 		allMetaContactsDict = [[NSMutableDictionary alloc] init];

 	}

 	//Load the array for the new metaContact

 	containedContactsArray = [[allMetaContactsDict objectForKey:metaContactInternalObjectID] mutableCopy];

 	if (!containedContactsArray) containedContactsArray = [[NSMutableArray alloc] init];

 	containedContactDict = nil;

 	//Create the dictionary describing this list object

 	containedContactDict = [NSDictionary dictionaryWithObjectsAndKeys:

 							listObject.service.serviceID, SERVICE_ID_KEY,

 							listObject.UID, UID_KEY, nil];

 	//Only add if this dict isn't already in the array

 	if (containedContactDict && ([containedContactsArray indexOfObject:containedContactDict] == NSNotFound)) {

 		[containedContactsArray addObject:containedContactDict];

 		[allMetaContactsDict setObject:containedContactsArray forKey:metaContactInternalObjectID];

 		//Save

 		[self _saveMetaContacts:allMetaContactsDict];

 		[adium.contactAlertsController mergeAndMoveContactAlertsFromListObject:listObject

 																  intoListObject:metaContact];

 	}

 	[allMetaContactsDict release];

 	[containedContactsArray release];

 }

 //Actually adds a list contact to a meta contact. No preferences are changed.

 //Attempts to add the list object, causing group reassignment and updates our contactToMetaContactLookupDict

 //for quick lookup of the MetaContact given a AIListContact uniqueObjectID if successful.

 - (BOOL)_performAddContact:(AIListContact *)inContact toMetaContact:(AIMetaContact *)metaContact

 {

 	//we only allow group->meta->contact, not group->meta->meta->contact

 	NSParameterAssert([metaContact canContainObject:inContact]);

 	BOOL								success;

 	//Remove the object from its previous containing groups

 	[self _moveContactLocally:inContact fromGroups:inContact.groups toGroups:[NSSet set]];

 	//AIMetaContact will handle reassigning the list object's grouping to being itself

 	if ((success = [metaContact addObject:inContact])) {

 		[contactToMetaContactLookupDict setObject:metaContact forKey:[inContact internalObjectID]];

 		[self _didChangeContainer:metaContact object:inContact];

 		//Ensure the metacontact ends up in the appropriate groups

 		[metaContact restoreGrouping];

 	}

 	return success;

 }

 - (void)removeContact:(AIListContact *)inContact fromMetaContact:(AIMetaContact *)metaContact

 {

 	//we only allow group->meta->contact, not group->meta->meta->contact

 	NSParameterAssert(![inContact conformsToProtocol:@protocol(AIContainingObject)]);

 	NSString			*metaContactInternalObjectID = [metaContact internalObjectID];

 	//Get the dictionary of all metaContacts

 	NSMutableDictionary *allMetaContactsDict = [adium.preferenceController preferenceForKey:KEY_METACONTACT_OWNERSHIP

 																   group:PREF_GROUP_CONTACT_LIST];

 	//Load the array for the metaContact

 	NSArray *containedContactsArray = [allMetaContactsDict objectForKey:metaContactInternalObjectID];

 	//Enumerate it, looking only for the appropriate type of containedContactDict

 	NSString	*listObjectUID = inContact.UID;

 	NSString	*listObjectServiceID = inContact.service.serviceID;

 	NSDictionary *containedContactDict = nil;

 	for (containedContactDict in containedContactsArray) {

 		if ([[containedContactDict objectForKey:UID_KEY] isEqualToString:listObjectUID] &&

 			[[containedContactDict objectForKey:SERVICE_ID_KEY] isEqualToString:listObjectServiceID]) {

 			break;

 		}

 	}

 	//If we found a matching dict (referring to our contact in the old metaContact), remove it and store the result

 	if (containedContactDict) {

 		NSMutableArray		*newContainedContactsArray;

 		NSMutableDictionary	*newAllMetaContactsDict;

 		newContainedContactsArray = [containedContactsArray mutableCopy];

 		[newContainedContactsArray removeObjectIdenticalTo:containedContactDict];

 		newAllMetaContactsDict = [allMetaContactsDict mutableCopy];

 		[newAllMetaContactsDict setObject:newContainedContactsArray

 								   forKey:metaContactInternalObjectID];

 		[self _saveMetaContacts:newAllMetaContactsDict];

 		[newContainedContactsArray release];

 		[newAllMetaContactsDict release];

 	}

 	//The listObject can be within the metaContact without us finding a containedContactDict if we are removing multiple

 	//listContacts referring to the same UID & serviceID combination - that is, on multiple accounts on the same service.

 	//We therefore request removal of the object regardless of the if (containedContactDict) check above.

 	[metaContact removeObject:inContact];

 	[self _didChangeContainer:metaContact object:inContact];

 }

 /*!

  * @brief Determine the existing metacontact into which a grouping of UIDs and services would be placed

  *

  * @param UIDsArray NSArray of UIDs

  * @param servicesArray NSArray of serviceIDs corresponding to entries in UIDsArray

  * 

  * @result Either the existing AIMetaContact -[self groupUIDs:forServices:usingMetaContactHint:] would return if passed a nil metaContactHint,

  *         or nil (if no existing metacontact would be used).

  */

 - (AIMetaContact *)knownMetaContactForGroupingUIDs:(NSArray *)UIDsArray forServices:(NSArray *)servicesArray

 {

 	AIMetaContact	*metaContact = nil;

 	NSInteger count = [UIDsArray count];

 	for (NSInteger i = 0; i < count; i++) {

 		if ((metaContact = [contactToMetaContactLookupDict objectForKey:[AIListObject internalObjectIDForServiceID:[servicesArray objectAtIndex:i]

 																											   UID:[UIDsArray objectAtIndex:i]]])) {

 			break;

 		}

 	}

 	return metaContact;

 }

 /*!

  * @brief Groups UIDs for services into a single metacontact

  *

  * UIDsArray and servicesArray should be a paired set of arrays, with each index corresponding to

  * a UID and a service, respectively, which together define a contact which should be included in the grouping.

  *

  * Assumption: This is only called after the contact list is finished loading, which occurs via

  * -(void)controllerDidLoad above.

  *

  * @param UIDsArray NSArray of UIDs

  * @param servicesArray NSArray of serviceIDs corresponding to entries in UIDsArray

  * @param metaContactHint If passed, an AIMetaContact to use for the grouping if an existing one isn't found. If nil, a new metacontact will be craeted in that case.

  */

 - (AIMetaContact *)groupUIDs:(NSArray *)UIDsArray forServices:(NSArray *)servicesArray usingMetaContactHint:(AIMetaContact *)metaContactHint

 {

 	NSMutableSet *internalObjectIDs = [[NSMutableSet alloc] init];

 	AIMetaContact *metaContact = nil;

 	NSString *internalObjectID;

 	NSInteger count = [UIDsArray count];

 	/* Build an array of all contacts matching this description (multiple accounts on the same service listing

 	 * the same UID mean that we can have multiple AIListContact objects with a UID/service combination)

 	 */

 	for (NSUInteger i = 0; i < count; i++) {

 		NSString	*serviceID = [servicesArray objectAtIndex:i];

 		NSString	*UID = [UIDsArray objectAtIndex:i];

 		internalObjectID = [AIListObject internalObjectIDForServiceID:serviceID

 																  UID:UID];

 		if(!metaContact) {

 			metaContact = [contactToMetaContactLookupDict objectForKey:internalObjectID];

 		}

 		[internalObjectIDs addObject:internalObjectID];

 	}

 	if ([internalObjectIDs count] > 1) {

 		//Create a new metaContact is we didn't find one and weren't supplied a hint

 		if (!metaContact && !(metaContact = metaContactHint)) {

 			AILogWithSignature(@"New metacontact to group %@ on %@", UIDsArray, servicesArray);

 			metaContact = [self metaContactWithObjectID:nil];

 		}

 		for (internalObjectID in internalObjectIDs) {

 			AIListObject	*existingObject;

 			if ((existingObject = [self existingListObjectWithUniqueID:internalObjectID])) {

 				/* If there is currently an object (or multiple objects) matching this internalObjectID

 				 * we should add immediately.

 				 */

 				NSAssert([metaContact canContainObject:existingObject], @"Attempting to add something metacontacts can't hold to a metacontact");

 				[self addContact:(id)existingObject

 					  toMetaContact:metaContact];	

 			} else {

 				/* If no objects matching this internalObjectID exist, we can simply add to the 

 				 * contactToMetaContactLookupDict for use if such an object is created later.

 				 */

 				[contactToMetaContactLookupDict setObject:metaContact

 												   forKey:internalObjectID];			

 			}

 		}

 	}

 	[internalObjectIDs release];

 	return metaContact;

 }

 /* @brief Group an NSArray of AIListContacts, returning the meta contact into which they are added.

  *

  * This will reuse an existing metacontact (for one of the contacts in the array) if possible.

  * @param contactsToGroupArray Contacts to group together

  */

 - (AIMetaContact *)groupContacts:(NSArray *)contactsToGroupArray

 {

 	AIMetaContact   *metaContact = nil;

 	//Look for a metacontact we were passed directly

 	for (AIListContact *listContact in contactsToGroupArray) {

 		if ([listContact isKindOfClass:[AIMetaContact class]]) {

 			metaContact = (AIMetaContact *)listContact;

 			break;

 		}

 	}

 	//If we weren't passed a metacontact, look for an existing metacontact associated with a passed contact

 	if (!metaContact) {

 		for (AIListContact *listContact in contactsToGroupArray) {

 			if (![listContact isKindOfClass:[AIMetaContact class]] &&

 				(metaContact = [contactToMetaContactLookupDict objectForKey:[listContact internalObjectID]])) {

 					break;

 			}

 		}

 	}

 	//Create a new metaContact is we didn't find one.

 	if (!metaContact) {

 		AILogWithSignature(@"New metacontact to group %@", contactsToGroupArray);

 		metaContact = [self metaContactWithObjectID:nil];

 	}

 	/* Add all these contacts to our MetaContact.

 	 * Some may already be present, but that's fine, as nothing will happen.

 	 */

 	for (AIListContact *listContact in contactsToGroupArray) {

 		[self addContact:listContact toMetaContact:metaContact];

 	}

 	return metaContact;

 }

 - (void)explodeMetaContact:(AIMetaContact *)metaContact

 {

 	//Remove the objects within it from being inside it

 	[contactPropertiesObserverManager delayListObjectNotifications];

 	NSArray	*containedObjects = metaContact.containedObjects;

 	NSMutableDictionary *allMetaContactsDict = [[adium.preferenceController preferenceForKey:KEY_METACONTACT_OWNERSHIP

 																						 group:PREF_GROUP_CONTACT_LIST] mutableCopy];

 	for (AIListContact *object in containedObjects) {

 		//Remove from the contactToMetaContactLookupDict first so we don't try to reinsert into this metaContact

 		[contactToMetaContactLookupDict removeObjectForKey:[object internalObjectID]];

 		[self removeContact:object fromMetaContact:metaContact];

 	}

 	//Then, procede to remove the metaContact

 	//Protect!

 	[metaContact retain];

 	//Remove it from its containing groups (no contained contacts == present in no groups)

 	[metaContact restoreGrouping];

 	NSString	*metaContactInternalObjectID = [metaContact internalObjectID];

 	//Remove our reference to it internally

 	[metaContactDict removeObjectForKey:metaContactInternalObjectID];

 	//Remove it from the preferences dictionary

 	[allMetaContactsDict removeObjectForKey:metaContactInternalObjectID];

 	//Save the updated allMetaContactsDict which no longer lists the metaContact

 	[self _saveMetaContacts:allMetaContactsDict];

 	[contactPropertiesObserverManager endListObjectNotificationsDelay];

 	//Protection is overrated.

 	[metaContact release];

 	[allMetaContactsDict release];

 }

 - (void)_saveMetaContacts:(NSDictionary *)allMetaContactsDict

 {

 	AILog(@"MetaContacts: Saving!");

 	[adium.preferenceController setPreference:allMetaContactsDict

 										 forKey:KEY_METACONTACT_OWNERSHIP

 										  group:PREF_GROUP_CONTACT_LIST];

 	[adium.preferenceController setPreference:[allMetaContactsDict allKeys]

 										 forKey:KEY_FLAT_METACONTACTS

 										  group:PREF_GROUP_CONTACT_LIST];

 }

 //Sort list objects alphabetically by their display name

 NSInteger contactDisplayNameSort(AIListObject *objectA, AIListObject *objectB, void *context)