/*-------------------------------------------------------------------------------------------------------*\

 | Adium, Copyright (C) 2001-2006, Adam Iser  (adamiser@mac.com | http://www.adiumx.com)                   |

 \---------------------------------------------------------------------------------------------------------/

  | 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.

  \------------------------------------------------------------------------------------------------------ */

 /*

 	A quick and simple HTML to Attributed string converter (ha! --jmelloy)

 */

 #import <Adium/AIHTMLDecoder.h>

 #import <AIUtilities/AIApplicationAdditions.h>

 #import <AIUtilities/AITextAttributes.h>

 #import <AIUtilities/AIAttributedStringAdditions.h>

 #import <AIUtilities/AIColorAdditions.h>

 #import <AIUtilities/AIDictionaryAdditions.h>

 #import <AIUtilities/AIStringAdditions.h>

 #import <AIUtilities/AIFileManagerAdditions.h>

 #import <AIUtilities/AIImageAdditions.h>

 #import <AIUtilities/AIFileManagerAdditions.h>

 #import <Adium/AITextAttachmentExtension.h>

 #import <Adium/ESFileWrapperExtension.h>

 #import <Adium/AIXMLElement.h>

 #import <FriBidi/NSString-FBAdditions.h>

 #import <CoreServices/CoreServices.h>

 int HTMLEquivalentForFontSize(int fontSize);

 @interface AIHTMLDecoder ()

 - (NSDictionary *)processFontTagArgs:(NSDictionary *)inArgs attributes:(AITextAttributes *)textAttributes;

 - (void)processBodyTagArgs:(NSDictionary *)inArgs attributes:(AITextAttributes *)textAttributes;

 - (void)processLinkTagArgs:(NSDictionary *)inArgs attributes:(AITextAttributes *)textAttributes;

 - (NSDictionary *)processSpanTagArgs:(NSDictionary *)inArgs attributes:(AITextAttributes *)textAttributes;

 - (void)processDivTagArgs:(NSDictionary *)inArgs attributes:(AITextAttributes *)textAttributes;

 - (NSAttributedString *)processImgTagArgs:(NSDictionary *)inArgs attributes:(AITextAttributes *)textAttributes baseURL:(NSString *)baseURL;

 - (BOOL)appendImage:(NSImage *)attachmentImage

 			 atPath:(NSString *)inPath

 		   toString:(NSMutableString *)string

 		   withName:(NSString *)inName 

 		 imageClass:(NSString *)imageClass

 		 imagesPath:(NSString *)imagesPath

 	  uniqueifyHTML:(BOOL)uniqueifyHTML;

 - (void)restoreAttributesFromDict:(NSDictionary *)inAttributes intoAttributes:(AITextAttributes *)textAttributes;

 @end

 @interface NSString (AIHTMLDecoderAdditions)

 - (NSString *)stringByConvertingWingdingsToUnicode;

 - (NSString *)stringByConvertingSymbolToSymbolUnicode;

 @end

 @implementation AIHTMLDecoder

 static NSString			*horizontalRule = nil;

 + (void)initialize

 {

 	//Set up the horizontal rule which will be searched-for when encoding and inserted when decoding

 	if ((self == [AIHTMLDecoder class])) {

 #define HORIZONTAL_BAR			0x2013

 #define HORIZONTAL_RULE_LENGTH	12

 		const unichar separatorUTF16[HORIZONTAL_RULE_LENGTH] = {

 			'\n', HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR,

 			HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, HORIZONTAL_BAR, '\n'

 		};

 		horizontalRule = [[NSString alloc] initWithCharacters:separatorUTF16 length:HORIZONTAL_RULE_LENGTH];

 	}	

 }

 - (void) dealloc {

 	[XMLNamespace release]; XMLNamespace = nil;

 	[baseURL release]; baseURL = nil;

 	[super dealloc];

 }

 + (AIHTMLDecoder *)decoder

 {

 	return [[[self alloc] init] autorelease];

 }

 - (id)initWithHeaders:(BOOL)includeHeaders

 			 fontTags:(BOOL)includeFontTags

 		closeFontTags:(BOOL)closeFontTags

 			colorTags:(BOOL)includeColorTags

 			styleTags:(BOOL)includeStyleTags

 	   encodeNonASCII:(BOOL)encodeNonASCII

 		 encodeSpaces:(BOOL)encodeSpaces

 	attachmentsAsText:(BOOL)attachmentsAsText

 onlyIncludeOutgoingImages:(BOOL)onlyIncludeOutgoingImages

 	   simpleTagsOnly:(BOOL)simpleOnly

 	   bodyBackground:(BOOL)bodyBackground

   allowJavascriptURLs:(BOOL)allowJS

 {

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

 		thingsToInclude.headers							= includeHeaders;

 		thingsToInclude.fontTags						= includeFontTags;

 		thingsToInclude.closingFontTags					= closeFontTags;

 		thingsToInclude.colorTags						= includeColorTags;

 		thingsToInclude.styleTags						= includeStyleTags;

 		thingsToInclude.nonASCII						= encodeNonASCII;

 		thingsToInclude.allSpaces						= encodeSpaces;

 		thingsToInclude.attachmentTextEquivalents		= attachmentsAsText;

 		thingsToInclude.onlyIncludeOutgoingImages	= onlyIncludeOutgoingImages;

 		thingsToInclude.simpleTagsOnly					= simpleOnly;

 		thingsToInclude.bodyBackground					= bodyBackground;

 		thingsToInclude.allowJavascriptURLs				= allowJS;

 		thingsToInclude.allowAIMsubprofileLinks			= NO;

 	}

 	return self;

 }

 + (AIHTMLDecoder *)decoderWithHeaders:(BOOL)includeHeaders

 							 fontTags:(BOOL)includeFontTags

 						closeFontTags:(BOOL)closeFontTags

 							colorTags:(BOOL)includeColorTags

 							styleTags:(BOOL)includeStyleTags

 					   encodeNonASCII:(BOOL)encodeNonASCII

 						 encodeSpaces:(BOOL)encodeSpaces

 					attachmentsAsText:(BOOL)attachmentsAsText

 			onlyIncludeOutgoingImages:(BOOL)onlyIncludeOutgoingImages

 					   simpleTagsOnly:(BOOL)simpleOnly

 					   bodyBackground:(BOOL)bodyBackground

                   allowJavascriptURLs:(BOOL)allowJS

 {

 	return [[[self alloc] initWithHeaders:includeHeaders

 								 fontTags:includeFontTags

 							closeFontTags:closeFontTags

 								colorTags:includeColorTags

 								styleTags:includeStyleTags

 						   encodeNonASCII:encodeNonASCII

 							 encodeSpaces:encodeSpaces

 						attachmentsAsText:attachmentsAsText

 		   onlyIncludeOutgoingImages:onlyIncludeOutgoingImages

 						   simpleTagsOnly:simpleOnly

 						   bodyBackground:bodyBackground

 					  allowJavascriptURLs:allowJS] autorelease];

 }

 #pragma mark Work methods

 /*!

  * @brief Parse arguments in a string

  *

  * The arguments are returned in an NSDictionary whose keys are all-lowercase

  */

 - (NSDictionary *)parseArguments:(NSString *)arguments

 {

 	NSMutableDictionary		*argDict;

 	NSScanner				*scanner;

 	static NSCharacterSet	*equalsSet = nil,

 		*dquoteSet = nil,

 		*squoteSet = nil,

 		*spaceSet = nil;

 	NSString				*key = nil, *value = nil;

 	//Setup

 	if (!equalsSet) equalsSet = [[NSCharacterSet characterSetWithCharactersInString:@"="]  retain];

 	if (!dquoteSet) dquoteSet = [[NSCharacterSet characterSetWithCharactersInString:@"\""] retain];

 	if (!squoteSet) squoteSet = [[NSCharacterSet characterSetWithCharactersInString:@"'"]  retain];

 	if (!spaceSet)  spaceSet  = [[NSCharacterSet characterSetWithCharactersInString:@" "]  retain];

 	scanner = [NSScanner scannerWithString:arguments];

 	argDict = [NSMutableDictionary dictionary];

 	while (![scanner isAtEnd]) {

 		BOOL	validKey, validValue;

 		//Find a tag

 		validKey = [scanner scanUpToCharactersFromSet:equalsSet intoString:&key];

 		[scanner scanCharactersFromSet:equalsSet intoString:nil];

 		//check for quotes

 		if ([scanner scanCharactersFromSet:dquoteSet intoString:nil]) {

 			validValue = [scanner scanUpToCharactersFromSet:dquoteSet intoString:&value];

 			[scanner scanCharactersFromSet:dquoteSet intoString:nil];

 		} else if ([scanner scanCharactersFromSet:squoteSet intoString:nil]) {

 			validValue = [scanner scanUpToCharactersFromSet:squoteSet intoString:&value];

 			[scanner scanCharactersFromSet:squoteSet intoString:nil];

 		} else {

 			validValue = [scanner scanUpToCharactersFromSet:spaceSet intoString:&value];

 		}

 		//Store in dict

 		if (validValue && value != nil && [value length] != 0 && validKey && key != nil && [key length] != 0) { //Watch out for invalid & empty tags

 			[argDict setObject:value forKey:[key lowercaseString]];

 		}

 	}

 	return argDict;

 }

 - (NSString *)encodeLooseHTML:(NSAttributedString *)inMessage imagesPath:(NSString *)imagesSavePath

 {

 	NSFontManager	*fontManager = [NSFontManager sharedFontManager];

 	NSRange			 searchRange;

 	NSColor			*pageColor = nil;

 	BOOL			 openFontTag = NO;

 	//Setup the incoming message as a regular string, and get its length

 	NSString		*inMessageString = [inMessage string];

 	unsigned		 messageLength = [inMessageString length];

 	//Setup the destination HTML string

 	NSMutableString *string = [NSMutableString string];

 	if (thingsToInclude.headers) {

 		[string appendString:@"<HTML>"];

 	}

 	//If the text is right-to-left, enclose all our HTML in an rtl DIV tag

 	BOOL	rightToLeft = NO;

 	if (!thingsToInclude.simpleTagsOnly) {

 		if (messageLength > 0) {

 			//First, attempt to figure the base writing direction of our message based on its content

 			NSWritingDirection	dir = [inMessageString baseWritingDirection];

 			//If that doesn't work, try using the writing direction of the input field

 			if (dir == NSWritingDirectionNatural) {

 				dir = [[inMessage attribute:NSParagraphStyleAttributeName

 									atIndex:0

 							 effectiveRange:nil] baseWritingDirection];

 				//If the input field's writing direction is NSWritingDirectionNatural, we shall figure what it really means.

 				//The natural writing direction is determined by the system based on the current active localization of the app.

 				if (dir == NSWritingDirectionNatural)

 					dir = [NSParagraphStyle defaultWritingDirectionForLanguage:nil];

 			}

 			if (dir == NSWritingDirectionRightToLeft) {

 				[string appendString:@"<DIV dir=\"rtl\">"];

 				rightToLeft = YES;

 			}

 		}

 	}	

 	//Setup the default attributes

 	NSString		*currentFamily = nil;

 	NSString		*currentColor = nil;

 	NSString		*currentBackColor = nil;

 	int				 currentSize = 0;

 	BOOL			 currentItalic = NO;

 	BOOL			 currentBold = NO;

 	BOOL			 currentUnderline = NO;

 	BOOL			 currentStrikethrough = NO;

 	NSString		*link = nil;

 	NSString		*oldLink = nil;

 	//Append the body tag (If there is a background color)

 	if (thingsToInclude.headers &&

 	   (messageLength > 0) &&

 	   (pageColor = [inMessage attribute:AIBodyColorAttributeName

 								 atIndex:0

 						  effectiveRange:nil])) {

 		[string appendString:@"<BODY BGCOLOR=\"#"];

 		[string appendString:[pageColor hexString]];

 		[string appendString:@"\">"];

 	}

 	//Loop through the entire string

 	searchRange = NSMakeRange(0,0);

 	while (searchRange.location < messageLength) {

 		NSDictionary	*attributes = [inMessage attributesAtIndex:searchRange.location effectiveRange:&searchRange];

 		NSFont			*font = [attributes objectForKey:NSFontAttributeName];

 		NSString		*color = (thingsToInclude.colorTags ? [[attributes objectForKey:NSForegroundColorAttributeName] hexString] : nil);

 		NSString		*backColor = (thingsToInclude.colorTags ? [[attributes objectForKey:NSBackgroundColorAttributeName] hexString] : nil);

 		NSString		*familyName = [font familyName];

 		float			 pointSize = [font pointSize];

 		NSFontTraitMask	 traits = [fontManager traitsOfFont:font];

 		BOOL			 hasUnderline = [[attributes objectForKey:NSUnderlineStyleAttributeName] intValue];

 		BOOL			 hasStrikethrough = [[attributes objectForKey:NSStrikethroughStyleAttributeName] intValue];

 		BOOL			 isBold = (traits & NSBoldFontMask);

 		BOOL			 isItalic = (traits & NSItalicFontMask);

 		link = [[attributes objectForKey:NSLinkAttributeName] absoluteString];

 		//If we had a link on the last pass, and we don't now or we have a different one, close the link tag

 		if (oldLink &&

 			(!link || (([link length] != 0) && ![oldLink isEqualToString:link]))) {

 			//Close Link

 			[string appendString:@"</a>"];

 			oldLink = nil;

 		}

 		NSMutableString	*chunk = [[inMessageString substringWithRange:searchRange] mutableCopy];

 		//Font (If the color, font, or size has changed)

 		BOOL changedSize = (pointSize != currentSize);

 		BOOL changedColor = ((color && ![color isEqualToString:currentColor]) || (!color && currentColor));

 		BOOL changedBackColor = ((backColor && ![backColor isEqualToString:currentBackColor]) || (!backColor && currentBackColor));

 		if((thingsToInclude.fontTags && (changedSize || ![familyName isEqualToString:currentFamily])) ||

 		   changedColor || changedBackColor) {

 			//Close any existing font tags, and open a new one

 			if (thingsToInclude.closingFontTags && openFontTag) {

 				[string appendString:@"</FONT>"];

 			}

 			if (!thingsToInclude.simpleTagsOnly) {

 				openFontTag = YES;

 				//Leave the <FONT open since we'll add the rest of the font tag on below

 				[string appendString:@"<FONT"];

 			}

 			//Family

 			if (thingsToInclude.fontTags && familyName && (![familyName isEqualToString:currentFamily] || thingsToInclude.closingFontTags)) {

 				if (thingsToInclude.simpleTagsOnly) {

 					[string appendString:[NSString stringWithFormat:@"<FONT FACE=\"%@\">",familyName]];

 				} else {

 					//(traits | NSNonStandardCharacterSetFontMask) seems to be the proper test... but it is true for all fonts!

 					//NSMacOSRomanStringEncoding seems to be the encoding of all standard Roman fonts... and langNum="11" seems to make the others send properly.

 					//It serves us well here.  Once non-AIM HTML is coming through, this will probably need to be an option in the function call.

 					if ([font mostCompatibleStringEncoding] != NSMacOSRomanStringEncoding) {

 						[string appendString:[NSString stringWithFormat:@" FACE=\"%@\" LANG=\"11\"",familyName]];

 					} else {

 						[string appendString:[NSString stringWithFormat:@" FACE=\"%@\"",familyName]];

 					}

 				}

 				[currentFamily release]; currentFamily = [familyName retain];

 			}

 			//Size

 			if (thingsToInclude.fontTags && font && !thingsToInclude.simpleTagsOnly) {

 				[string appendString:[NSString stringWithFormat:@" ABSZ=%i SIZE=%i", (int)pointSize, HTMLEquivalentForFontSize((int)pointSize)]];

 				currentSize = pointSize;

 			}

 			//Color

 			if (color) {

 				if (thingsToInclude.simpleTagsOnly) {

 					[string appendString:[NSString stringWithFormat:@"<FONT COLOR=\"#%@\">",color]];	

 				} else {

 					[string appendString:[NSString stringWithFormat:@" COLOR=\"#%@\"",color]];

 				}

 			}

 			//Background Color per tag

 			if (backColor) {

 				if (!thingsToInclude.simpleTagsOnly) {	

 					[string appendString:[NSString stringWithFormat:@" BACK=\"#%@\"",backColor]];

 				}

 			}

 			if (color != currentColor) {

 				currentColor = color;

 			}

 			if (backColor != currentBackColor) {

 				currentBackColor = backColor;

 			}

 			//Close the font tag if necessary

 			if (!thingsToInclude.simpleTagsOnly) {

 				[string appendString:@">"];

 			}

 		}

 		//Style (Bold, italic, underline, strikethrough)

 		if (thingsToInclude.styleTags) {			

 			if (currentItalic && !isItalic) {

 				[string appendString:@"</I>"];

 				currentItalic = NO;

 			} else  if (!currentItalic && isItalic) {

 				[string appendString:@"<I>"];

 				currentItalic = YES;

 			}

 			if (currentUnderline && !hasUnderline) {

 				[string appendString:@"</U>"];

 				currentUnderline = NO;

 			} else if (!currentUnderline && hasUnderline) {

 				[string appendString:@"<U>"];

 				currentUnderline = YES;

 			}

 			if (currentBold && !isBold) {

 				[string appendString:@"</B>"];

 				currentBold = NO;

 			} else if (!currentBold && isBold) {

 				[string appendString:@"<B>"];

 				currentBold = YES;

 			}

 			if (currentStrikethrough && !hasStrikethrough) {

 				[string appendString:@"</S>"];

 				currentStrikethrough = NO;

 			} else if (!currentStrikethrough && hasStrikethrough) {

 				[string appendString:@"<S>"];

 				currentStrikethrough = YES;

 			}

 		}

 		//Link

 		if (!oldLink && link && [link length] != 0) {

 			NSString	*linkString = ([link isKindOfClass:[NSURL class]] ? [(NSURL *)link absoluteString] : link);

 			/* For incoming messages, javascript urls are both dangerous and useless.

 			 * If thingsToInclude.allowJavascriptURLs is NO, we refuse to create <a> tags for links starting with javascript.

 			 * This probably should be set to NO for outgoing messages, to avoid MSN-style-censorship accusations.

 			 */

 			if (thingsToInclude.allowJavascriptURLs || [linkString rangeOfString:@"javascript"].location > 0) {

 				[string appendString:@"<a href=\""];

 				/* AIM can handle %n in links, which is highly invalid for a real URL.

 				 * If thingsToInclude.allowAIMsubprofileLinks is YES, and a %25n is in the link, replace the escaped version

 				 * which was used within Adium [so that NSURL didn't balk] with %n, which is what other AIM clients will

 				 * be expecting.

 				 */

 				if (thingsToInclude.allowAIMsubprofileLinks && 

 				   ([linkString rangeOfString:@"%25n"].location != NSNotFound)) {

 					NSMutableString	*fixedLinkString = [[linkString mutableCopy] autorelease];

 					[fixedLinkString replaceOccurrencesOfString:@"%25n"

 													 withString:@"%n"

 														options:NSLiteralSearch

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

 					linkString = fixedLinkString;

 				}

 				[string appendString:[linkString stringByEscapingForXMLWithEntities:nil]];

 				if (!thingsToInclude.simpleTagsOnly) {

 					[string appendString:@"\" title=\""];

 					[string appendString:[linkString stringByEscapingForXMLWithEntities:nil]];

 				}

 				NSString *classString = [attributes objectForKey:AIElementClassAttributeName];

 				if (!thingsToInclude.simpleTagsOnly && classString) {

 					[string appendString:@"\" class=\""];

 					[string appendString:classString];

 				}

 				[string appendString:@"\">"];

 				oldLink = linkString;

 			}

 		}

 		//Image Attachments

 		if ([attributes objectForKey:NSAttachmentAttributeName]) {

 			//Each attachment takes a character.. they are grouped by the attribute scan

 			for (int i = 0; (i < searchRange.length); i++) { 

 				NSTextAttachment *textAttachment = [[inMessage attributesAtIndex:searchRange.location+i 

 																  effectiveRange:nil] objectForKey:NSAttachmentAttributeName];

 				if (textAttachment) {

 					if (![textAttachment isKindOfClass:[AITextAttachmentExtension class]]) {

 						NSLog(@"Message %@ gave an NSTextAttachment %@ - why is it not an AITextAttachmentExtension?",

 							  inMessage,

 							  textAttachment);

 						continue;

 					}

 					AITextAttachmentExtension *attachment = (AITextAttachmentExtension *)textAttachment;

 					/* If we have a path to which we want to save any images and either

 					 *		the attachment should save such images OR

 					 *		the attachment is a plain NSTextAttachment and so doesn't respond to shouldSaveImageForLogging

 					 *

 					 * If we should save the image, we'll also tell the appendImage method to uniquify the HTML so it'll load

 					 * from disk each time it's displayed, preventing a WebView from caching it.

 					 */						

 					BOOL shouldSaveImage = (imagesSavePath &&

 											((![attachment respondsToSelector:@selector(shouldSaveImageForLogging)] ||

 											  [attachment shouldSaveImageForLogging])));

 					/* We want attachments as images where appropriate. We either want all images (we don't want only outgoing images) or

 					 * this attachment may be sent as an image rather than as text.

 					 */						

 					BOOL shouldIncludeImageWithoutSaving = (!thingsToInclude.attachmentTextEquivalents &&

 															(!thingsToInclude.onlyIncludeOutgoingImages || (![attachment respondsToSelector:@selector(shouldAlwaysSendAsText)] ||

 																											![attachment shouldAlwaysSendAsText])));

 					BOOL appendedImage = NO;

 					if (shouldSaveImage || shouldIncludeImageWithoutSaving) {

 						NSString	*existingPath, *imageName;

 						NSImage		*image;

 						//We want to use the image; collect all the information we have available

 						existingPath = ([attachment respondsToSelector:@selector(path)] ?

 										[attachment performSelector:@selector(path)] :

 										nil);

 						imageName = [attachment string];

 						image = nil;

 						/*

 							Although PDFs are treated as images on OSX, they can cause issues on other platforms.

 							Also, moreso than most other images, they can be too large to display inline.

 						 */

 						if(!existingPath || ![[existingPath pathExtension] isEqualToString:@"pdf"])

 						{

 							if ([attachment respondsToSelector:@selector(image)])

 								image = [attachment performSelector:@selector(image)];

 							else if ([[attachment attachmentCell] respondsToSelector:@selector(image)])

 								image = [[attachment attachmentCell] performSelector:@selector(image)];

 						}

 						if (existingPath || image) {

 							appendedImage = [self appendImage:image

 													   atPath:existingPath

 													 toString:string

 													 withName:imageName

 												   imageClass:[attachment imageClass]

 												   imagesPath:(shouldIncludeImageWithoutSaving ? imagesSavePath : nil)

 												uniqueifyHTML:shouldSaveImage];

 							//We were succesful appending the image tag, so release this chunk

 							[chunk release]; chunk = nil;	

 						}

 					}

 					if (!appendedImage) {

 						//We should replace the attachment with its textual equivalent if we didn't append an image

 						NSString	*attachmentString;

 						if ((attachmentString = [attachment string])) {

 							[string appendString:attachmentString];

 						}

 						[chunk release]; chunk = nil;

 					}

 				}

 			}

 		}

 		if (chunk) {

 			NSRange	fullRange;

 			unsigned int replacements;

 			//Escape special HTML characters.

 			fullRange = NSMakeRange(0, [chunk length]);

 			replacements = [chunk replaceOccurrencesOfString:@"&" withString:@"&"

 													 options:NSLiteralSearch range:fullRange];

 			fullRange.length += (replacements * 4);

 			replacements = [chunk replaceOccurrencesOfString:@"<" withString:@"&lt;"

 									  options:NSLiteralSearch range:fullRange];

 			fullRange.length += (replacements * 3);

 			replacements = [chunk replaceOccurrencesOfString:@">" withString:@">"

 													 options:NSLiteralSearch range:fullRange];

 			fullRange.length += (replacements * 3);

 			//Horizontal rule

 			replacements = [chunk replaceOccurrencesOfString:horizontalRule withString:@"<HR>"

 													 options:NSLiteralSearch range:fullRange];

 			if (replacements) {

 				fullRange.length = [chunk length];

 			}

 			if (thingsToInclude.allSpaces) {

 				/* Replace the tabs first, if they exist, so that it creates a leading " " when the tab is the initial character, and 

 				 * so subsequent tab formatting is preserved.

 				 */

 				replacements = [chunk replaceOccurrencesOfString:@"\t" 

 													  withString:@"    "

 														 options:NSLiteralSearch

 														   range:fullRange];

 				fullRange.length += (replacements * 18);

 				//If the first character is a space, replace that leading ' ' with " " to preserve formatting.

 				if ([chunk hasPrefix:@" "]) {

 					[chunk replaceCharactersInRange:NSMakeRange(0, 1)

 										 withString:@" "];

 					fullRange.length += 5;

 				}

 				/* Replace all remaining blocks of "  " (<space><space>) with " &nbsp;" (<space><&nbsp;>) so that

 				 * formatting of large blocks of spaces in the middle of a line is preserved,

 				 * and so WebKit properly line-wraps.

 				 */

 				[chunk replaceOccurrencesOfString:@"  "

 									   withString:@"  "

 										  options:NSLiteralSearch

 											range:fullRange];

 			}

 			/* Encode line endings */

 			//Handle \r\n as a single line break

 			[chunk replaceOccurrencesOfString:@"\r\n"

 								   withString:@"<BR>"

 									  options:NSLiteralSearch 

 										range:fullRange];

 			//Now replace every remaining line ending

 			NSRange lineEndingRange;

 			while ((lineEndingRange = [chunk rangeOfLineBreakCharacter]).location != NSNotFound) {

 				[chunk replaceCharactersInRange:lineEndingRange

 									 withString:@"<BR>"];

 			}

 			/* If we need to encode non-ASCII to HTML, append string character by

 			 * character, replacing any non-ascii characters with the designated SGML escape sequence.

 			 */

 			if (thingsToInclude.nonASCII) {

 				unsigned length = [chunk length];

 				for (unsigned i = 0; i < length; i++) {

 					unichar currentChar = [chunk characterAtIndex:i];

 					if (currentChar < 32) {

 						//Control character.

 						[string appendFormat:@"&#x%x;", currentChar];

 					} else if (currentChar >= 127) {

 						if (!UCIsSurrogateHighCharacter(currentChar)) {

 							[string appendFormat:@"&#x%x;", currentChar];

 						} else {

 							//currentChar is the high character of a surrogate pair.

 							unichar lowSurrogate = 0xFFFF;

 							if ((i + 1) < length) {

 								lowSurrogate = [chunk characterAtIndex:++i];

 							}

 							if (!UCIsSurrogateLowCharacter(lowSurrogate)) {

 								//In case you're wondering: 0xFFFF is not a low surrogate. (Nor anything else, for that matter.)

 								AILog(@"AIHTMLDecoder: Got high surrogate of surrogate pair, but there's no low surrogate after it. This is at index %u of chunk with length %u. The chunk is: %@", i, length, chunk);

 							} else {

 								UnicodeScalarValue codePoint = UCGetUnicodeScalarValueForSurrogatePair(/*highSurrogate*/ currentChar, lowSurrogate);

 								[string appendFormat:@"&#x%x;", codePoint];

 							}

 						}

 					} else {

 						//unichar characters may have a length of up to 3; be careful to get the whole character

 						NSRange composedCharRange = [chunk rangeOfComposedCharacterSequenceAtIndex:i];

 						[string appendString:[chunk substringWithRange:composedCharRange]];

 						i += composedCharRange.length - 1;

 					}

 				}

 			} else {

 				[string appendString:chunk];

 			}

 			//Release the chunk

 			[chunk release];

 		}

 		searchRange.location += searchRange.length;

 	}

 	[currentFamily release];

 	//Finish off the HTML

 	if (thingsToInclude.styleTags) {

 		if (currentItalic)        [string appendString:@"</I>"];

 		if (currentBold)          [string appendString:@"</B>"];

 		if (currentUnderline)     [string appendString:@"</U>"];

 		if (currentStrikethrough) [string appendString:@"</S>"];

 	}

 	//If we had a link on the last pass, close the link tag

 	if (oldLink) {

 		//Close Link

 		[string appendString:@"</a>"];

 		oldLink = nil;

 	}

 	if (thingsToInclude.fontTags && thingsToInclude.closingFontTags && openFontTag) {

 		//Close any open font tag

 		[string appendString:@"</FONT>"];

 	}

 	if (rightToLeft) {

 		//Close any open div

 		[string appendString:@"</DIV>"];

 	}

 	if (thingsToInclude.headers && pageColor) {

 		//Close the body tag

 		[string appendString:@"</BODY>"];

 	}

 	if (thingsToInclude.headers) {

 		//Close the HTML

 		[string appendString:@"</HTML>"];

 	}

 	//KBOTC's odd hackish body background thingy for WMV since no one else will add it

 	if (thingsToInclude.bodyBackground &&

 	   (messageLength > 0)) {

 		[string setString:@""];

 		if ((pageColor = [inMessage attribute:AIBodyColorAttributeName atIndex:0 effectiveRange:nil])) {

 			[string setString:[pageColor hexString]];

 			[string replaceOccurrencesOfString:@"\"" 

 									withString:@"" 

 									   options:NSLiteralSearch

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

 		}

 	}

 	return string;

 }

 - (AIXMLElement *)elementWithAppKitAttributes:(NSDictionary *)attributes

 							   attributeNames:(NSSet *)attributeNames

 							   elementContent:(NSMutableString *)elementContent

 		  shouldAddElementContentToTopElement:(out BOOL *)outAddElementContentToTopElement

 								   imagesPath:(NSString *)imagesPath

 {

 	if (!(attributes && [attributes count] && attributeNames && [attributeNames count]))

 		return nil;

 	attributes = [attributes dictionaryWithIntersectionWithSetOfKeys:attributeNames];

 	NSString         *linkValue       = [attributes objectForKey:NSLinkAttributeName];

 	NSTextAttachment *attachmentValue = [attributes objectForKey:NSAttachmentAttributeName];

 	NSString *elementName = linkValue ? @"a" : @"span";

 	BOOL moreThanJustAnImage = [attributes count] - (attachmentValue != nil);

 	BOOL addElementContentToTopElement = YES;

 	AIXMLElement *thisElement = moreThanJustAnImage ? [AIXMLElement elementWithNamespaceName:XMLNamespace elementName:elementName] : nil;

 	if (linkValue) {

 		[thisElement setValue:linkValue forAttribute:@"href"];

 	}

 	if (attachmentValue) {

 		AITextAttachmentExtension *extension;

 		if ([attachmentValue isKindOfClass:[AITextAttachmentExtension class]])

 			extension = (AITextAttachmentExtension *)attachmentValue;

 		else

 			extension = [AITextAttachmentExtension textAttachmentExtensionFromTextAttachment:attachmentValue];

 		if ((thingsToInclude.attachmentTextEquivalents ||

 			 !imagesPath ||

 			([extension respondsToSelector:@selector(shouldAlwaysSendAsText)] && [extension shouldAlwaysSendAsText])) &&

 			([extension respondsToSelector:@selector(string)])) {

 			[elementContent setString:[extension string]];

 		} else {

 			/* We have an image we want to save if possible, and we have an imagesPath */

 			AIXMLElement *imageElement = [AIXMLElement elementWithNamespaceName:XMLNamespace elementName:@"img"];

 			[imageElement setSelfCloses:YES];

 			NSTextAttachmentCell *cell = (NSTextAttachmentCell *)[attachmentValue attachmentCell];

 			NSSize size = [cell cellSize];

 			[imageElement setValue:[[NSNumber numberWithFloat:size.width] stringValue] forAttribute:@"width"];

 			[imageElement setValue:[[NSNumber numberWithFloat:size.height] stringValue] forAttribute:@"height"];

 			NSString *path = [extension path];

 			if (path) {

 				NSString *destinationPath = [imagesPath stringByAppendingPathComponent:[path lastPathComponent]];

 				if ([[NSFileManager defaultManager] copyItemAtPath:path

 													  toPath:destinationPath

 													 error:NULL]) {

 					/* Just the file name; the XML should be set to have a base URL of the imagesPath */

 					/* It might be good to make this an optional behavior, with the other choice of an absolute

 					 * file URL (destinationPath).

 					 */

 					[imageElement setValue:[path lastPathComponent]

 							  forAttribute:@"src"];					

 				} else {

 					AILogWithSignature(@"Could not copy %@ to %@", path, destinationPath);

 				}

 			}

 			if (elementContent && [elementContent length]) {

 				[imageElement setValue:elementContent forAttribute:@"alt"];

 			}

 			if (thisElement) {

 				[thisElement addObject:imageElement];

 			} else {

 				thisElement = imageElement;

 			}

 			addElementContentToTopElement = NO;

 		}

 	}

 	NSString *CSSString = [NSAttributedString CSSStringForTextAttributes:attributes];

 	if (CSSString && [CSSString length]) {

 		[thisElement setValue:CSSString forAttribute:@"style"];

 	}

 	if (outAddElementContentToTopElement) {

 		*outAddElementContentToTopElement = addElementContentToTopElement;

 	}

 	return thisElement;

 }

 - (NSDictionary *)attributesByReplacingNSFontAttributeNameWithAIFontAttributeNames:(NSDictionary *)attributes

 {

 	NSFont *font = [[attributes objectForKey:NSFontAttributeName] retain];

 	if (!font) {

 		return [[attributes retain] autorelease];

 	} else {

 		NSMutableDictionary *mutableAttributes = [attributes mutableCopy];

 		[mutableAttributes removeObjectForKey:NSFontAttributeName];

 		[mutableAttributes setObject:[font familyName]

 		                      forKey:AIFontFamilyAttributeName];

 		[mutableAttributes setObject:[NSString stringWithFormat:@"%@pt", [NSString stringWithFloat:[font pointSize] maxDigits:2]]

 		                      forKey:AIFontSizeAttributeName];

 		NSFontTraitMask traits = [[NSFontManager sharedFontManager] traitsOfFont:font];

 		if (traits & NSBoldFontMask) {

 			[mutableAttributes setObject:@"bold" forKey:AIFontWeightAttributeName];

 		}

 		if (traits & NSItalicFontMask) {

 			[mutableAttributes setObject:@"italic" forKey:AIFontStyleAttributeName];

 		}

 		[font release];

 		NSDictionary *result = [NSDictionary dictionaryWithDictionary:mutableAttributes];

 		[mutableAttributes release];

 		return result;

 	}

 }

 - (AIXMLElement *)rootStrictXHTMLElementForAttributedString:(NSAttributedString *)inMessage imagesPath:(NSString *)imagesSavePath

 {

 	NSRange			 searchRange;

 	//Setup the incoming message as a regular string, and get its length

 	NSString		*inMessageString = [inMessage string];

 	unsigned		 messageLength = [inMessageString length];

 	NSSet *emptySet = [NSSet set];

 	//These two stacks are parallel. For every element, there should be a set of attribute names, and vice versa.

 	NSMutableArray *elementStack = [NSMutableArray array];

 	NSMutableArray *attributeNamesStack = [NSMutableArray array];

 	//Root element: includeHeaders ? <html> : <div>

 	if (thingsToInclude.headers) {

 		[elementStack addObject:[AIXMLElement elementWithNamespaceName:XMLNamespace elementName:@"html"]];

 		[attributeNamesStack addObject:emptySet];

 		AIXMLElement *bodyElement = [AIXMLElement elementWithNamespaceName:XMLNamespace elementName:@"body"];

 		[[elementStack lastObject] addObject:bodyElement];

 		[elementStack addObject:bodyElement];

 		[attributeNamesStack addObject:emptySet];

 		NSColor *pageColor;

 		if ((messageLength > 0) &&

 		   (pageColor = [inMessage attribute:AIBodyColorAttributeName

 									 atIndex:0

 							  effectiveRange:NULL]))

 		{

 			[bodyElement setValue:[@"background-color: " stringByAppendingString:[pageColor CSSRepresentation]] forAttribute:@"style"];

 		}

 	}

 	AIXMLElement *divElement = [AIXMLElement elementWithNamespaceName:XMLNamespace elementName:@"div"];

 	//If the text is right-to-left, enclose all our HTML in an rtl div tag

 	if ((messageLength > 0) &&

 		([[inMessage attribute:NSParagraphStyleAttributeName

 					   atIndex:0

 				effectiveRange:nil] baseWritingDirection] == NSWritingDirectionRightToLeft))

 	{

 		[divElement setValue:@"rtl" forAttribute:@"dir"];

 	}

 	[[elementStack lastObject] addObject:divElement];

 	[elementStack addObject:divElement];

 	[attributeNamesStack addObject:emptySet];

 	NSMutableSet *CSSCapableAttributes = [[[NSAttributedString CSSCapableAttributesSet] mutableCopy] autorelease];

 	[CSSCapableAttributes addObject:NSLinkAttributeName];

 	NSSet *CSSCapableAttributesWithNoAttachment = [NSSet setWithSet:CSSCapableAttributes];

 	[CSSCapableAttributes addObject:NSAttachmentAttributeName];

 	NSDictionary *prevAttributes = nil;

 	//Loop through the entire string, handling each attribute run.

 	searchRange = NSMakeRange(0,messageLength);

 	while (searchRange.location < messageLength) {

 		NSRange runRange;

 		NSDictionary *attributes = [self attributesByReplacingNSFontAttributeNameWithAIFontAttributeNames:[inMessage attributesAtIndex:searchRange.location 

 																												 longestEffectiveRange:&runRange

 																															   inRange:searchRange]];

 		attributes = [attributes dictionaryWithIntersectionWithSetOfKeys:CSSCapableAttributes];

 		NSSet *startedKeys = nil, *endedKeys = nil;

 		[attributes compareWithPriorDictionary:prevAttributes

 		                          getAddedKeys:&startedKeys

 		                        getRemovedKeys:&endedKeys

 		                    includeChangedKeys:YES];

 		prevAttributes = [attributes dictionaryWithIntersectionWithSetOfKeys:CSSCapableAttributesWithNoAttachment];

 		if([attributes objectForKey:NSAttachmentAttributeName] != nil)

 			runRange.length = 1;  //Encode a single image at a time

 		NSMutableSet *mutableEndedKeys = [endedKeys mutableCopy];

 		if (mutableEndedKeys) {

 			//First handle attributes that have ended or changed.

 			if ([mutableEndedKeys count]) {

 				NSMutableSet *attributesToRestore = [NSMutableSet set];

 				NSRange popRange = { [attributeNamesStack count], 0 };

 				while ([mutableEndedKeys count]) {

 					--popRange.location; ++popRange.length;

 					NSMutableSet *attributeNames = [attributeNamesStack objectAtIndex:popRange.location];