/* 

 * 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

		NSMutableArray *foundMessages = [NSMutableArray arrayWithCapacity:linesLeftToFind];

		NSMutableArray *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",

						   foundMessages, @"FoundMessages",

						   elementStack, @"ElementStack",

						   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];

		off_t offset = [file offsetInFile];

		enum LMXParseResult result = LMXParsedIncomplete;

		// These set of file's autorelease pool.

		NSAutoreleasePool *parsingAutoreleasePool = [[NSAutoreleasePool alloc] init];

		do {

			// The location we're going to read for *this* set of reads.

			off_t readOffset = offset - readSize;

			if (readOffset < 0) {

				// Decrease it by the amount we're over.

				readSize += readOffset;

				// Start from the beginning.

				readOffset = 0;

			}

			if (chunk.length != readSize) {

				// In case we short-read last time, or we're reading a smaller amount this time.

				[chunk setLength:readSize];				

			}

			char *buf = [chunk mutableBytes];

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

			NSInteger idx = 0;

			ssize_t amountRead = 0;

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

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

			   if (amountRead <= 0) break;

			}

			if (idx != readSize) {

				// If we short read, we don't want to read unknown buffer contents.

				[chunk setLength:idx];

			}

			// Adjust the real offset

			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);

		//Drain our autorelease pool.

		[parsingAutoreleasePool release];

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

{

	NSMutableDictionary *contextInfo = [parser contextInfo];

	NSMutableArray *elementStack = [contextInfo objectForKey:@"ElementStack"];

	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

{

	NSMutableDictionary *contextInfo = [parser contextInfo];

	NSMutableArray *elementStack = [contextInfo objectForKey:@"ElementStack"];

	if ([elementStack count])

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

}

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

{

	NSMutableDictionary *contextInfo = [parser contextInfo];

	NSMutableArray *elementStack = [contextInfo objectForKey:@"ElementStack"];

	if ([elementStack count]) {

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

		if (attributes) {

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

		}

		NSMutableArray	*foundMessages = [contextInfo objectForKey:@"FoundMessages"];

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

		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);

			}

		}

		[elementStack removeObjectAtIndex:0U];

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

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

			[parser abortParsing];

		}

	}

}

@end