/* 

 * 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 "CBPurpleAccount.h"

#import "PurpleService.h"

#import <libpurple/notify.h>

#import <libpurple/cmds.h>

#import <AdiumLibpurple/SLPurpleCocoaAdapter.h>

#import <Adium/AIAccount.h>

#import <Adium/AIChat.h>

#import <Adium/AIContentMessage.h>

#import <Adium/AIContentTopic.h>

#import <Adium/AIContentEvent.h>

#import <Adium/AIContentContext.h>

#import <Adium/AIContentNotification.h>

#import <Adium/AIHTMLDecoder.h>

#import <Adium/AIListContact.h>

#import <Adium/AIListGroup.h>

#import <Adium/AIListObject.h>

#import <Adium/AIMetaContact.h>

#import <Adium/AIService.h>

#import <Adium/AIServiceIcons.h>

#import <Adium/AIStatus.h>

#import <Adium/ESFileTransfer.h>

#import <Adium/AIWindowController.h>

#import <Adium/AIEmoticon.h>

#import <Adium/AIAccountControllerProtocol.h>

#import <Adium/AIChatControllerProtocol.h>

#import <Adium/AIContactControllerProtocol.h>

#import <Adium/AIContactObserverManager.h>

#import <Adium/AIContentControllerProtocol.h>

#import <Adium/AIInterfaceControllerProtocol.h>

#import <Adium/AIStatusControllerProtocol.h>

#import <AIUtilities/AIAttributedStringAdditions.h>

#import <AIUtilities/AIDictionaryAdditions.h>

#import <AIUtilities/AIMenuAdditions.h>

#import <AIUtilities/AIMutableOwnerArray.h>

#import <AIUtilities/AIStringAdditions.h>

#import <AIUtilities/AIApplicationAdditions.h>

#import <AIUtilities/AIObjectAdditions.h>

#import <AIUtilities/AIImageAdditions.h>

#import <AIUtilities/AIImageDrawingAdditions.h>

#import <AIUtilities/AIMutableStringAdditions.h>

#import <AIUtilities/AISystemNetworkDefaults.h>

#import <Adium/AdiumAuthorization.h>

#import <Adium/AIMedia.h>

#import <Adium/AIMediaControllerProtocol.h>

#import "ESiTunesPlugin.h"

#import "AMPurpleTuneTooltip.h"

#import "adiumPurpleRequest.h"

#import "adiumPurpleMedia.h"

#import "AIDualWindowInterfacePlugin.h"

#ifdef HAVE_CDSA

#import "AIPurpleCertificateViewer.h"

#endif

#define NO_GROUP						@"__NoGroup__"

#define	PREF_GROUP_ALIASES			@"Aliases"		//Preference group to store aliases in

#define NEW_ACCOUNT_DISPLAY_TEXT		AILocalizedString(@"<New Account>", "Placeholder displayed as the name of a new account")

#define	KEY_PRIVACY_OPTION	@"Privacy Option"

@interface CBPurpleAccount ()

- (NSString *)_mapIncomingGroupName:(NSString *)name;

- (NSString *)_mapOutgoingGroupName:(NSString *)name;

- (void)setTypingFlagOfChat:(AIChat *)inChat to:(NSNumber *)typingState;

- (void)_receivedMessage:(NSAttributedString *)attributedMessage inChat:(AIChat *)chat fromListContact:(AIListContact *)sourceContact flags:(PurpleMessageFlags)flags date:(NSDate *)date;

- (NSNumber *)shouldCheckMail;

- (void)configurePurpleAccountNotifyingTarget:(id)target selector:(SEL)selector;

- (void)continueConnectWithConfiguredProxy;

- (void)continueRegisterWithConfiguredPurpleAccount;

- (void)promptForHostBeforeConnecting;

- (void)setAccountProfileTo:(NSAttributedString *)profile configurePurpleAccountContext:(NSInvocation *)inInvocation;

- (void)performAccountMenuAction:(NSMenuItem *)sender;

- (void)showServerCertificate;

- (void)retrievedProxyConfiguration:(NSDictionary *)proxyConfig context:(NSInvocation *)invocation;

- (void)iTunesDidUpdate:(NSNotification *)notification;

@end

@implementation CBPurpleAccount

static SLPurpleCocoaAdapter *purpleAdapter = nil;

// The PurpleAccount currently associated with this Adium account

- (PurpleAccount*)purpleAccount

{

	//Create a purple account if one does not already exist

	if (!account) {

		[self createNewPurpleAccount];

		AILog(@"Created PurpleAccount 0x%x with UID %@, protocolPlugin %s", account, self.UID, [self protocolPlugin]);

	}

    return account;

}

- (SLPurpleCocoaAdapter *)purpleAdapter

{

	if (!purpleAdapter) {

		purpleAdapter = [[SLPurpleCocoaAdapter sharedInstance] retain];	

	}	

	return purpleAdapter;

}

// Subclasses must override this

- (const char*)protocolPlugin { return NULL; }

- (PurplePluginProtocolInfo *)protocolInfo

{

	PurplePlugin				*prpl;

	if ((prpl = purple_find_prpl(purple_account_get_protocol_id(account)))) {

		return PURPLE_PLUGIN_PROTOCOL_INFO(prpl);

	}

	return NULL;

}

// Contacts ------------------------------------------------------------------------------------------------

#pragma mark Contacts

- (void)newContact:(AIListContact *)theContact withName:(NSString *)inName

{

}

- (void)addContact:(AIListContact *)theContact toGroupName:(NSString *)groupName contactName:(NSString *)contactName

{

	//When a new contact is created, if we aren't already silent and delayed, set it  a second to cover our initial

	//status updates

	if (!silentAndDelayed) {

		[self silenceAllContactUpdatesForInterval:2.0];

		[[AIContactObserverManager sharedManager] delayListObjectNotificationsUntilInactivity];		

	}

	//If the name we were passed differs from the current formatted UID of the contact, it's itself a formatted UID

	//This is important since we may get an alias ("Evan Schoenberg") from the server but also want the formatted name

	if (![contactName isEqualToString:theContact.formattedUID] && ![contactName isEqualToString:theContact.UID]) {

		[theContact setValue:contactName

							 forProperty:@"formattedUID"

							 notify:NotifyLater];

	}

	if (groupName && [groupName isEqualToString:@PURPLE_ORPHANS_GROUP_NAME]) {

		[theContact addRemoteGroupName:AILocalizedString(@"Orphans","Name for the orphans group")];

	} else if (groupName && [groupName length] != 0) {

		[theContact addRemoteGroupName:[self _mapIncomingGroupName:groupName]];

	} else {

		AILog(@"Got a nil group for %@",theContact);

	}

	[self gotGroupForContact:theContact];

}

- (void)removeContact:(AIListContact *)theContact fromGroupName:(NSString *)groupName

{

	NSParameterAssert(groupName != nil); //is this always true?

	NSParameterAssert(theContact != nil);

	[theContact removeRemoteGroupName:[self _mapIncomingGroupName:groupName]];

}

/*!

 * @brief Change the UID of a contact

 *

 * If we're just passed a formatted version of the current UID, don't change the UID but instead use the information

 * as the FormattedUID.  For example, we get sent this when an AIM contact's name formatting changes; we always want

 * to use a lowercase and space-free version for the UID, however.

 */

- (void)renameContact:(AIListContact *)theContact toUID:(NSString *)newUID

{

	//If the name we were passed differs from the current formatted UID of the contact, it's itself a formatted UID

	//This is important since we may get an alias ("Evan Schoenberg") from the server but also want the formatted name

	NSString	*normalizedUID = [self.service normalizeUID:newUID removeIgnoredCharacters:YES];

	if ([normalizedUID isEqualToString:theContact.UID]) {

		[theContact setValue:newUID

							 forProperty:@"formattedUID"

							 notify:NotifyLater];		

	} else {

		[theContact setUID:newUID];		

	}

}

- (void)updateContact:(AIListContact *)theContact toAlias:(NSString *)purpleAlias

{

	if (![[purpleAlias compactedString] isEqualToString:[theContact.UID compactedString]]) {

		//Store this alias as the serverside display name so long as it isn't identical when unformatted to the UID

		[theContact setServersideAlias:purpleAlias

							  silently:silentAndDelayed];

	} else {

		//If it's the same characters as the UID, apply it as a formatted UID

		if (![purpleAlias isEqualToString:theContact.formattedUID] && 

			![purpleAlias isEqualToString:theContact.UID]) {

			[theContact setFormattedUID:purpleAlias

								 notify:NotifyLater];

			//Apply any changes

			[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

		}

	}

}

- (void)updateContact:(AIListContact *)theContact forEvent:(NSNumber *)event

{

}		

//Signed online

- (void)updateSignon:(AIListContact *)theContact withData:(void *)data

{

	[theContact setOnline:YES

				   notify:NotifyLater

				 silently:silentAndDelayed];

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

}

//Signed offline

- (void)updateSignoff:(AIListContact *)theContact withData:(void *)data

{

	[theContact setOnline:NO

				   notify:NotifyLater

				 silently:silentAndDelayed];

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

}

//Signon Time

- (void)updateSignonTime:(AIListContact *)theContact withData:(NSDate *)signonDate

{	

	[theContact setSignonDate:signonDate

					   notify:NotifyLater];

	//Apply any changes

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

}

/*!

 * @brief Status name to use for a Purple buddy

 */

- (NSString *)statusNameForPurpleBuddy:(PurpleBuddy *)buddy

{

	return nil;

}

/*!

 * @brief Status message for a contact

 */

- (NSAttributedString *)statusMessageForPurpleBuddy:(PurpleBuddy *)buddy

{

	PurplePresence		*presence = purple_buddy_get_presence(buddy);

	PurpleStatus		*status = (presence ? purple_presence_get_active_status(presence) : NULL);

	const char			*message = (status ? purple_status_get_attr_string(status, "message") : NULL);

	NSString			*buddyStatusMessage = nil;

	// Get the plugin's status message for this buddy if they don't have a status message

	if (!message) {

		PurplePluginProtocolInfo  *prpl_info = self.protocolInfo;

		if (prpl_info && prpl_info->status_text) {

			char *status_text = (prpl_info->status_text)(buddy);

			// Don't display "Offline" as a status message.

			if (status_text && strcmp(status_text, _("Offline")) != 0) {

				buddyStatusMessage = [NSString stringWithUTF8String:status_text];				

			}

			g_free(status_text);

		}

	} else {

		buddyStatusMessage = [NSString stringWithUTF8String:message];

	}

	return buddyStatusMessage ? [AIHTMLDecoder decodeHTML:buddyStatusMessage] : nil;

}

/*!

 * @brief Update the status message and away state of the contact

 */

- (void)updateStatusForContact:(AIListContact *)theContact toStatusType:(NSNumber *)statusTypeNumber statusName:(NSString *)statusName statusMessage:(NSAttributedString *)inStatusMessage isMobile:(BOOL)isMobile

{

	[theContact setStatusWithName:statusName

					   statusType:[statusTypeNumber intValue]

						   notify:NotifyLater];

	[theContact setStatusMessage:inStatusMessage

						  notify:NotifyLater];

	[theContact setIsMobile:isMobile notify:NotifyLater];

	//Apply the change

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

}

//Idle time

- (void)updateWentIdle:(AIListContact *)theContact withData:(NSDate *)idleSinceDate

{

	[theContact setIdle:YES sinceDate:idleSinceDate notify:NotifyLater];

	//Apply any changes

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

}

- (void)updateIdleReturn:(AIListContact *)theContact withData:(void *)data

{

	[theContact setIdle:NO

			  sinceDate:nil

				 notify:NotifyLater];

	//Apply any changes

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

}

//Evil level (warning level)

- (void)updateEvil:(AIListContact *)theContact withData:(NSNumber *)evilNumber

{

	[theContact setWarningLevel:[evilNumber integerValue]

						 notify:NotifyLater];

	//Apply any changes

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

}

- (void)clearIconForContact:(AIListContact *)theContact

{

	[theContact setServersideIconData:nil

							   notify:NotifyLater];

	//Apply any changes

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];	

}

//Buddy Icon

- (void)updateIcon:(AIListContact *)theContact withData:(NSData *)userIconData

{

	[NSObject cancelPreviousPerformRequestsWithTarget:self

											 selector:@selector(clearIconForContact:)

											   object:theContact];

	if (userIconData) {

		[theContact setServersideIconData:userIconData

								   notify:NotifyLater];

		//Apply any changes

		[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

	} else {

		/* We may receive an empty icon update just before an actual change. We don't want to flicker through no-icon.

		 * We therefore cancel empty icon updates when we receive a new icon, and we do the actual clearing on a delay in case

		 * this is what is about to happen.

		 */

		[self performSelector:@selector(clearIconForContact:)

				   withObject:theContact

				   afterDelay:10.0];

	}

}

- (NSString *)processedIncomingUserInfo:(NSString *)inString

{

	NSMutableString *returnString = nil;

	if ([inString rangeOfString:@"Purple could not find any information in the user's profile. The user most likely does not exist."].location != NSNotFound) {

		returnString = [[inString mutableCopy] autorelease];

		[returnString replaceOccurrencesOfString:@"Purple could not find any information in the user's profile. The user most likely does not exist."

									  withString:AILocalizedString(@"Adium could not find any information in the user's profile. This may not be a registered name.", "Message shown when a contact's profile can't be found")

										 options:NSLiteralSearch

										   range:NSMakeRange(0, [returnString length])];

	}

	return (returnString ? returnString : inString);

}

- (NSString *)webProfileStringForContact:(AIListContact *)contact

{

	return [NSString stringWithFormat:NSLocalizedString(@"View %@'s %@ web profile", nil), 

			contact.formattedUID, [contact.service shortDescription]];

}

- (NSMutableArray *)arrayOfDictionariesFromPurpleNotifyUserInfo:(PurpleNotifyUserInfo *)user_info forContact:(AIListContact *)contact

{

	GList *l;

	NSMutableArray *array = [NSMutableArray array];

	for (l = purple_notify_user_info_get_entries(user_info); l != NULL; l = l->next) {

		PurpleNotifyUserInfoEntry *user_info_entry = l->data;

		switch (purple_notify_user_info_entry_get_type(user_info_entry)) {

			case PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER:

				[array addObject:[NSDictionary dictionaryWithObjectsAndKeys:

								  [NSString stringWithUTF8String:purple_notify_user_info_entry_get_label(user_info_entry)], KEY_KEY,

								  [NSNumber numberWithInteger:AIUserInfoSectionHeader], KEY_TYPE,

								  nil]];

				break;

			case PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK:

				[array addObject:[NSDictionary dictionaryWithObjectsAndKeys:

								  [NSNumber numberWithInteger:AIUserInfoSectionBreak], KEY_TYPE,

								  nil]];

				break;

			case PURPLE_NOTIFY_USER_INFO_ENTRY_PAIR:

			{

				if (purple_notify_user_info_entry_get_label(user_info_entry) && purple_notify_user_info_entry_get_value(user_info_entry)) {

					[array addObject:[NSDictionary dictionaryWithObjectsAndKeys:

									  [NSString stringWithUTF8String:purple_notify_user_info_entry_get_label(user_info_entry)], KEY_KEY,

									  processPurpleImages([NSString stringWithUTF8String:purple_notify_user_info_entry_get_value(user_info_entry)], self), KEY_VALUE,

									  nil]];

				} else if (purple_notify_user_info_entry_get_label(user_info_entry)) {

					[array addObject:[NSDictionary dictionaryWithObject:

									  [NSString stringWithUTF8String:purple_notify_user_info_entry_get_label(user_info_entry)]

																 forKey:KEY_KEY]];

				} else if (purple_notify_user_info_entry_get_value(user_info_entry)) {

					NSMutableString	*value = [processPurpleImages([NSString stringWithUTF8String:purple_notify_user_info_entry_get_value(user_info_entry)],

																  self) mutableCopy];

					[value replaceOccurrencesOfString:@"<br>" withString:@"<br/>" options:(NSCaseInsensitiveSearch | NSLiteralSearch)];

					[value replaceOccurrencesOfString:@"<br />" withString:@"<br/>" options:(NSCaseInsensitiveSearch | NSLiteralSearch)];

					[value replaceOccurrencesOfString:@"<B>" withString:@"<b>" options:NSLiteralSearch];

					for (NSString *valuePair in [value componentsSeparatedByString:@"<br/><b>"]) {

						NSRange	firstStartBold = [valuePair rangeOfString:@"<b>"];

						NSRange	firstEndBold = [valuePair rangeOfString:@"</b>"];

						if (firstEndBold.length > 0) {

							// Chop off <b> from the beginning and :</b> from the end. The extra -1 is for the colon.

							[array addObject:[NSDictionary dictionaryWithObjectsAndKeys:

											  [valuePair substringWithRange:NSMakeRange(firstStartBold.length, firstEndBold.location-firstStartBold.length-1)], KEY_KEY,

											  [valuePair substringFromIndex:NSMaxRange(firstEndBold)], KEY_VALUE,

											  nil]];

						} else {

							[array addObject:[NSDictionary dictionaryWithObject:valuePair

																		forKey:KEY_VALUE]];

						}

					}

					[value release];

				}	

				break;

			}

		}

	}

	NSString *webProfileValue = [NSString stringWithFormat:@"%s</a>", _("View web profile")];

	NSInteger i;

	NSUInteger count = [array count];

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

		NSDictionary *dict = [array objectAtIndex:i];

		NSString *value = [dict objectForKey:KEY_VALUE];

		if (value &&

			[value rangeOfString:webProfileValue options:(NSBackwardsSearch | NSAnchoredSearch | NSLiteralSearch)].location != NSNotFound) {

			NSMutableString *newValue = [[value mutableCopy] autorelease];

			[newValue replaceOccurrencesOfString:webProfileValue

									  withString:[self webProfileStringForContact:contact]

										 options:(NSBackwardsSearch | NSAnchoredSearch | NSLiteralSearch)];

			NSMutableDictionary *replacementDict = [dict mutableCopy];

			[replacementDict setObject:newValue forKey:KEY_VALUE];

			[array replaceObjectAtIndex:i withObject:replacementDict];

			[replacementDict release];

			/* There will only be 1 (at most) web profile link */

			break;

		}

	}

	return array;

}

- (void)updateUserInfo:(AIListContact *)theContact withData:(PurpleNotifyUserInfo *)user_info

{

	NSArray		*profileContents = [self arrayOfDictionariesFromPurpleNotifyUserInfo:user_info forContact:theContact];

	[theContact setProfileArray:profileContents

					notify:NotifyLater];

	[self openInspectorForContactInfo:theContact];

	//Apply any changes

	[theContact notifyOfChangedPropertiesSilently:silentAndDelayed];

}

/*!

 * @brief Open the info inspector when getting info

 */

- (void)openInspectorForContactInfo:(AIListContact *)theContact

{

}

/*!

 * @brief Purple removed a contact from the local blist

 *

 * This can happen in many situations:

 *	- For every contact on an account when the account signs off

 *	- For a contact as it is deleted by the user

 *	- For a contact as it is deleted by Purple (e.g. when Sametime refuses an addition because it is known to be invalid)

 *	- In the middle of the move process as a contact moves from one group to another

 *

 * We need not take any action; we'll be notified of changes by Purple as necessary.

 */

- (void)removeContact:(AIListContact *)theContact

{

}

//To allow root level buddies on protocols which don't support them, we map any buddies in a group

//named after this account's UID to the root group.  These functions handle the mapping.  Group names should

//be filtered through incoming before being sent to Adium - and group names from Adium should be filtered through

//outgoing before being used.

- (NSString *)_mapIncomingGroupName:(NSString *)name

{

	if (!name || ([[name compactedString] caseInsensitiveCompare:self.UID] == NSOrderedSame)) {

		return ADIUM_ROOT_GROUP_NAME;

	} else {

		return name;

	}

}

- (NSString *)_mapOutgoingGroupName:(NSString *)name

{

	if ([[name compactedString] caseInsensitiveCompare:ADIUM_ROOT_GROUP_NAME] == NSOrderedSame) {

		return self.UID;

	} else {

		return name;

	}

}

//Update the status of a contact (Request their profile)

- (void)delayedUpdateContactStatus:(AIListContact *)inContact

{

    //Request profile

	[purpleAdapter getInfoFor:inContact.UID onAccount:self];

}

- (void)requestAddContactWithUID:(NSString *)contactUID

{

	[adium.contactController requestAddContactWithUID:contactUID

												service:[self _serviceForUID:contactUID]

												account:self];

}

- (AIService *)_serviceForUID:(NSString *)contactUID

{

	return self.service;

}

- (void)gotGroupForContact:(AIListContact *)listContact {};

/*!

 * @brief Return the serverside icon for a contact

 */

- (NSData *)serversideIconDataForContact:(AIListContact *)contact

{

	PurpleBuddy		*buddy;

	NSData			*data = nil;

	if (self.purpleAccount &&

		(buddy = purple_find_buddy(account, [contact.UID UTF8String]))) {

		PurpleBuddyIcon *buddyIcon;

		BOOL			shouldUnref = NO;

		/* First, try to get a current buddy icon from the PurpleBuddy */

		buddyIcon = purple_buddy_get_icon(buddy);

		if (!buddyIcon) {

			/* Failing that, load one from the cache. We'll need to unreference the returned PurpleBuddyIcon

			 * when we're done.

			 */

			buddyIcon = purple_buddy_icons_find(account, [contact.UID UTF8String]);

			shouldUnref = YES;

		}

		if (buddyIcon) {

			const guchar	*iconData;

			size_t			len;

			iconData = purple_buddy_icon_get_data(buddyIcon, &len);

			if (iconData && len) {

				data = [NSData dataWithBytes:iconData length:len];

			}

			if (shouldUnref)