/* 

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

#import <AdiumLibpurple/SLPurpleCocoaAdapter.h>

#import <Adium/AIAccountControllerProtocol.h>

#import <Adium/AIInterfaceControllerProtocol.h>

#import <Adium/AIStatusControllerProtocol.h>

#import <Adium/AIContactControllerProtocol.h>

#import <Adium/AIChat.h>

#import <Adium/AIHTMLDecoder.h>

#import <Adium/AIListContact.h>

#import <Adium/AIStatus.h>

#import <Adium/AIStatusIcons.h>

#import <Adium/ESFileTransfer.h>

#import <Adium/AIService.h>

#import <AIUtilities/AIApplicationAdditions.h>

#import <AIUtilities/AIAttributedStringAdditions.h>

#import <AIUtilities/AIDictionaryAdditions.h>

#import <AIUtilities/AIStringAdditions.h>

#import <libpurple/presence.h>

#import <libpurple/si.h>

#import <SystemConfiguration/SystemConfiguration.h>

#import "AMXMLConsoleController.h"

#import "AMPurpleJabberServiceDiscoveryBrowsing.h"

#import "ESPurpleJabberAccountViewController.h"

#import "AMPurpleJabberAdHocServer.h"

#import "AMPurpleJabberAdHocPing.h"

#define DEFAULT_JABBER_HOST @"@jabber.org"

@interface ESPurpleJabberAccount ()

- (BOOL)enableXMLConsole;

@end

@implementation ESPurpleJabberAccount

/*!

 * @brief The UID will be changed. The account has a chance to perform modifications

 *

 * Upgrade old Jabber accounts stored with the host in a separate key to have the right UID, in the form

 * name@server.org

 *

 * Append @jabber.org to a proposed UID which has no domain name and does not need to be updated.

 *

 * @param proposedUID The proposed, pre-filtered UID (filtered means it has no characters invalid for this servce)

 * @result The UID to use; the default implementation just returns proposedUID.

 */

- (NSString *)accountWillSetUID:(NSString *)proposedUID

{

	proposedUID = [proposedUID lowercaseString];

	NSString	*correctUID;

	if ((proposedUID && ([proposedUID length] > 0)) && 

	   ([proposedUID rangeOfString:@"@"].location == NSNotFound)) {

		NSString	*host;

		//Upgrade code: grab a previously specified Jabber host

		if ((host = [self preferenceForKey:@"Jabber:Host" group:GROUP_ACCOUNT_STATUS])) {

			//Determine our new, full UID

			correctUID = [NSString stringWithFormat:@"%@@%@",proposedUID, host];

			//Clear the preference and then set the UID so we don't perform this upgrade again

			[self setPreference:nil forKey:@"Jabber:Host" group:GROUP_ACCOUNT_STATUS];

			[self setPreference:correctUID forKey:@"FormattedUID" group:GROUP_ACCOUNT_STATUS];

		} else {

			//Append [self serverSuffix] (e.g. @jabber.org) to a Jabber account with no server

			correctUID = [proposedUID stringByAppendingString:[self serverSuffix]];

		}

	} else {

		correctUID = proposedUID;

	}

	return correctUID;

}

- (const char*)protocolPlugin

{

   return "prpl-jabber";

}

- (void)dealloc

{

	[xmlConsoleController close];

	[xmlConsoleController release];

	[super dealloc];

}

- (NSSet *)supportedPropertyKeys

{

	static NSMutableSet *supportedPropertyKeys = nil;

	if (!supportedPropertyKeys) {

		supportedPropertyKeys = [[NSMutableSet alloc] initWithObjects:

			@"AvailableMessage",

			@"Invisible",

			nil];

		[supportedPropertyKeys unionSet:[super supportedPropertyKeys]];

	}

	return supportedPropertyKeys;

}

- (void)configurePurpleAccount

{

	[super configurePurpleAccount];

	NSString	*connectServer;

	BOOL		forceOldSSL, allowPlaintext, requireTLS;

	purple_account_set_username(account, self.purpleAccountName);

	//'Connect via' server (nil by default)

	connectServer = [self preferenceForKey:KEY_JABBER_CONNECT_SERVER group:GROUP_ACCOUNT_STATUS];

	//XXX - As of libpurple 2.0.0, 'localhost' doesn't work properly by 127.0.0.1 does. Hack!

	if (connectServer && [connectServer isEqualToString:@"localhost"])

		connectServer = @"127.0.0.1";

	purple_account_set_string(account, "connect_server", (connectServer ?

														[connectServer UTF8String] :

														""));

	NSString *boshServer = [self preferenceForKey:KEY_JABBER_BOSH_SERVER group:GROUP_ACCOUNT_STATUS];

	purple_account_set_string(account, "bosh_url", (boshServer ? [boshServer UTF8String] : ""));

	// FT proxies

	NSString *ftProxies = [self preferenceForKey:KEY_JABBER_FT_PROXIES group:GROUP_ACCOUNT_STATUS];

	if (ftProxies.length) {

		purple_account_set_string(account, "ft_proxies", [ftProxies UTF8String]);

	}

	//Force old SSL usage? (off by default)

	forceOldSSL = [[self preferenceForKey:KEY_JABBER_FORCE_OLD_SSL group:GROUP_ACCOUNT_STATUS] boolValue];

	purple_account_set_bool(account, "old_ssl", forceOldSSL);

	//Require SSL or TLS? (off by default)

	requireTLS = [[self preferenceForKey:KEY_JABBER_REQUIRE_TLS group:GROUP_ACCOUNT_STATUS] boolValue];

	purple_account_set_bool(account, "require_tls", requireTLS);

	//Allow plaintext authorization over an unencrypted connection? Purple will prompt if this is NO and is needed.

	allowPlaintext = [[self preferenceForKey:KEY_JABBER_ALLOW_PLAINTEXT group:GROUP_ACCOUNT_STATUS] boolValue];

	purple_account_set_bool(account, "auth_plain_in_clear", allowPlaintext);

	/* Mac OS X 10.4's cyrus-sasl's PLAIN mech gives us problems.  Is it a bug in the installed library, a bug in its compilation, or a bug

	 * in our linkage against it? I don't know. The result is that the username gets included twice before the base64 encoding is performed.

	 *

	 * Furthermore, on any version, using the cyrus-sasl PLAIN mech prevents us from following Google Talk best practices for handling of domain names.

	 * This is because we can't add to the <auth> response's attributes:

	 *		xmlns:ga='http://www.google.com/talk/protocol/auth' ga:client-uses-full-bind-result='true'

	 * as per http://code.google.com/apis/talk/jep_extensions/jid_domain_change.html and therefore we won't automatically resolve changing an

	 * "@gmail.com" to "@googlemail.com" or some other domain name.

	 *

	 * We therefore use the PLAIN implementation in libpurple itself. Libpurple's own DIGEST-MD5 is always used for compatibility with old OpenFire

	 * servers.

	 *

	 * This preference and the changes for it are added via the "libpurple_jabber_avoid_sasl_option_hack.diff" patch we apply during the build process.

	 */

	purple_prefs_set_bool("/plugins/prpl/jabber/avoid_sasl_for_plain_auth", YES);

}

- (NSString *)serverSuffix

{

	NSString *host = [self preferenceForKey:KEY_JABBER_CONNECT_SERVER group:GROUP_ACCOUNT_STATUS];

	return (host ? host : DEFAULT_JABBER_HOST);

}

/*!	@brief	Obtain the resource name for this Jabber account.

 *

 *	This could be extended in the future to perform keyword substitution (e.g. s/%computerName%/CSCopyMachineName()/).

 *

 *	@return	The resource name for the account.

 */

- (NSString *)resourceName

{

    NSString *resource = [self preferenceForKey:KEY_JABBER_RESOURCE group:GROUP_ACCOUNT_STATUS];

    if(resource == nil || [resource length] == 0)

        resource = [(NSString*)SCDynamicStoreCopyLocalHostName(NULL) autorelease];

	return resource;

}

- (const char *)purpleAccountName

{

	NSString	*userNameWithHost = nil, *completeUserName = nil;

	BOOL		serverAppendedToUID;

	/*

	 * Purple stores the username in the format username@server/resource.  We need to pass it a username in this format

	 *

	 * The user should put the username in username@server format, which is common for Jabber. If the user does

	 * not specify the server, use jabber.org.

	 */

	serverAppendedToUID = ([UID rangeOfString:@"@"].location != NSNotFound);

	if (serverAppendedToUID) {

		userNameWithHost = UID;

	} else {

		userNameWithHost = [UID stringByAppendingString:[self serverSuffix]];

	}

	completeUserName = [NSString stringWithFormat:@"%@/%@" ,userNameWithHost, [self resourceName]];

	return [completeUserName UTF8String];

}

/*!

 * @brief Connect Host

 *

 * Convenience method for retrieving the connect host for this account

 *

 * Rather than having a separate server field, Jabber uses the servername after the user name.

 * username@server.org

 *

 * The connect server, stored in KEY_JABBER_CONNECT_SERVER, overrides this to provide the connect host. It will

 * not be set in most cases.

 */

- (NSString *)host

{

	NSString	*host;

	if (!(host = [self preferenceForKey:KEY_JABBER_CONNECT_SERVER group:GROUP_ACCOUNT_STATUS])) {

		NSUInteger location = [UID rangeOfString:@"@"].location;

		if ((location != NSNotFound) && (location + 1 < [UID length])) {

			host = [UID substringFromIndex:(location + 1)];

		} else {

			host = [self serverSuffix];

		}

	}

	return host;

}

/*!

 * @brief Should set aliases serverside?

 *

 * Jabber supports serverside aliases.

 */

- (BOOL)shouldSetAliasesServerside

{

	return YES;

}

- (AIListContact *)contactWithUID:(NSString *)sourceUID

{

	AIListContact	*contact;

	contact = [adium.contactController existingContactWithService:service

															account:self

																UID:sourceUID];

	if (!contact) {		

		contact = [adium.contactController contactWithService:[self _serviceForUID:sourceUID]

														account:self

															UID:sourceUID];

	}

	return contact;

}

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

{

	AIService	*contactService;

	NSString	*contactServiceID = nil;

	if ([contactUID hasSuffix:@"@gmail.com"] ||

		[contactUID hasSuffix:@"@googlemail.com"]) {

		contactServiceID = @"libpurple-jabber-gtalk";

	} else if([contactUID hasSuffix:@"@livejournal.com"]){

		contactServiceID = @"libpurple-jabber-livejournal";

	} else {

		contactServiceID = @"libpurple-Jabber";

	}

	contactService = [adium.accountController serviceWithUniqueID:contactServiceID];

	return contactService;

}

- (id)authorizationRequestWithDict:(NSDictionary*)dict {

	switch ([[self preferenceForKey:KEY_JABBER_SUBSCRIPTION_BEHAVIOR group:GROUP_ACCOUNT_STATUS] intValue]) {

		case 2: // always accept + add

			// add

			{

				NSString *groupname = [self preferenceForKey:KEY_JABBER_SUBSCRIPTION_GROUP group:GROUP_ACCOUNT_STATUS];

				if ([groupname length] > 0) {

					AIListContact *contact = [adium.contactController contactWithService:self.service account:self UID:[dict objectForKey:@"Remote Name"]];

					AIListGroup *group = [adium.contactController groupWithUID:groupname];

					[contact.account addContact:contact toGroup:group];

				}

			}

			// fallthrough

		case 1: // always accept

			[[self purpleAdapter] doAuthRequestCbValue:[[[dict objectForKey:@"authorizeCB"] retain] autorelease] withUserDataValue:[[[dict objectForKey:@"userData"] retain] autorelease]];

			break;

		case 3: // always deny

			[[self purpleAdapter] doAuthRequestCbValue:[[[dict objectForKey:@"denyCB"] retain] autorelease] withUserDataValue:[[[dict objectForKey:@"userData"] retain] autorelease]];

			break;

		default: // ask (should be 0)

			return [super authorizationRequestWithDict:dict];

	}

	return NULL;

}

- (void)purpleAccountRegistered:(BOOL)success

{

	if(success && [self.service accountViewController]) {

		const char *usernamestr = purple_account_get_username(account);

		NSString *username;

		if (usernamestr) {

			NSString *userWithResource = [NSString stringWithUTF8String:usernamestr];

			NSRange slashrange = [userWithResource rangeOfString:@"/"];

			if(slashrange.location != NSNotFound)

				username = [userWithResource substringToIndex:slashrange.location];

			else

				username = userWithResource;

		} else

			username = (id)[NSNull null];

		NSString *pw = (purple_account_get_password(account) ? [NSString stringWithUTF8String:purple_account_get_password(account)] : [NSNull null]);

		[[NSNotificationCenter defaultCenter] postNotificationName:AIAccountUsernameAndPasswordRegisteredNotification

												  object:self

												userInfo:[NSDictionary dictionaryWithObjectsAndKeys:

													username, @"username",

													pw, @"password",

													nil]];

	}

}

#pragma mark Status

- (NSString *)encodedAttributedString:(NSAttributedString *)inAttributedString forListObject:(AIListObject *)inListObject

{

	static AIHTMLDecoder *jabberHtmlEncoder = nil;

	if (!jabberHtmlEncoder) {

		jabberHtmlEncoder = [[AIHTMLDecoder alloc] init];

		[jabberHtmlEncoder setIncludesHeaders:NO];

		[jabberHtmlEncoder setIncludesFontTags:YES];

		[jabberHtmlEncoder setClosesFontTags:YES];

		[jabberHtmlEncoder setIncludesStyleTags:YES];

		[jabberHtmlEncoder setIncludesColorTags:YES];

		[jabberHtmlEncoder setEncodesNonASCII:NO];

		[jabberHtmlEncoder setPreservesAllSpaces:NO];

		[jabberHtmlEncoder setUsesAttachmentTextEquivalents:YES];

	}

	return [jabberHtmlEncoder encodeHTML:inAttributedString imagesPath:nil];

}

- (NSString *)_UIDForAddingObject:(AIListContact *)object

{

	NSString	*objectUID = object.UID;

	NSString	*properUID;

	if ([objectUID rangeOfString:@"@"].location != NSNotFound) {

		properUID = objectUID;

	} else {

		properUID = [NSString stringWithFormat:@"%@@%@",objectUID,self.host];

	}

	return [properUID lowercaseString];

}

- (NSString *)unknownGroupName {

    return (AILocalizedString(@"Roster","Roster - the Jabber default group"));

}

- (NSString *)connectionStringForStep:(int)step

{

	switch (step) {

		case 0:

			return AILocalizedString(@"Connecting",nil);

			break;

		case 1:

			return AILocalizedString(@"Initializing Stream",nil);

			break;

		case 2:

			return AILocalizedString(@"Reading data",nil);

			break;			

		case 3:

			return AILocalizedString(@"Authenticating",nil);

			break;

		case 5:

			return AILocalizedString(@"Initializing Stream",nil);

			break;

		case 6:

			return AILocalizedString(@"Authenticating",nil);

			break;

	}

	return nil;

}

- (AIReconnectDelayType)shouldAttemptReconnectAfterDisconnectionError:(NSString **)disconnectionError

{

	AIReconnectDelayType shouldAttemptReconnect = [super shouldAttemptReconnectAfterDisconnectionError:disconnectionError];

	if (([self lastDisconnectionReason] == PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR) &&

		([self shouldVerifyCertificates])) {

		shouldAttemptReconnect = AIReconnectNever;

	} else if (!finishedConnectProcess && ![password length] &&

			   (disconnectionError &&

			   ([*disconnectionError isEqualToString:[NSString stringWithUTF8String:_("Read Error")]] ||

				[*disconnectionError isEqualToString:[NSString stringWithUTF8String:_("Service Unavailable")]] ||

				[*disconnectionError isEqualToString:[NSString stringWithUTF8String:_("Forbidden")]]))) {

		//No password specified + above error while we're connecting = behavior of various broken servers. Prompt for a password.

		[self serverReportedInvalidPassword];

		shouldAttemptReconnect = AIReconnectImmediately;

	}

	return shouldAttemptReconnect;

}

- (void)disconnectFromDroppedNetworkConnection

{

	/* Before we disconnect from a dropped network connection, set gc->disconnect_timeout to a non-0 value.

	 * This will let the prpl know that we are disconnecting with no backing ssl connection and that therefore

	 * the ssl connection is has should not be messaged in the process of disconnecting.

	 */

	PurpleConnection *gc = purple_account_get_connection(account);

	if (PURPLE_CONNECTION_IS_VALID(gc) &&

		!gc->disconnect_timeout) {

		gc->disconnect_timeout = -1;

		AILog(@"%@: Disconnecting from a dropped network connection", self);

	}

	[super disconnectFromDroppedNetworkConnection];

}

#pragma mark File transfer

- (BOOL)canSendFolders

{

	return NO;

}

- (void)beginSendOfFileTransfer:(ESFileTransfer *)fileTransfer

{

	[super _beginSendOfFileTransfer:fileTransfer];

}

- (void)acceptFileTransferRequest:(ESFileTransfer *)fileTransfer

{

    [super acceptFileTransferRequest:fileTransfer];    

}

- (void)rejectFileReceiveRequest:(ESFileTransfer *)fileTransfer

{

    [super rejectFileReceiveRequest:fileTransfer];    

}

- (void)cancelFileTransfer:(ESFileTransfer *)fileTransfer

{

	[super cancelFileTransfer:fileTransfer];

}

#pragma mark Status Messages

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

{

	NSString		*statusName = nil;

	PurplePresence	*presence = purple_buddy_get_presence(buddy);

	PurpleStatus		*status = purple_presence_get_active_status(presence);

	const char		*purpleStatusID = purple_status_get_id(status);

	if (!purpleStatusID) return nil;

	if (!strcmp(purpleStatusID, jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_CHAT))) {

		statusName = STATUS_NAME_FREE_FOR_CHAT;

	} else if (!strcmp(purpleStatusID, jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_XA))) {

		statusName = STATUS_NAME_EXTENDED_AWAY;

	} else if (!strcmp(purpleStatusID, jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_DND))) {

		statusName = STATUS_NAME_DND;

	}

	return statusName;

}

#pragma mark Menu items

- (NSString *)titleForContactMenuLabel:(const char *)label forContact:(AIListContact *)inContact

{

	if (strcmp(label, "Un-hide From") == 0) {

		return [NSString stringWithFormat:AILocalizedString(@"Un-hide From %@",nil),inContact.formattedUID];

	} else if (strcmp(label, "Temporarily Hide From") == 0) {

		return [NSString stringWithFormat:AILocalizedString(@"Temporarily Hide From %@",nil),inContact.formattedUID];

	} else if (strcmp(label, "Unsubscribe") == 0) {

		return [NSString stringWithFormat:AILocalizedString(@"Unsubscribe %@",nil),inContact.formattedUID];

	} else if (strcmp(label, "(Re-)Request authorization") == 0) {

		return [NSString stringWithFormat:AILocalizedString(@"Re-request Authorization from %@",nil),inContact.formattedUID];

	} else if (strcmp(label,  "Cancel Presence Notification") == 0) {

		return [NSString stringWithFormat:AILocalizedString(@"Cancel Presence Notification to %@",nil),inContact.formattedUID];	

	} else if (strcmp(label,  _("Ping")) == 0) {

		return [NSString stringWithFormat:AILocalizedString(@"Ping %@",nil),inContact.formattedUID];	

	}

	return [super titleForContactMenuLabel:label forContact:inContact];

}

- (NSString *)titleForAccountActionMenuLabel:(const char *)label

{	

	if (strcmp(label, "Set User Info...") == 0) {

		return [AILocalizedString(@"Set User Info", nil) stringByAppendingEllipsis];

	} else 	if (strcmp(label, "Search for Users...") == 0) {

		return [AILocalizedString(@"Search for Users", nil) stringByAppendingEllipsis];

	} else 	if (strcmp(label, "Set Mood...") == 0) {

		return [AILocalizedString(@"Set Mood", nil) stringByAppendingEllipsis];

	} else 	if (strcmp(label, "Set Nickname...") == 0) {

		return [AILocalizedString(@"Set Nickname", nil) stringByAppendingEllipsis];

	} 

	return [super titleForAccountActionMenuLabel:label];

}

#pragma mark Multiuser chat

/*!

 * @brief A chat will be joined

 *

 * This gives the account a chance to update any information in the chat's creation dictionary if desired.

 *

 * @result The final chat creation dictionary to use.

 */

- (NSDictionary *)willJoinChatUsingDictionary:(NSDictionary *)chatCreationDictionary

{

	if (![[chatCreationDictionary objectForKey:@"handle"] length]) {

		NSMutableDictionary *dict = [[chatCreationDictionary mutableCopy] autorelease];

		[dict setObject:self.displayName

				 forKey:@"handle"];

		chatCreationDictionary = dict;

	}

	return chatCreationDictionary;

}

- (BOOL)chatCreationDictionary:(NSDictionary *)chatCreationDict isEqualToDictionary:(NSDictionary *)baseDict

{

	/* If the chat isn't keeping track of a handle, it's because we added it in

	 * willJoinChatUsingDictionary: above. Remove it from baseDict so the comparison is accurate.

	 */

	if (![chatCreationDict objectForKey:@"handle"])

		baseDict = [baseDict dictionaryWithDifferenceWithSetOfKeys:[NSSet setWithObject:@"handle"]];