/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef _ENTRY_FILTER_H
#define _ENTRY_FILTER_H

#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#include <new>

#if defined(__BEOS__) && !defined(__HAIKU__)
	// BeOS doesn't have <fnmatch.h>, but libroot.so features fnmatch() anyway
	extern "C" int fnmatch(const char *pattern, const char *string, int flags);
#else
#	include <fnmatch.h>
#endif

namespace BPrivate {


class BasicEntryFilter {
public:
	BasicEntryFilter()
		: fPattern(NULL),
		  fIsFileName(false)
	{
	}

	~BasicEntryFilter()
	{
		free(fPattern);
	}

	bool SetTo(const char* pattern, bool isFileName)
	{
		free(fPattern);

		fPattern = strdup(pattern);
		if (fPattern == NULL)
			return false;

		fIsFileName = isFileName;

		return true;
	}

	bool Filter(const char* path, const char* name) const
	{
		if (fPattern != NULL) {
			if (fnmatch(fPattern, (fIsFileName ? name : path), 0) == 0)
				return true;
		}

		return false;
	}

	void SetNextFilter(BasicEntryFilter* next)
	{
		fNextFilter = next;
	}

	BasicEntryFilter* NextFilter() const
	{
		 return fNextFilter;
	}

private:
	char*				fPattern;
	bool				fIsFileName;
	BasicEntryFilter*	fNextFilter;
};


class EntryFilter {
public:
	EntryFilter()
		: fIncludeFilters(NULL),
		  fExcludeFilters(NULL)
	{
	}

	~EntryFilter()
	{
		while (BasicEntryFilter* filter = fIncludeFilters) {
			fIncludeFilters = filter->NextFilter();
			delete filter;
		}

		while (BasicEntryFilter* filter = fExcludeFilters) {
			fExcludeFilters = filter->NextFilter();
			delete filter;
		}
	}

	void AddIncludeFilter(BasicEntryFilter* filter)
	{
		_AddFilter(fIncludeFilters, filter);
	}

	bool AddIncludeFilter(const char* pattern, bool isFilePattern)
	{
		return _AddFilter(fIncludeFilters, pattern, isFilePattern);
	}

	void AddExcludeFilter(BasicEntryFilter* filter)
	{
		_AddFilter(fExcludeFilters, filter);
	}

	bool AddExcludeFilter(const char* pattern, bool isFilePattern)
	{
		return _AddFilter(fExcludeFilters, pattern, isFilePattern);
	}

	bool Filter(const char* path) const
	{
		if (fExcludeFilters == NULL && fIncludeFilters)
			return true;

		// get leaf name
		const char* name = strrchr(path, '/');
		name = (name != NULL ? name + 1 : path);

		// exclude filters
		if (_Filter(fExcludeFilters, path, name))
			return false;

		// include filters -- if none are given, everything matches
		return fIncludeFilters == NULL || _Filter(fIncludeFilters, path, name);
	}

private:
	static void _AddFilter(BasicEntryFilter*& filterList,
		BasicEntryFilter* filter)
	{
		filter->SetNextFilter(filterList);
		filterList = filter;
	}

	static bool _AddFilter(BasicEntryFilter*& filterList, const char* pattern,
		bool isFilePattern)
	{
		BasicEntryFilter* filter = new(std::nothrow) BasicEntryFilter;
		if (filter == NULL)
			return false;

		if (!filter->SetTo(pattern, isFilePattern)) {
			delete filter;
			return false;
		}

		_AddFilter(filterList, filter);

		return true;
	}

	static bool _Filter(const BasicEntryFilter* const& filterList,
		const char* path, const char* name)
	{
		const BasicEntryFilter* filter = filterList;
		while (filter) {
			if (filter->Filter(path, name))
				return true;
			filter = filter->NextFilter();
		}

		return false;
	}

private:
	BasicEntryFilter*	fIncludeFilters;
	BasicEntryFilter*	fExcludeFilters;
};

}	// namespace BPrivate


#endif	// _ENTRY_FILTER_H