/* 

 * 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 <Adium/AIChat.h>

#import <Adium/AIAccount.h>

#import <Adium/AIListObject.h>

#import <Adium/AIListContact.h>

#import <Adium/AIMessageEntryTextView.h>

#import <Adium/ESFileWrapperExtension.h>

#import <Adium/AITextAttachmentExtension.h>

#import <Adium/AIMenuControllerProtocol.h>

#import <Adium/AIContentControllerProtocol.h>

#import <Adium/AIInterfaceControllerProtocol.h>

#import <Adium/AIContentContext.h>

#import <AIUtilities/AIApplicationAdditions.h>

#import <AIUtilities/AIAttributedStringAdditions.h>

#import <AIUtilities/AIColorAdditions.h>

#import <AIUtilities/AITextAttributes.h>

#import <AIUtilities/AIImageAdditions.h>

#import <AIUtilities/AIFileManagerAdditions.h>

#import <AIUtilities/AIPasteboardAdditions.h>

#import <AIUtilities/AIBezierPathAdditions.h>

#import <Adium/AIContactControllerProtocol.h>

#import <FriBidi/NSString-FBAdditions.h>

#define MAX_HISTORY					25		//Number of messages to remember in history

#define ENTRY_TEXTVIEW_PADDING		6		//Padding for auto-sizing

#define KEY_DISABLE_TYPING_NOTIFICATIONS		@"Disable Typing Notifications"

#define KEY_SPELL_CHECKING						@"Spell Checking Enabled"

#define KEY_GRAMMAR_CHECKING					@"Grammar Checking Enabled"

#define	PREF_GROUP_DUAL_WINDOW_INTERFACE		@"Dual Window Interface"

#define INDICATOR_RIGHT_PADDING					2		// Padding between right side of the message view and the rightmost indicator

#define PREF_GROUP_CHARACTER_COUNTER			@"Character Counter"

#define KEY_CHARACTER_COUNTER_ENABLED			@"Character Counter Enabled"

#define KEY_MAX_NUMBER_OF_CHARACTERS			@"Maximum Number Of Characters"

#define FILES_AND_IMAGES_TYPES [NSArray arrayWithObjects: \

	NSFilenamesPboardType, AIiTunesTrackPboardType, NSTIFFPboardType, NSPDFPboardType, NSPICTPboardType, nil]

#define PASS_TO_SUPERCLASS_DRAG_TYPE_ARRAY [NSArray arrayWithObjects: \

	NSRTFPboardType, NSStringPboardType, nil]

/**

 * @class AISimpleTextView

 * @brief Just draws an attributed string. That's it.

 * 

 * No really, it's dead simple. It just draws an attributed string in its bounds (which you set). That's it.

 * It's totally not even useful.

 */

@implementation  AISimpleTextView

@synthesize string;

- (void)dealloc

{

	[string release];

	[super dealloc];

}

- (void)drawRect:(NSRect)rect 

{

	[string drawInRect:self.bounds];

}

@end

@interface AIMessageEntryTextView ()

- (void)_setPushIndicatorVisible:(BOOL)visible;

- (void)positionPushIndicator;

- (void)_resetCacheAndPostSizeChanged;

- (NSAttributedString *)attributedStringWithAITextAttachmentExtensionsFromRTFDData:(NSData *)data;

- (NSAttributedString *)attributedStringWithTextAttachmentExtension:(AITextAttachmentExtension *)attachment;

- (void)addAttachmentOfPath:(NSString *)inPath;

- (void)addAttachmentOfImage:(NSImage *)inImage;

- (void)addAttachmentsFromPasteboard:(NSPasteboard *)pasteboard;

- (void)setCharacterCounterVisible:(BOOL)visible;

- (void)setCharacterCounterMaximum:(int)inMaxCharacters;

- (void)setCharacterCounterPrefix:(NSString *)prefix;

- (void)updateCharacterCounter;

- (void)positionCharacterCounter;

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

@end

@interface NSMutableAttributedString (AIMessageEntryTextViewAdditions)

- (void)convertForPasteWithTraitsUsingAttributes:(NSDictionary *)inAttributes;

@end

@implementation AIMessageEntryTextView

- (void)_initMessageEntryTextView

{

	associatedView = nil;

	chat = nil;

	pushIndicator = nil;

	pushPopEnabled = YES;

	historyEnabled = YES;

	clearOnEscape = NO;

	homeToStartOfLine = YES;

	resizing = NO;

	enableTypingNotifications = NO;

	historyArray = [[NSMutableArray alloc] initWithObjects:@"",nil];

	pushArray = [[NSMutableArray alloc] init];

	currentHistoryLocation = 0;

	[self setDrawsBackground:YES];

	_desiredSizeCached = NSMakeSize(0,0);

	characterCounter = nil;

	characterCounterPrefix = nil;

	maxCharacters = 0;

	savedTextColor = nil;

	if ([self respondsToSelector:@selector(setAllowsUndo:)]) {

		[self setAllowsUndo:YES];

	}

	if ([self respondsToSelector:@selector(setAllowsDocumentBackgroundColorChange:)]) {

		[self setAllowsDocumentBackgroundColorChange:YES];

	}

	[self setImportsGraphics:YES];

	[[NSNotificationCenter defaultCenter] addObserver:self 

											 selector:@selector(textDidChange:)

												 name:NSTextDidChangeNotification 

											   object:self];

	[[NSNotificationCenter defaultCenter] addObserver:self

											 selector:@selector(frameDidChange:) 

												 name:NSViewFrameDidChangeNotification 

											   object:self];

	[[NSNotificationCenter defaultCenter] addObserver:self

															selector:@selector(toggleMessageSending:)

																name:@"AIChatDidChangeCanSendMessagesNotification"

															  object:chat];

	[[NSNotificationCenter defaultCenter] addObserver:self 

															selector:@selector(contentObjectAdded:) 

																name:Content_ContentObjectAdded 

															  object:nil];

	[adium.preferenceController registerPreferenceObserver:self forGroup:PREF_GROUP_DUAL_WINDOW_INTERFACE];	

	[[AIContactObserverManager sharedManager] registerListObjectObserver:self];

}

//Init the text view

- (id)initWithFrame:(NSRect)frameRect textContainer:(NSTextContainer *)aTextContainer

{

	if ((self = [super initWithFrame:frameRect textContainer:aTextContainer])) {

		[self _initMessageEntryTextView];

	}

    return self;

}

- (id)initWithCoder:(NSCoder *)coder

{

	if ((self = [super initWithCoder:coder])) {

		[self _initMessageEntryTextView];

	}

	return self;

}

- (void)dealloc

{

	if(chat.isGroupChat) {

		[chat removeObserver:self forKeyPath:@"Character Counter Max"];

		[chat removeObserver:self forKeyPath:@"Character Counter Prefix"];

	}

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	[adium.preferenceController unregisterPreferenceObserver:self];

	[[AIContactObserverManager sharedManager] unregisterListObjectObserver:self];

	[savedTextColor release];

	[characterCounter release];

	[characterCounterPrefix release];

    [chat release];

    [associatedView release];

    [historyArray release]; historyArray = nil;

    [pushArray release]; pushArray = nil;

    [super dealloc];

}

- (void) setDelegate:(id<AIMessageEntryTextViewDelegate>)del

{

	super.delegate = del;

}

- (id<AIMessageEntryTextViewDelegate>)delegate

{

	return super.delegate;

}

- (void)keyDown:(NSEvent *)inEvent

{

	NSString *charactersIgnoringModifiers = [inEvent charactersIgnoringModifiers];

	if ([charactersIgnoringModifiers length]) {

		unichar		 inChar = [charactersIgnoringModifiers characterAtIndex:0];

		unsigned int flags = [inEvent modifierFlags];

		//We have to test ctrl before option, because otherwise we'd miss ctrl-option-* events

		if (pushPopEnabled &&

			(flags & NSControlKeyMask) && !(flags & NSShiftKeyMask)) {

			if (inChar == NSUpArrowFunctionKey) {

				[self popContent];

			} else if (inChar == NSDownArrowFunctionKey) {

				[self pushContent];

			} else if (inChar == 's') {

				[self swapContent];

			} else {

				[super keyDown:inEvent];

			}

		} else if (historyEnabled && 

				   (flags & NSAlternateKeyMask) && !(flags & NSShiftKeyMask)) {

			if (inChar == NSUpArrowFunctionKey) {

				[self historyUp];

			} else if (inChar == NSDownArrowFunctionKey) {

				[self historyDown];

			} else {

				[super keyDown:inEvent];

			}

		} else if (associatedView &&

				   (flags & NSCommandKeyMask) && !(flags & NSShiftKeyMask)) {

			if ((inChar == NSUpArrowFunctionKey || inChar == NSDownArrowFunctionKey) ||

			   (inChar == NSHomeFunctionKey || inChar == NSEndFunctionKey) ||

			   (inChar == NSPageUpFunctionKey || inChar == NSPageDownFunctionKey)) {

				//Pass the associatedView a keyDown event equivalent equal to inEvent except without the modifier flags

				[associatedView keyDown:[NSEvent keyEventWithType:[inEvent type]

														 location:[inEvent locationInWindow]

													modifierFlags:0

														timestamp:[inEvent timestamp]

													 windowNumber:[inEvent windowNumber]

														  context:[inEvent context]

													   characters:[inEvent characters]

									  charactersIgnoringModifiers:charactersIgnoringModifiers

														isARepeat:[inEvent isARepeat]

														  keyCode:[inEvent keyCode]]];

			} else {

				[super keyDown:inEvent];

			}

		} else if (associatedView &&

				   (inChar == NSPageUpFunctionKey || inChar == NSPageDownFunctionKey)) {

			[associatedView keyDown:inEvent];

		} else if (inChar == NSHomeFunctionKey || inChar == NSEndFunctionKey) {

			if (homeToStartOfLine) {

				NSRange	newRange;

				if (flags & NSShiftKeyMask) {

					//With shift, select to the beginning/end of the line

					NSRange	selectedRange = [self selectedRange];

					if (inChar == NSHomeFunctionKey) {

						//Home: from 0 to the current location

						newRange.location = 0;

						newRange.length = selectedRange.location;

					} else {

						//End: from current location to the end

						newRange.location = selectedRange.location;

						newRange.length = [[self string] length] - newRange.location;

					}

				} else {

					newRange.location = ((inChar == NSHomeFunctionKey) ? 0 : [[self string] length]);

					newRange.length = 0;

				}

				[self setSelectedRange:newRange];

			} else {

				//If !homeToStartOfLine, pass the keypress to our associated view.

				if (associatedView) {

					[associatedView keyDown:inEvent];

				} else {

					[super keyDown:inEvent];					

				}

			}

		} else if (inChar == NSTabCharacter) {

			if ([self.delegate respondsToSelector:@selector(textViewShouldTabComplete:)] &&

				[self.delegate textViewShouldTabComplete:self]) {

				[self complete:nil];

			} else {

				[super keyDown:inEvent];				

			} 

		} else {

			[super keyDown:inEvent];

		}

	} else {

		[super keyDown:inEvent];

	}

}

//Text changed

- (void)textDidChange:(NSNotification *)notification

{

	//Update typing status

	if (enableTypingNotifications) {

		[adium.contentController userIsTypingContentForChat:chat hasEnteredText:[[self textStorage] length] > 0];

	}

	//Hide any existing contact list tooltip when we begin typing

	[adium.interfaceController showTooltipForListObject:nil atScreenPoint:NSZeroPoint onWindow:nil];

    //Reset cache and resize

	[self _resetCacheAndPostSizeChanged]; 

	//Update the character counter

	if (characterCounter) {

		[self updateCharacterCounter];

	}

}

/*!

 * @brief Clear any link attribute in the current typing attributes

 *

 * Any link attribute is removed. All other typing attributes are unchanged.

 */

- (void)clearLinkAttribute

{

	NSDictionary *typingAttributes = [self typingAttributes];

	if ([typingAttributes objectForKey:NSLinkAttributeName]) {

		NSMutableDictionary *newTypingAttributes = [typingAttributes mutableCopy];

		[newTypingAttributes removeObjectForKey:NSLinkAttributeName];

		[self setTypingAttributes:newTypingAttributes];

		[newTypingAttributes release];

	}

}

/*!

 * @brief The user pressed escape: clear our text view in response

 */

- (void)cancelOperation:(id)sender

{

	if (clearOnEscape) {

		NSUndoManager	*undoManager = [self undoManager];

		[undoManager registerUndoWithTarget:self

								   selector:@selector(setAttributedString:)

									 object:[[[self textStorage] copy] autorelease]];

		[undoManager setActionName:AILocalizedString(@"Clear", nil)];

		[self setString:@""];

		[self clearLinkAttribute];		

	}

	if ([self.delegate respondsToSelector:@selector(textViewDidCancel:)]) {

		[self.delegate textViewDidCancel:self];

	}

}

//Configure ------------------------------------------------------------------------------------------------------------

#pragma mark Configure

@synthesize clearOnEscape, homeToStartOfLine, associatedView;

- (void)preferencesChangedForGroup:(NSString *)group key:(NSString *)key

							object:(AIListObject *)object preferenceDict:(NSDictionary *)prefDict firstTime:(BOOL)firstTime

{

	if ((!object || (object == chat.account)) &&

		[group isEqualToString:GROUP_ACCOUNT_STATUS] &&

		(!key || [key isEqualToString:KEY_DISABLE_TYPING_NOTIFICATIONS])) {

		enableTypingNotifications = ![[chat.account preferenceForKey:KEY_DISABLE_TYPING_NOTIFICATIONS

																 group:GROUP_ACCOUNT_STATUS] boolValue];

	}

	if (!object &&

		[group isEqualToString:PREF_GROUP_DUAL_WINDOW_INTERFACE] &&

		(!key || [key isEqualToString:KEY_SPELL_CHECKING])) {

		[self setContinuousSpellCheckingEnabled:[[prefDict objectForKey:KEY_SPELL_CHECKING] boolValue]];

	}

	if (!object &&

		[group isEqualToString:PREF_GROUP_DUAL_WINDOW_INTERFACE] &&

		(!key || [key isEqualToString:KEY_GRAMMAR_CHECKING])) {

		[self setGrammarCheckingEnabled:[[prefDict objectForKey:KEY_GRAMMAR_CHECKING] boolValue]];

	}

}

//Adium Text Entry -----------------------------------------------------------------------------------------------------

#pragma mark Adium Text Entry

/*!

 * @brief Toggle whether message sending is enabled based on a notification. The notification object is the AIChat of the appropriate message entry view

 */

- (void)toggleMessageSending:(NSNotification *)not

{

	//XXX - We really should query the AIChat about this, but AIChat's "can't send" is really designed for handling offline, not banned. Bringing up the offline messaging dialog when banned would make no sense.

	[self setSendingEnabled:[[[not userInfo] objectForKey:@"TypingEnabled"] boolValue]];

}

/*!

 * @brief Are we available for sending?

 */

- (BOOL)availableForSending

{

	return self.sendingEnabled;

}

//Set our string, preserving the selected range

- (void)setAttributedString:(NSAttributedString *)inAttributedString

{

    int			length = [inAttributedString length];

    NSRange 	oldRange = [self selectedRange];

    //Change our string

    [[self textStorage] setAttributedString:inAttributedString];

    //Restore the old selected range

    if (oldRange.location < length) {

        if (oldRange.location + oldRange.length <= length) {

            [self setSelectedRange:oldRange];

        } else {

            [self setSelectedRange:NSMakeRange(oldRange.location, length - oldRange.location)];       

        }

    }

    //Notify everyone that our text changed

    [[NSNotificationCenter defaultCenter] postNotificationName:NSTextDidChangeNotification object:self];

}

//Set our string (plain text)

- (void)setString:(NSString *)string

{

    [super setString:string];

    //Notify everyone that our text changed

    [[NSNotificationCenter defaultCenter] postNotificationName:NSTextDidChangeNotification object:self];

}

//Set our typing format

- (void)setTypingAttributes:(NSDictionary *)attrs

{

	[super setTypingAttributes:attrs];

	[self setInsertionPointColor:[[attrs objectForKey:NSBackgroundColorAttributeName] contrastingColor]];

}

#pragma mark Pasting

- (BOOL)handlePasteAsRichText

{

	NSPasteboard *generalPasteboard = [NSPasteboard generalPasteboard];

	BOOL		 handledPaste = NO;

	//Types is ordered by the preference for handling of the data; enumerating it lets us allow the sending application's hints to be followed.

	for (NSString *type in generalPasteboard.types) {

		if ([type isEqualToString:NSRTFDPboardType]) {

			NSData *data = [generalPasteboard dataForType:NSRTFDPboardType];

			[self insertText:[self attributedStringWithAITextAttachmentExtensionsFromRTFDData:data]];

			handledPaste = YES;

		} else if ([PASS_TO_SUPERCLASS_DRAG_TYPE_ARRAY containsObject:type]) {

			//When we hit a type we should let the superclass handle, break without doing anything

			break;

		} else if ([FILES_AND_IMAGES_TYPES containsObject:type]) {

			[self addAttachmentsFromPasteboard:generalPasteboard];

			handledPaste = YES;

		}

		if (handledPaste) break;

	}

	return handledPaste;

}

//Paste as rich text without altering our typing attributes

- (void)pasteAsRichText:(id)sender

{

	NSDictionary	*attributes = [[self typingAttributes] copy];

	if (![self handlePasteAsRichText]) {

		[self paste:sender];

	}

	if (attributes) {

		[self setTypingAttributes:attributes];

	}

	[attributes release];

	[self scrollRangeToVisible:[self selectedRange]];

}

- (void)pasteAsPlainTextWithTraits:(id)sender

{

	NSDictionary	*attributes = [[self typingAttributes] copy];

	NSPasteboard	*generalPasteboard = [NSPasteboard generalPasteboard];

	NSString		*type;

	NSArray *supportedTypes =

		[NSArray arrayWithObjects:NSURLPboardType, NSRTFDPboardType, NSRTFPboardType, NSHTMLPboardType, NSStringPboardType, 

			NSFilenamesPboardType, NSTIFFPboardType, NSPDFPboardType, NSPICTPboardType, nil];

	type = [[NSPasteboard generalPasteboard] availableTypeFromArray:supportedTypes];

	if ([type isEqualToString:NSRTFPboardType] ||

		[type isEqualToString:NSRTFDPboardType] ||

		[type isEqualToString:NSHTMLPboardType] ||

		[type isEqualToString:NSStringPboardType]) {

		NSData *data;

		@try {

			data = [generalPasteboard dataForType:type];

		} @catch (NSException *localException) {

			data = nil;

		}

		//Failed. Try again with the string type.

		if (!data && ![type isEqualToString:NSStringPboardType]) {

			if ([[[NSPasteboard generalPasteboard] types] containsObject:NSStringPboardType]) {

				type = NSStringPboardType;

				@try {

					data = [generalPasteboard dataForType:type];

				} @catch (NSException *localException) {

					data = nil;

				}

			}

		}

		if (!data) {

			//We still didn't get valid data... maybe super can handle it

			@try {

				[self paste:sender];

			} @catch (NSException *localException) {

				NSBeep();

				return;

			}

		}

		NSMutableAttributedString *attributedString;

		if ([type isEqualToString:NSStringPboardType]) {

			NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

			attributedString = [[NSMutableAttributedString alloc] initWithString:string

																	  attributes:[self typingAttributes]];

			[string release];

		} else {

			@try {

				if ([type isEqualToString:NSRTFPboardType]) {

					attributedString = [[NSMutableAttributedString alloc] initWithRTF:data

																   documentAttributes:NULL];

				} else if ([type isEqualToString:NSRTFDPboardType]) {

					attributedString = [[NSMutableAttributedString alloc] initWithRTFD:data

																	documentAttributes:NULL];

				} else /* NSHTMLPboardType */ {

					attributedString = [[NSMutableAttributedString alloc] initWithHTML:data

																	documentAttributes:NULL];

				}

			} @catch (NSException *localException) {

				//Error while reading the RTF or HTML data, which can happen. Fall back on plain text

				if ([[[NSPasteboard generalPasteboard] types] containsObject:NSStringPboardType]) {

					data = [generalPasteboard dataForType:NSStringPboardType];

					NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

					attributedString = [[NSMutableAttributedString alloc] initWithString:string

																			  attributes:[self typingAttributes]];

					[string release];

				} else {

					attributedString = nil;

				}

			}

			if (!attributedString) {

				NSBeep();

				return;

			}

			[attributedString convertForPasteWithTraitsUsingAttributes:[self typingAttributes]];