/*
 * Copyright 2008-2009, Stephan Aßmus <superstippi@gmx.de>
 *  All rights reserved. Distributed under the terms of the MIT License.
 */
#ifndef COPY_ENGINE_H
#define COPY_ENGINE_H


#include <stdlib.h>

#include <Entry.h>
#include <File.h>
#include <Messenger.h>
#include <String.h>

#include "BlockingQueue.h"

class BFile;
class ProgressReporter;


class CopyEngine {
public:
			class EntryFilter;

public:
								CopyEngine(ProgressReporter* reporter,
									EntryFilter* entryFilter);
	virtual						~CopyEngine();

			void				ResetTargets(const char* source);
			status_t			CollectTargets(const char* source,
									sem_id cancelSemaphore = -1);

			status_t			Copy(const char* source,
									const char* destination,
									sem_id cancelSemaphore = -1,
									bool copyAttributes = true);

	static	status_t			RemoveFolder(BEntry& entry);

private:
			status_t			_CollectCopyInfo(const char* source,
									sem_id cancelSemaphore, off_t& bytesToCopy,
									uint64& itemsToCopy);
			status_t			_Copy(BEntry& source, BEntry& destination,
									sem_id cancelSemaphore,
									bool copyAttributes);
			status_t			_CopyData(const BEntry& entry,
									const BEntry& destination,
									sem_id cancelSemaphore = -1);

			const char*			_RelativeEntryPath(
									const char* absoluteSourcePath) const;

			void				_UpdateProgress();

	static	int32				_WriteThreadEntry(void* cookie);
			void				_WriteThread();

private:
			enum {
				BUFFER_COUNT	= 16,
				BUFFER_SIZE		= 1024 * 1024
			};
			struct Buffer {
				Buffer(BFile* file)
					:
					file(file),
					buffer(malloc(BUFFER_SIZE)),
					size(BUFFER_SIZE),
					validBytes(0),
					deleteFile(false)
				{
				}
				~Buffer()
				{
					if (deleteFile)
						delete file;
					free(buffer);
				}
				BFile*			file;
				void*			buffer;
				size_t			size;
				size_t			validBytes;
				bool			deleteFile;
			};

private:
	BlockingQueue<Buffer>		fBufferQueue;

			thread_id			fWriterThread;
	volatile bool				fQuitting;

			BString				fAbsoluteSourcePath;

			off_t				fBytesRead;
			off_t				fLastBytesRead;
			uint64				fItemsCopied;
			uint64				fLastItemsCopied;
			bigtime_t			fTimeRead;

			off_t				fBytesWritten;
			bigtime_t			fTimeWritten;

			const char*			fCurrentTargetFolder;
			const char*			fCurrentItem;

			ProgressReporter*	fProgressReporter;
			EntryFilter*		fEntryFilter;
};


class CopyEngine::EntryFilter {
public:
	virtual						~EntryFilter();

	virtual	bool				ShouldCopyEntry(const BEntry& entry,
									const char* path,
									const struct stat& statInfo) const = 0;
};


#endif // COPY_ENGINE_H