#ifndef INCLUDED_L3_FILES_H
#define INCLUDED_L3_FILES_H

// *Filenames Wildcarding* Copyright (C) Krzysztof Bosak 1999-04-14
// All rights reserved.
// kbosak@box43.pl
// http://www.kbosak.prv.pl

#include <string.h>
#include <stdlib.h>
#include "l3_array.h"
#include "l3_stack.h"
#include "l3_str.h"
class InvalidPathEx {}; // Path is meanigless or too long (system limitation) after expanding to full path.

#ifdef _MSC_VER // Visual C++ ////////////////////////////////////////////////////////////////

#include <io.h>

class SmartFindNext
{
	intptr_t _handle;
public:
	inline SmartFindNext(char * const path, _finddata_t * const finddata)
	{
		assert(path!=NULL);
		assert(finddata!=NULL);
		_handle=_findfirst(path, finddata);
	}
	inline bool FindNext(_finddata_t * const finddata) const
	{
		return _findnext(_handle, finddata)==0;
	}
	inline ~SmartFindNext()
	{
		_findclose(_handle);
	}
	inline bool IsGoodHandle() const
	{
		return _handle!=-1L;
	}
};

class DirectoryScanner
{
	TextString _path;
	basearray_s<char> _buffer_full_path;
	TextString _full_path;
	growing_arraystack<_finddata_t> _find_data;
public:
	explicit DirectoryScanner(const TextString& path)
		: _path(path),
		_buffer_full_path(_MAX_PATH)
	{
		assert(_buffer_full_path.size()==_MAX_PATH);
		_path=path;
		//cout<<"Path="<<_path.c_str()<<endl;//
		void *fullpath_ptr=_fullpath(&_buffer_full_path[0], _path.c_str(), _MAX_PATH);
		if(fullpath_ptr==NULL || fullpath_ptr!=&_buffer_full_path[0])
		{
			_full_path=_path;
			throw InvalidPathEx();
		}
		_full_path=&_buffer_full_path[0];
		//cout<<"fullpath="<<_full_path.c_str()<<endl;//
		_finddata_t finddata;
 		SmartFindNext sfind(&_full_path[0], &finddata);
		if(sfind.IsGoodHandle()==false)
		{
			return;
		}
		else
		{
			_find_data.push(finddata);
			while(sfind.FindNext(&finddata)==true)
			{
				_find_data.push(finddata);
			}
		}
	}
	growing_arraystack<_finddata_t>& FindData()
	{
		return _find_data;
	}
	const growing_arraystack<_finddata_t>& FindData() const
	{
		return _find_data;
	}
	const TextString& Path() const
	{
		return _path;
	}
	const TextString& FullPath() const
	{
		return _full_path;
	}
};

class FilenamesExtractor
{
	TextString _path;
	basearray_s<char> _split_path;
	basearray_s<char> _split_drive;
	basearray_s<char> _split_dir;
	basearray_s<char> _split_fname;
	basearray_s<char> _split_ext;
	growing_arraystack<TextString> _find_names;
public:
	inline FilenamesExtractor(TextString path, bool do_recursion, bool dirs_only)
		: _path(path),
		_split_path(_MAX_PATH),
		_split_drive(_MAX_DRIVE),
		_split_dir(_MAX_DIR),
		_split_fname(_MAX_FNAME),
		_split_ext(_MAX_EXT)
	{
		int last_path_index=path.length()-1;
		bool fast_flag=false;
		if(path[last_path_index]==':')// changing 'drive:' to 'drive\'
		{
			path+="\\";
			fast_flag=true;
		}
		last_path_index=path.length()-1;
		if(path[last_path_index]=='\\' || path[last_path_index]=='/')// changing 'dir\' and 'dir/' to 'dir\*'
		{
			path+="*";
			fast_flag=true;
		}
		if(fast_flag==false)
		{
			last_path_index=path.length()-1;
			if(path[last_path_index]=='*')
			{
				if(last_path_index>=2 && path[last_path_index-1]=='.' && path[last_path_index-2]=='*')
				{
					fast_flag=true;
				}
				else if(last_path_index>=1 && path[last_path_index-1]!='.')
				{
					fast_flag=true;
				}
			}
		}
		if(do_recursion==true && dirs_only==false)
		{// directory\*.txt in case of recursion should mean *.* for dirs and *.txt for files
			_splitpath(path.c_str(),
				&_split_drive[0], &_split_dir[0], &_split_fname[0], &_split_ext[0]);
			//if(strcmp(&_split_fname[0], "*")==0 && strcmp(&_split_ext[0], ".*")==0)
			if(fast_flag==true)
			{
				//cout<<"FASTER...\n";
				//assert(0);
				_do_recursion(path, true, false);
			}
			else
			{
				const TextString const1=&_split_fname[0];
				const TextString const2=&_split_ext[0];
				_makepath(&_split_path[0],
					&_split_drive[0], &_split_dir[0], "*", NULL);
				path=&_split_path[0];
				//cout<<"NotFinished="<<path.c_str()<<endl;
				FilenamesExtractor fe(path, do_recursion, true);
				growing_arraystack<TextString>& finddata_stack=fe.FileNames();
				while(!finddata_stack.empty())
				{
					TextString subdirpath=finddata_stack.top();
					finddata_stack.pop();
					subdirpath+="\\";
					subdirpath+=const1;
					subdirpath+=const2;
					//cout<<subdirpath.pop().c_str()<<endl;
					_do_recursion(subdirpath, true, false);
				}
			}
		}
		else
		{
			_do_recursion(path, do_recursion, dirs_only);
		}
	}
	inline const TextString& Path() const
	{
		return _path;
	}
	inline growing_arraystack<TextString>& FileNames()
	{
		return _find_names;
	}
	inline const growing_arraystack<TextString>& FileNames() const
	{
		return _find_names;
	}
private:
	inline void _do_recursion(const TextString& path, bool do_recursion, bool dirs_only)
	{
		DirectoryScanner ds(path);
		growing_arraystack<_finddata_t> &gs=ds.FindData();
		while(!gs.empty())
		{
			const _finddata_t finddata=gs.top();
			gs.pop();
			if(strcmp(finddata.name, ".")!=0 && strcmp(finddata.name, "..")!=0)
			{
				if(dirs_only==false)
				{
					if(finddata.attrib!=_A_SUBDIR)
					{
						//_find_names.push(finddata.name);// push filename only
						_splitpath(path.c_str(),
							&_split_drive[0], &_split_dir[0], &_split_fname[0], &_split_ext[0]);
						_makepath(&_split_path[0],
							&_split_drive[0], &_split_dir[0], finddata.name, NULL);
						_find_names.push(&_split_path[0]);// push full path
					}
				}
				else
				{
					if(finddata.attrib==_A_SUBDIR)
					{
						_splitpath(path.c_str(),
							&_split_drive[0], &_split_dir[0], &_split_fname[0], &_split_ext[0]);
						_makepath(&_split_path[0],
							&_split_drive[0], &_split_dir[0], finddata.name, NULL);
						_find_names.push(&_split_path[0]);// push full path of directory
					}
				}
				if(do_recursion==true)
				{
					//cout<<finddata.name<<"<--\n";
					_splitpath(path.c_str(),
						&_split_drive[0], &_split_dir[0], &_split_fname[0], &_split_ext[0]);
					TextString text_split_dir=&_split_dir[0];
					text_split_dir+=finddata.name;
					text_split_dir+="\\";
					_makepath(&_split_path[0],
						&_split_drive[0], text_split_dir.c_str(), &_split_fname[0], &_split_ext[0]);
					//cout<<&_split_path[0]<<"<==\n";
					_do_recursion(&_split_path[0], do_recursion, dirs_only);
				}
			}
		}
	}
};

#else // _MSC_VER ////////////////////////////////////////////////////////////////

class FilenamesExtractor
{
private:
	TextString _single_filename;
	growing_arraystack<TextString> _find_names;

public:
	inline FilenamesExtractor(const TextString& path, bool, bool)
		: _single_filename(path)
	{
		_find_names.push(_single_filename);
	}
	inline const TextString& Path() const
	{
		return _single_filename;
	}
	inline growing_arraystack<TextString>& FileNames()
	{
		return _find_names;
	}
	inline const growing_arraystack<TextString>& FileNames() const
	{
		return _find_names;
	}
};

#endif // MSC_VER //////////////////////////////////////////////////////////////

/*
int main(int argc, char *argv[])
{
	try
	{
		if(argc!=2)
		{
			cerr<<"Bad number of command line arguments.\n";
			exit(1);
		}
		cout<<"argc: "<<argc<<endl;
		int i;
		for(i=0; i<argc; i++)
		{
			cout<<"argv["<<i<<"]: "<<argv[i]<<endl;
		}
		cout<<endl;
		try
		{
			FilenamesExtractor ds(argv[1], true, false);
			growing_arraystack<TextString>& finddata_stack=ds.FileNames();
			while(!finddata_stack.empty())
			{
				cout<<finddata_stack.pop().c_str()<<endl;
			}
		}
		catch(const InvalidPathEx&)
		{
			cerr<<"Invalid path.\n";
		}
	}
	catch(const OutOfMemoryEx &ex)
	{
		cerr<<ex;
	}
	catch(const ArrayEx &ex)
	{
		cerr<<ex;
	}
	catch(...)
	{
		cerr<<"Fatal exception occured. This should had never happened...\n";
	}
	return 0;
}
*/

#endif // INCLUDED_L3_FILES_H