/* 

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

 #import "DCMessageContextDisplayPlugin.h"

 #import "DCMessageContextDisplayPreferences.h"

 #import <AIUtilities/AIDictionaryAdditions.h>

 #import <Adium/AIChat.h>

 #import <Adium/AIContentContext.h>

 #import <Adium/AIService.h>

 //Old school

 #import <Adium/AIListContact.h>

 #import <AIUtilities/AIAttributedStringAdditions.h>

 #import <Adium/AIAccountControllerProtocol.h>

 //omg crawsslinkz

 #import "AILoggerPlugin.h"

 //LMX

 #import <LMX/LMXParser.h>

 #import <Adium/AIXMLElement.h>

 #import <AIUtilities/AIStringAdditions.h>

 #import "unistd.h"

 #import <AIUtilities/NSCalendarDate+ISO8601Parsing.h>

 #import <Adium/AIContactControllerProtocol.h>

 #import <Adium/AIHTMLDecoder.h>

 #define RESTORED_CHAT_CONTEXT_LINE_NUMBER 50

 /**

  * @class DCMessageContextDisplayPlugin

  * @brief Component to display in-window message history

  *

  * The amount of history, and criteria of when to display history, are determined in the Advanced->Message History preferences.

  */

 @interface DCMessageContextDisplayPlugin ()

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

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

 - (NSArray *)contextForChat:(AIChat *)chat;

 @end

 @implementation DCMessageContextDisplayPlugin

 /**

  * @brief Install

  */

 - (void)installPlugin

 {

 	isObserving = NO;

 	//Setup our preferences

     [adium.preferenceController registerDefaults:[NSDictionary dictionaryNamed:CONTEXT_DISPLAY_DEFAULTS

 																		forClass:[self class]] 

 										  forGroup:PREF_GROUP_CONTEXT_DISPLAY];

 	//Observe preference changes for whether or not to display message history

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

 }

 /**

  * @brief Uninstall

  */

 - (void)uninstallPlugin

 {

 	[adium.preferenceController unregisterPreferenceObserver:self];

 	[[NSNotificationCenter defaultCenter] removeObserver:self];

 }

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

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

 {

 	if (!object) {		

 		shouldDisplay = [[prefDict objectForKey:KEY_DISPLAY_CONTEXT] boolValue];

 		linesToDisplay = [[prefDict objectForKey:KEY_DISPLAY_LINES] integerValue];

 		if (shouldDisplay && linesToDisplay > 0 && !isObserving) {

 			//Observe new message windows only if we aren't already observing them

 			isObserving = YES;

 			[[NSNotificationCenter defaultCenter] addObserver:self

 										   selector:@selector(addContextDisplayToWindow:)

 											   name:Chat_DidOpen 

 											 object:nil];

 		} else if (isObserving && (!shouldDisplay || linesToDisplay <= 0)) {

 			//Remove observer

 			isObserving = NO;

 			[[NSNotificationCenter defaultCenter] removeObserver:self name:Chat_DidOpen object:nil];

 		}

 	}

 }

 /**

  * @brief Retrieve and display in-window message history

  *

  * Called in response to the Chat_DidOpen notification

  */

 - (void)addContextDisplayToWindow:(NSNotification *)notification

 {

 	AIChat	*chat = (AIChat *)[notification object];

 	NSArray	*context = [self contextForChat:chat];

 	if (context && [context count] > 0 && shouldDisplay) {

 		AIContentContext	*contextMessage;

 		for(contextMessage in context) {

 			/* Don't display immediately, so the message view can aggregate multiple message history items.

 			 * As required, we post Content_ChatDidFinishAddingUntrackedContent when finished adding. */

 			[contextMessage setDisplayContentImmediately:NO];

 			[adium.contentController displayContentObject:contextMessage

 										usingContentFilters:YES

 												immediately:YES];

 		}

 		//We finished adding untracked content

 		[[NSNotificationCenter defaultCenter] postNotificationName:Content_ChatDidFinishAddingUntrackedContent

 												  object:chat];

 	}

 }

 /*!

  * @brief Retrieve the message history for a particular chat

  *

  * Asks AILoggerPlugin for the path to the right file, and then uses LMX to parse that file backwards.

  */

 - (NSArray *)contextForChat:(AIChat *)chat

 {

 	//If there's no log there, there's no message history. Bail out.

 	NSArray *logPaths = [AILoggerPlugin sortedArrayOfLogFilesForChat:chat];

 	if(!logPaths) return nil;

 	NSInteger linesLeftToFind = 0;

 	AIHTMLDecoder *decoder = [AIHTMLDecoder decoder];

 	NSString *logObjectUID = chat.name;

 	if (!logObjectUID) logObjectUID = chat.listObject.UID;

 	logObjectUID = [logObjectUID safeFilenameString];

 	NSString *baseLogPath = [[AILoggerPlugin logBasePath] stringByAppendingPathComponent:

 		[AILoggerPlugin relativePathForLogWithObject:logObjectUID onAccount:chat.account]];	

 	if ([chat boolValueForProperty:@"Restored Chat"] && linesToDisplay < RESTORED_CHAT_CONTEXT_LINE_NUMBER) {

 		linesLeftToFind = MAX(linesLeftToFind, RESTORED_CHAT_CONTEXT_LINE_NUMBER);

 	} else {

 		linesLeftToFind = linesToDisplay;		

 	}

 	//Initialize a place to store found messages

 	NSMutableArray *outerFoundContentContexts = [NSMutableArray arrayWithCapacity:linesLeftToFind]; 

 	//Iterate over the elements of the log path array.

 	NSEnumerator *pathsEnumerator = [logPaths objectEnumerator];

 	NSString *logPath = nil;

 	while (linesLeftToFind > 0 && (logPath = [pathsEnumerator nextObject])) {

 		//If it's not a .chatlog, ignore it.

 		if (![logPath hasSuffix:@".chatlog"])

 			continue;

 		//Stick the base path on to the beginning

 		logPath = [baseLogPath stringByAppendingPathComponent:logPath];

 		//By default, the xmlFilePath is the chat log file/bundle... if we find that the chatlog is a bundle, we'll use the xml file inside.

 		NSString *xmlFilePath = logPath;

 		BOOL isDir;

 		if ([[NSFileManager defaultManager] fileExistsAtPath:logPath isDirectory:&isDir]) {

 			/* If we have a chatLog bundle, we want to get the text content for the xml file inside */

 			NSString *baseURL;

 			if (isDir) {

 				baseURL = logPath;

 				xmlFilePath = [logPath stringByAppendingPathComponent:

 							   [[[logPath lastPathComponent] stringByDeletingPathExtension] stringByAppendingPathExtension:@"xml"]];

 			} else {

 				baseURL = nil;

 			}

 			[decoder setBaseURL:baseURL];

 		}

 		//Initialize the found messages array and element stack for us-as-delegate

 		foundMessages = [NSMutableArray arrayWithCapacity:linesLeftToFind];

 		elementStack = [NSMutableArray array];

 		//Create the parser and set ourselves as the delegate

 		LMXParser *parser = [LMXParser parser];

 		[parser setDelegate:self];

 		//Set up info needed by elementStarted to create content objects.

 		NSMutableDictionary *contextInfo = nil;

 		{

 			//Get the service name from the path name

 			NSString *serviceName = [[[[[logPath stringByDeletingLastPathComponent] stringByDeletingLastPathComponent] lastPathComponent] componentsSeparatedByString:@"."] objectAtIndex:0U];

 			AIListObject *account = chat.account;

 			NSString	 *accountID = [NSString stringWithFormat:@"%@.%@", account.service.serviceID, account.UID];

 			contextInfo = [NSMutableDictionary dictionaryWithObjectsAndKeys:

 						   serviceName, @"Service name",

 						   account, @"Account",

 						   accountID, @"Account ID",

 						   chat, @"Chat",

 						   decoder, @"AIHTMLDecoder",

 						   [NSValue valueWithPointer:&linesLeftToFind], @"LinesLeftToFindValue",

 						   nil];

 			[parser setContextInfo:(void *)contextInfo];

 		}

 		//Open up the file we need to read from, and seek to the end (this is a *backwards* parser, after all :)

 		NSFileHandle *file = [NSFileHandle fileHandleForReadingAtPath:xmlFilePath];

 		[file seekToEndOfFile];

 		//Set up some more doohickeys and then start the parse loop

 		NSInteger readSize = 4 * getpagesize(); //Read 4 pages at a time.

 		NSMutableData *chunk = [NSMutableData dataWithLength:readSize];

 		NSInteger fd = [file fileDescriptor];

 		char *buf = [chunk mutableBytes];

 		off_t offset = [file offsetInFile];

 		enum LMXParseResult result = LMXParsedIncomplete;

 		parsingAutoreleasePool = [[NSAutoreleasePool alloc] init];

 		do {

 			//Calculate the new offset

 			offset = (offset <= readSize) ? 0 : offset - readSize;

 			//Seek to it and read greedily until we hit readSize or run out of file.

 			NSInteger idx = 0;

 			for (ssize_t amountRead = 0; idx < readSize; idx += amountRead) { 

 				amountRead = pread(fd, buf + idx, readSize, offset + idx); 

 			   if (amountRead <= 0) break;

 			}

 			offset -= idx;

 			//Parse

 			result = [parser parseChunk:chunk];

 		//Continue to parse as long as we need more elements, we have data to read, and LMX doesn't think we're done.

 		} while ([foundMessages count] < linesLeftToFind && offset > 0 && result != LMXParsedCompletely);

 		//Pop our autorelease pool.

 		[parsingAutoreleasePool release]; parsingAutoreleasePool = nil;

 		//Be a good citizen and close the file

 		[file closeFile];

 		//Add our locals to the outer array; we're probably looping again.

 		[outerFoundContentContexts replaceObjectsInRange:NSMakeRange(0, 0) withObjectsFromArray:foundMessages];

 		linesLeftToFind -= [outerFoundContentContexts count];

 	}

 	if (linesLeftToFind > 0) {

 		AILogWithSignature(@"Unable to find %d logs for %@", linesLeftToFind, chat);

 	}

 	return outerFoundContentContexts;

 }

 #pragma mark LMX delegate

 - (void)parser:(LMXParser *)parser elementEnded:(NSString *)elementName

 {

 	if ([elementName isEqualToString:@"message"]) {

 		[elementStack insertObject:[AIXMLElement elementWithName:elementName] atIndex:0U];

 	}

 	else if ([elementStack count]) {

 		AIXMLElement *element = [AIXMLElement elementWithName:elementName];

 		[(AIXMLElement *)[elementStack objectAtIndex:0U] insertObject:element atIndex:0U];

 		[elementStack insertObject:element atIndex:0U];

 	}

 }

 - (void)parser:(LMXParser *)parser foundCharacters:(NSString *)string

 {

 	if ([elementStack count])

 		[(AIXMLElement *)[elementStack objectAtIndex:0U] insertObject:string atIndex:0U];

 }

 - (void)parser:(LMXParser *)parser elementStarted:(NSString *)elementName attributes:(NSDictionary *)attributes

 {

 	if ([elementStack count]) {

 		AIXMLElement *element = [elementStack objectAtIndex:0U];

 		if (attributes) {

 			[element setAttributeNames:[attributes allKeys] values:[attributes allValues]];

 		}

 		NSMutableDictionary *contextInfo = [parser contextInfo];

 		if ([elementName isEqualToString:@"message"]) {

 			//A message element has started!

 			//This means that we have all of this message now, and therefore can create a single content object from the AIXMLElement tree and then throw away that tree.

 			//This saves memory when a message element contains many elements (since each one is represented by an AIXMLElement sub-tree in the AIXMLElement tree, as opposed to a simple NSAttributeRun in the NSAttributedString of the content object).

 			NSString     *serviceName = [contextInfo objectForKey:@"Service name"];

 			AIListObject *account     = [contextInfo objectForKey:@"Account"];

 			NSString     *accountID   = [contextInfo objectForKey:@"Account ID"];

 			AIChat       *chat        = [contextInfo objectForKey:@"Chat"];

 			//Set up some doohickers.

 			NSDictionary	*attributes = [element attributes];

 			NSString		*timeString = [attributes objectForKey:@"time"];

 			//Create the context object

 			if (timeString) {

 				NSCalendarDate *time = [NSCalendarDate calendarDateWithString:timeString];

 				NSString		*autoreplyAttribute = [attributes objectForKey:@"auto"];

 				NSString		*sender = [NSString stringWithFormat:@"%@.%@", serviceName, [attributes objectForKey:@"sender"]];

 				BOOL			sentByMe = ([sender isEqualToString:accountID]);

 				/*don't fade the messages if they're within the last 5 minutes

 				 *since that will be resuming a conversation, not starting a new one.

 				 *Why the class trickery? Less code duplication, clearer what is actually different between the two cases.

 				 */

 				Class messageClass = (-[time timeIntervalSinceNow] > 300.0) ? [AIContentContext class] : [AIContentMessage class];

 				AIListContact *listContact = nil;

 				if (chat.isGroupChat) {

 					listContact = [chat.account contactWithUID:[attributes objectForKey:@"sender"]];

 				} else {

 					listContact = chat.listObject;

 				}

 				AIContentMessage *message = [messageClass messageInChat:chat 

 															 withSource:(sentByMe ? account : listContact)

 															destination:(sentByMe ? (chat.isGroupChat ? nil : chat.listObject) : account)

 																   date:time

 																message:[[contextInfo objectForKey:@"AIHTMLDecoder"] decodeHTML:[element contentsAsXMLString]]

 															  autoreply:(autoreplyAttribute && [autoreplyAttribute caseInsensitiveCompare:@"true"] == NSOrderedSame)];

 				//Don't log this object

 				[message setPostProcessContent:NO];

 				[message setTrackContent:NO];

 				//Add it to the array (in front, since we're working backwards, and we want the array in forward order)

 				[foundMessages insertObject:message atIndex:0];

 			} else {

 				NSLog(@"Null message context display time for %@",element);

 			}

 		}

 		NSInteger	 *linesLeftToFind = [[contextInfo objectForKey:@"LinesLeftToFindValue"] pointerValue];

 		[elementStack removeObjectAtIndex:0U];

 		if ([foundMessages count] == *linesLeftToFind) {

 			if ([elementStack count]) [elementStack removeAllObjects];

 			[parser abortParsing];

 		}

 	}

 }

 @end