/* 

 * 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];

			//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];

	}

	//Restore the grouping of all list bookmarks

	for (AIListBookmark *bookmark in [self allBookmarks]) {

		[bookmark 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]];