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

| 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:@" "];