/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation. All
 * Rights Reserved.
 *
 * Contributor(s): 
 */
/* msgundmg.cpp --- Undo Manager implementation
 */

#include "msg.h"
#include "msgundmg.h"
#include "maildb.h"
#include "msgdbvw.h"
#include "msgpane.h"
#include "msgmpane.h"
#include "msgtpane.h"
#include "mailhdr.h"
#include "msgfinfo.h"

extern "C"
{
	extern int MK_OUT_OF_MEMORY;
}

///////////////////////////////////////////////////////////////////////////
// Implementation of UndoObject
///////////////////////////////////////////////////////////////////////////

UndoObject::UndoObject()
{
	m_owner = NULL;
	m_preExitFunc_hook = NULL;
	m_refCount = 1;
}

UndoObject::~UndoObject()
{
}

int
UndoObject::Release()
{
	--m_refCount;
	if (!m_refCount)
	{
		delete this;
		return 0;
	}
	return m_refCount;
}

UndoStatus
UndoObject::DoUndo()
{
	return UndoComplete;
}

UndoStatus
UndoObject::StopUndo( int /*status*/ )
{
	return UndoFailed;
}

// This is a default implementation. You should overwrite this
// method.
void
UndoObject::FinalizeUndo()
{
	// This is a default implementation. Client should
	// overwrite.
	XP_ASSERT(m_owner);

	AddRefCount();
	
	m_owner->AddUndoAction (this);

	// Inform UndoManager that we have done with
	// current undo object. 
	m_owner->DoUndoComplete(this);

}

void
UndoObject::UndoURLHook(URL_Struct *url)
{
	XP_ASSERT (url);
	if ( !url ) return;
	MSG_Pane *pane = url->msg_pane; 

	XP_ASSERT (pane);
	if (!pane) return;

	pane->GetUndoManager()->AddInProgress(this);

	if (url->pre_exit_fn)
		m_preExitFunc_hook = url->pre_exit_fn;
	
	url->pre_exit_fn = UndoObject::UndoURLPreExitFunc;
}

void
UndoObject::UndoURLPreExitFunc (URL_Struct *url,
								int status,
								MWContext *context)
{
	XP_ASSERT (url);
	if ( !url ) return;

	if (url->msg_pane)
	{
		UndoManager *undoManager = url->msg_pane->GetUndoManager();

		XP_ASSERT (undoManager);
		if (!undoManager) return;

		UndoObject *undoObject = undoManager->RemoveInProgress();

		XP_ASSERT (undoObject);
		if (!undoObject) return;

		if (undoObject->m_preExitFunc_hook)
			undoObject->m_preExitFunc_hook (url, status, context);

		if (status < 0)
		{
			undoObject->StopUndo (status);
			undoManager->Reset();
			return;
		}

		UndoStatus undoStatus;

		undoStatus = undoObject->UndoPreExit();

		if (undoStatus == UndoComplete)
			undoObject->FinalizeUndo();
		else
		{
			undoObject->StopUndo (status);
			undoManager->Reset();
		}
	}
}

/////////////////////////////////////////////////////////////////////
// Implementation of UndoMarker
/////////////////////////////////////////////////////////////////////
void
UndoMarker::FinalizeUndo()
{
	XP_ASSERT (IsMarker());

	if (IsStart())
		m_owner->StartBatch();
	else
		m_owner->EndBatch();

	m_owner->DoUndoComplete(this);
}


/////////////////////////////////////////////////////////////////
// Implementation of UndoManager
/////////////////////////////////////////////////////////////////

UndoManager::UndoManager (MSG_Pane *pane, int maxActions)
{
	m_maxUndoActions = maxActions;
	m_depth = 0;
	m_state = UndoIdle;
	m_count = 0;
	m_status = UndoComplete;
	m_pane = pane;
	m_refCount = 1;
}

UndoManager::~UndoManager ()
{
	FlushActions();
}

int
UndoManager::Init()
{
	return 0;
}

int
UndoManager::Release()
{
	--m_refCount;
	if (!m_refCount)
	{
		delete this;
		return 0;
	}
	return m_refCount;
}


int
UndoManager::StartBatch()
{
	int status = 0;
	UndoMarker *marker = new UndoMarker (FALSE);

	if ( !marker ) return MK_OUT_OF_MEMORY;

	++m_depth;

	if (m_state == UndoIdle || m_state == UndoRedoing)
		AddAtomicUndo(marker);
	else
		AddAtomicRedo(marker);

	return status;
}

int
UndoManager::EndBatch()
{
	int status = 0;
	UndoMarker *marker = new UndoMarker (TRUE);

	if (!marker) 
	{
		Reset();
		return MK_OUT_OF_MEMORY;
	}

	--m_depth;

	if (m_state == UndoIdle || m_state == UndoRedoing)
		AddAtomicUndo(marker);
	else
		AddAtomicRedo(marker);

	if (m_state == UndoIdle)
		FinalizeAtomicActions();

	return status;
}

int
UndoManager::AbortBatch()
{
	XP_ASSERT (m_state == UndoIdle);

	int size;
	int status = 0;

	// **** There definitely much more we can do. For now
	// let's just free some memory resource. Revisit later!!!!!!
    while (1)
	{
		size = m_atomicUndoList.GetSize();
		if (size == 0)
			break;
		((UndoObject *) m_atomicUndoList.GetAt(--size))->Release();
		m_atomicUndoList.RemoveAt(size);
	}
	return status;
}

int
UndoManager::AddUndoAction( UndoObject *undoObject )
{
	int status = 0;

	XP_ASSERT (undoObject);
	if (!undoObject) return -1;

	undoObject->SetOwner(this);

	if (m_state == UndoIdle || m_state == UndoRedoing)
	{
		if (m_depth) 
		{
			AddAtomicUndo(undoObject);
		}
		else
		{
			if (m_undoList.GetSize() >= m_maxUndoActions)
				FlushAtomic (&m_undoList);
			m_undoList.Add(undoObject);
		}
	}
	else
	{
		if (m_depth)
		{
			AddAtomicRedo (undoObject);
		}
		else
		{
			if (m_redoList.GetSize() >= m_maxUndoActions)
				FlushAtomic (&m_redoList);
			m_redoList.Add(undoObject);
		}
	}
	return status;
}

XP_Bool
UndoManager::CanUndo()
{
	return (m_undoList.GetSize() > 0);
}

XP_Bool
UndoManager::CanRedo()
{
	return (m_redoList.GetSize() > 0);
}

UndoStatus
UndoManager::Undo()
{
	UndoStatus status = UndoError;
	if (CanUndo())
	{
		m_status = UndoComplete;
		m_state = UndoUndoing;
		status = FireAtomic( &m_undoList );
	}
	if (status != UndoInProgress)
		m_state = UndoIdle;
	return status;
}

UndoStatus
UndoManager::Redo()
{
	UndoStatus status = UndoError;
	if (CanRedo())
	{
		m_status = UndoComplete;
		m_state = UndoRedoing;
		status = FireAtomic( &m_redoList );
	}
	if (status != UndoInProgress)
		m_state = UndoIdle;
	return status;
}

void
UndoManager::FlushActions()
{
	int size = 0;
	while (1)
	{
		size = m_undoList.GetSize();
		if (size == 0)
			break;
		((UndoObject*)m_undoList.GetAt(--size))->Release();
		m_undoList.RemoveAt(size);
	}
	while (1)
	{
		size = m_redoList.GetSize();
		if (size == 0)
			break;
		((UndoObject*)m_redoList.GetAt(--size))->Release();
		m_redoList.RemoveAt(size);
	}

	m_inProgressList.RemoveAll();
	m_atomicUndoList.RemoveAll();
	m_atomicRedoList.RemoveAll();

	m_depth = 0;
	m_count = 0;
	m_state = UndoIdle;
	m_status = UndoComplete;
}

void
UndoManager::RemoveActions(MSG_FolderInfo *folder)
{
	if (!folder) return;

	int size;
	
	size = m_undoList.GetSize();
	while (size)
	{
		if (((UndoObject*)m_undoList.GetAt(--size))->HasFolder(folder))
			m_undoList.RemoveAt(size);
	}

	size = m_redoList.GetSize();
	while(size)
	{
		if (((UndoObject*)m_undoList.GetAt(--size))->HasFolder(folder))
			m_redoList.RemoveAt(size);
	}
}

void
UndoManager::Reset()
{
	int size = 0;

	if (m_state == UndoUndoing)
	{
		while (1)
		{
			size = m_atomicRedoList.GetSize();
			if (size == 0)
				break;
			((UndoObject*)m_atomicRedoList.GetAt(--size))->Release();
			m_atomicRedoList.RemoveAt(size);
		}
	}
	else if (m_state == UndoRedoing)
	{
		while (1)
		{
			size = m_atomicUndoList.GetSize();
			if (size == 0)
				break;
			((UndoObject*)m_atomicUndoList.GetAt(--size))->Release();
			m_atomicUndoList.RemoveAt(size);
		}
	}
	m_state = UndoIdle;
	m_depth = 0;
	m_count = 0;
	m_status = UndoComplete;
}

int
UndoManager::AddInProgress (UndoObject *undoObject)
{
	XP_ASSERT (undoObject);
	if (!undoObject) return -1;

	m_inProgressList.Add((void *)undoObject);
	return 0;
}

UndoObject*
UndoManager::GetInProgress()
{
	int size = m_inProgressList.GetSize();
	XP_ASSERT(size > 0);
	if (size <= 0) return NULL;

	UndoObject *undoObject = (UndoObject *) m_inProgressList.GetAt(size-1);
	return undoObject;
}

UndoObject*
UndoManager::RemoveInProgress()
{
	UndoObject *undoObject = GetInProgress();
	m_inProgressList.RemoveAt(m_inProgressList.GetSize()-1);

	return (undoObject);
}

void
UndoManager::FlushAtomic (XPPtrArray *list)
{
	int size = list->GetSize();
	int count = 0;

	--size; // real index;

	UndoObject *undoObject = (UndoObject*) list->GetAt(size);
	XP_ASSERT (undoObject);

	if (!undoObject) return;

	if (m_depth)
	{
		// we are flush while we are adding a batch operation
		int depth = m_depth;
		while (depth && size >= 0)
		{
			if (undoObject->IsMarker() && undoObject->IsEnd())
				depth--;
			undoObject = (UndoObject*) list->GetAt(--size);
		}
	}

	if (undoObject->IsMarker())
	{
		int depth = 0;

		XP_ASSERT(undoObject->IsStart());
		while (undoObject && size >= 0)
		{
			if (undoObject->IsStart())
				depth++;
			else if (undoObject->IsEnd())
				depth--;
			undoObject->Release();
			++count;
			list->RemoveAt(size--);
			if (!depth) return;
			undoObject = (UndoObject*) list->GetAt(size);
		}
	}
	else
	{
		++count;
		undoObject->Release();
		list->RemoveAt(size);
	}
}


// This is an extremely overloaded routine. I am not sure what else
// I can do. Sigh.....
UndoStatus
UndoManager::FireAtomic (XPPtrArray *list)
{
	if (m_status!= UndoComplete) return m_status;

	int size = list->GetSize();

	if (!size) return UndoComplete;

	UndoObject *undoObject;

	if (!m_depth)
		m_count = 0;

	undoObject = (UndoObject*) list->GetAt(size-m_count-1);

	XP_ASSERT(undoObject);
	if (!undoObject) return UndoError;

	if (undoObject->IsMarker() || m_depth)
	{
		while (undoObject)
		{
			m_status = undoObject->DoUndo();
			if (m_status == UndoInProgress)
			{
				return m_status;
			}
			else if (m_status == UndoComplete)
			{
				// What happen if something went wrong in the middle of an
				// atomic operation
				undoObject->FinalizeUndo();
			}
			else
			{
				// Don't know what to do yet
				XP_ASSERT(0);
			}
			if (!m_depth) 
			{
				// We are done with this batch. Reset undo state
				// to undo idle.
				m_state = UndoIdle;
				return m_status;
			}
			else if (m_status != UndoComplete)
			{
				return m_status;
			}
			undoObject = (UndoObject*)list->GetAt(size-m_count-1);
		}
	}
	else
	{
		m_status = undoObject->DoUndo();
		if ( m_status == UndoComplete )
		{
			undoObject->FinalizeUndo();
			// FinalizeUndo() calls DoUndoComplete() if this is a single
			// atomic undo operation m_state is reset to UndoIdle in
			// DoUndoComplete().
			return UndoComplete;
		}
		else if (m_status == UndoInProgress)
		{
			return UndoInProgress;
		}
		else
		{
			// don't know what to do yet
			return m_status;
		}
	}
	return m_status;
}

void
UndoManager::DoUndoComplete(UndoObject* undoObject)
{
	m_status = UndoComplete;

	++m_count;
	if (m_depth) {
		if (m_state == UndoUndoing)
			FireAtomic(&m_undoList);
		else if (m_state == UndoRedoing)
			FireAtomic(&m_redoList);
		else
			XP_ASSERT(0);
		// **** Post Error message if error occured
	}
	else
	{
		if (undoObject->IsMarker() &&
			undoObject->IsEnd())
		{
			FinalizeAtomicActions();
		}
		else
		{
			if (m_state == UndoUndoing)
				m_undoList.Remove((void *) undoObject);
			else if (m_state == UndoRedoing)
				m_redoList.Remove((void *) undoObject);
			undoObject->Release();
		}
		m_state = UndoIdle;
	}
}


void
UndoManager::AddAtomicUndo(UndoObject *undoObject)
{
	m_atomicUndoList.Add(undoObject);
}

void
UndoManager::AddAtomicRedo(UndoObject *undoObject)
{
	m_atomicRedoList.Add(undoObject);
}

void
UndoManager::FinalizeAtomicActions()
{
	XPPtrArray *list = (m_state == UndoUndoing ?
		&m_atomicRedoList :
		&m_atomicUndoList );

	if (!m_depth)
	{
		UndoObject *undoObject;
		int size = list->GetSize();
		int count = m_count;

		for (int i=0; i<size; i++)
		{
			undoObject = (UndoObject*) list->GetAt(i);
			AddUndoAction(undoObject);
		}
		list->RemoveAll();

		if (m_state == UndoIdle)
			return;

		list = (m_state == UndoUndoing ?
			&m_undoList : &m_redoList );

		while (count)
		{
			undoObject = (UndoObject *) list->GetAt(list->GetSize()-1);
			undoObject->Release();
			list->RemoveAt(list->GetSize()-1);
			count--;
		}
	}
	
}

int 
UndoManager::AddMsgKey(MessageKey key)
{
	int status = 0;

	m_msgKeyArray.Add(key);
	return status;
}

MessageKey
UndoManager::GetAndRemoveMsgKey()
{
	if (!m_msgKeyArray.GetSize())
		return MSG_MESSAGEKEYNONE;

	MessageKey key = m_msgKeyArray.GetAt(0);
	m_msgKeyArray.RemoveAt(0);

	return key;
}


void UndoManager::SetUndoMsgFolder( MSG_FolderInfo *folder )
{
	m_undoMsgFolder = folder;
}

MSG_FolderInfo * UndoManager::GetUndoMsgFolder()
{
	return m_undoMsgFolder;
}

//////////////////////////////////////////////////////////////////////////
// BacktrackManager
//////////////////////////////////////////////////////////////////////////

BacktrackManager::BacktrackManager(MSG_Pane *pane)
{
	m_pane = pane;
	m_cursor = -1;
	m_state = MSG_BacktrackIdle;
	m_curKey = MSG_MESSAGEKEYNONE;
	m_curFolder = NULL;
}

BacktrackManager::~BacktrackManager()
{
	Reset();
}

int
BacktrackManager::AddEntry(MSG_FolderInfo *folder, MessageKey key)
{
	int status = 0;
	BacktrackEntry *entry = NULL;

	if (m_state != MSG_BacktrackIdle)
	{
		return status;
	}

	if (m_cursor >= 0)
	{		
		entry = (BacktrackEntry *) m_backtrackArray.GetAt(m_cursor);
		if (entry->folder == folder && entry->key == key)
			goto done;
	}
	if (m_cursor-1 >= 0)
	{
		entry = (BacktrackEntry *) m_backtrackArray.GetAt(m_cursor-1);
		if (entry->folder == folder && entry->key == key)
			goto done;
	}
	if ((m_cursor+1) < m_backtrackArray.GetSize())
	{
		entry = (BacktrackEntry *) m_backtrackArray.GetAt(m_cursor+1);
		if (entry->folder == folder && entry->key == key)
			goto done;
	}

	entry = new BacktrackEntry;
	if (entry)
	{
		m_cursor++;
		entry->folder = folder;
		entry->key = key;
		m_backtrackArray.InsertAt(m_cursor, (void*)entry, 1);
		goto done;
	}
	else
		return MK_OUT_OF_MEMORY;
done:
	if (entry)
		SetCurMessageKey (entry->folder, entry->key);
	return status;
}

XP_Bool
BacktrackManager::CanGoBack()
{
	if (m_cursor <=0) return FALSE;
	BacktrackEntry *entry = NULL;

	for (int i=m_cursor-1; i >= 0; i--)
	{
		entry = (BacktrackEntry *) m_backtrackArray.GetAt(i);
		XP_ASSERT (entry->key != MSG_MESSAGEKEYNONE);
		if (entry->key != MSG_MESSAGEKEYNONE) 
			return TRUE;
	}
	return FALSE;
}

XP_Bool
BacktrackManager::CanGoForward()
{
	int size = m_backtrackArray.GetSize();
	BacktrackEntry *entry = NULL;

	if (m_cursor >= size-1)
		return FALSE;
	
	for (int i=m_cursor+1; i < size; i++)
	{
		entry = (BacktrackEntry*) m_backtrackArray.GetAt(i);
		XP_ASSERT (entry->key != MSG_MESSAGEKEYNONE);
		if (entry->key != MSG_MESSAGEKEYNONE)
			return TRUE;
	}
	return FALSE;
}

MessageKey
BacktrackManager::GoBack(MSG_FolderInfo **pFolderInfo)
{
	XP_ASSERT (m_cursor > 0);
	int i;
	DBMessageHdr *msgHdr = NULL;
	BacktrackEntry *entry = NULL;
	MailDB *mailDb;

	m_state = MSG_BacktrackBackward;

	for (i=m_cursor-1; i >= 0; i--)
	{
		entry = (BacktrackEntry*) m_backtrackArray.GetAt(i);
		if (entry->folder != m_curFolder)
		{
			// *** if the folder is a newsgroup folder we done.
			if (entry->folder->IsNews()) break;

			// if this is a mail folder does this message get deleted?
			MsgERR err = eUNKNOWN;
			mailDb= NULL;
			err = MailDB::Open(entry->folder->GetMailFolderInfo()->GetPathname(), 
							   FALSE, &mailDb);
			if (err == eSUCCESS)
			{
				msgHdr = mailDb->GetDBHdrForKey(entry->key);
				if (msgHdr)
				{
					mailDb->Close();
					break;
				}
			}
			if (mailDb) mailDb->Close();
		}
		else if (entry->key != m_curKey)
		{
			msgHdr = m_pane->GetMsgView()->GetDB()->GetDBHdrForKey(entry->key);
			if (msgHdr) break;
		}
	}

	delete msgHdr;

	if (entry)
	{
		if (pFolderInfo && m_curFolder != entry->folder)
			*pFolderInfo = entry->folder;
		m_cursor = i;
		SetCurMessageKey(entry->folder, entry->key);
		return entry->key;
	}
	return MSG_MESSAGEKEYNONE;
}


MessageKey
BacktrackManager::GoForward(MSG_FolderInfo **pFolderInfo)
{
	int size = m_backtrackArray.GetSize();

	XP_ASSERT (m_cursor < size -1);
	int i;
	DBMessageHdr *msgHdr = NULL;
	BacktrackEntry *entry = NULL;
	MailDB *mailDb;

	m_state = MSG_BacktrackForward;

	for (i=m_cursor+1; i < size; i++)
	{
		entry = (BacktrackEntry*) m_backtrackArray.GetAt(i);
		if (entry->folder != m_curFolder)
		{
			// *** if the folder is a newsgroup folder we done.
			if (entry->folder->IsNews()) break;

			// if this is a mail folder does this message get deleted?
			MsgERR err = eUNKNOWN;
			mailDb= NULL;
			err = MailDB::Open(entry->folder->GetMailFolderInfo()->GetPathname(), 
							   FALSE, &mailDb);
			if (err == eSUCCESS)
			{
				msgHdr = mailDb->GetDBHdrForKey(entry->key);
				if (msgHdr)
				{
					mailDb->Close();
					break;
				}
			}
			if (mailDb) mailDb->Close();
		}
		else if (entry->key != m_curKey)
		{
			msgHdr = m_pane->GetMsgView()->GetDB()->GetDBHdrForKey(entry->key);
			if (msgHdr) break;
		}
	}

	delete msgHdr;

	if (entry)
	{
		if (pFolderInfo && m_curFolder != entry->folder)
			*pFolderInfo = entry->folder;
		m_cursor = i;
		SetCurMessageKey(entry->folder, entry->key);
		return entry->key;
	}
	return MSG_MESSAGEKEYNONE;
}

void
BacktrackManager::Reset()
{
	BacktrackEntry *entry = NULL;
	int size = m_backtrackArray.GetSize();

	for (int i=0; i < size; i++)
	{
		entry = (BacktrackEntry *) m_backtrackArray.GetAt(0);
		m_backtrackArray.RemoveAt(0);
		delete entry;
	}

	m_cursor = -1;
	m_curKey = MSG_MESSAGEKEYNONE;
	m_curFolder = NULL;

}


void
BacktrackManager::SetCurMessageKey(MSG_FolderInfo *folder,
								   MessageKey key)
{
	m_curFolder = folder;
	m_curKey = key;
}

void
BacktrackManager::RemoveEntries(MSG_FolderInfo *folder)
{
	int size = m_backtrackArray.GetSize();
	BacktrackEntry *entry = NULL;

	if (!folder || size <= 0)
		return;

	while (size)
	{
		entry = (BacktrackEntry *) m_backtrackArray.GetAt(--size);
		if (entry->folder == folder)
		{
			m_backtrackArray.RemoveAt(size);
			delete entry;
			if (m_cursor == size)
			{
				m_cursor = -1;
				m_curKey = MSG_MESSAGEKEYNONE;
				m_curFolder = NULL;
			}
			else if (m_cursor > size)
			{
				m_cursor--;
			}
		}
	}
}