//---------------------------------------------------------------------------
//
//	SCSI Target Emulator RaSCSI Reloaded
//	for Raspberry Pi
//
//	Powered by XM6 TypeG Technology.
//	Copyright (C) 2016-2020 GIMONS
//	[ Host File System for the X68000 ]
//
//  Note: This functionality is specific to the X68000 operating system.
//        It is highly unlikely that this will work for other platforms.
//---------------------------------------------------------------------------

#pragma once

//---------------------------------------------------------------------------
//
//	Status code definitions
//
//---------------------------------------------------------------------------
#define FS_INVALIDFUNC		0xFFFFFFFF	///< Executed an invalid function
#define FS_FILENOTFND		0xFFFFFFFE	///< The selected file can not be found
#define FS_DIRNOTFND		0xFFFFFFFD	///< The selected directory can not be found
#define FS_OVEROPENED		0xFFFFFFFC	///< There are too many files open
#define FS_CANTACCESS		0xFFFFFFFB	///< Can not access the direcory or volume
#define FS_NOTOPENED		0xFFFFFFFA	///< The selected handle is not opened
#define FS_INVALIDMEM		0xFFFFFFF9	///< Memory management has been destroyed
#define FS_OUTOFMEM		0xFFFFFFF8	///< Insufficient memory for execution
#define FS_INVALIDPTR		0xFFFFFFF7	///< Selected an invalid memory management pointer
#define FS_INVALIDENV		0xFFFFFFF6	///< Selected an invalid environment
#define FS_ILLEGALFMT		0xFFFFFFF5	///< The exeucted file is in an invalid format
#define FS_ILLEGALMOD		0xFFFFFFF4	///< Invalid open access mode
#define FS_INVALIDPATH		0xFFFFFFF3	///< Mistake in selected file name
#define FS_INVALIDPRM		0xFFFFFFF2	///< Called with an invalid parameter
#define FS_INVALIDDRV		0xFFFFFFF1	///< Mistake in selected drive
#define FS_DELCURDIR		0xFFFFFFF0	///< Unable to delete the current directory
#define FS_NOTIOCTRL		0xFFFFFFEF	///< Unable to use IOCTRL with the device
#define FS_LASTFILE		0xFFFFFFEE	///< Can not find any more files
#define FS_CANTWRITE		0xFFFFFFED	///< Selected file can not be written
#define FS_DIRALREADY		0xFFFFFFEC	///< Selected directory is already registered
#define FS_CANTDELETE		0xFFFFFFEB	///< Can not delete because of a file
#define FS_CANTRENAME		0xFFFFFFEA	///< Can not rename because of a file
#define FS_DISKFULL		0xFFFFFFE9	///< Can not create a file because the disk is full
#define FS_DIRFULL		0xFFFFFFE8	///< Can not create a file because the directory is full
#define FS_CANTSEEK		0xFFFFFFE7	///< Can not seek in the selected location
#define FS_SUPERVISOR		0xFFFFFFE6	///< Selected supervisor in supervisor mode
#define FS_THREADNAME		0xFFFFFFE5	///< A thread with this name already exists
#define FS_BUFWRITE		0xFFFFFFE4	///< Writing to inter-process communication buffers is disallowed
#define FS_BACKGROUND		0xFFFFFFE3	///< Unable to start a background process
#define FS_OUTOFLOCK		0xFFFFFFE0	///< Insufficient lock space
#define FS_LOCKED		0xFFFFFFDF	///< Can not access because it is locked
#define FS_DRIVEOPENED		0xFFFFFFDE	///< Selected drive has an open handler
#define FS_LINKOVER		0xFFFFFFDD	///< The symbolic link is nested over 16 times
#define FS_FILEEXIST		0xFFFFFFB0	///< The file exists

#define FS_FATAL_MEDIAOFFLINE	0xFFFFFFA3	///< No media inserted
#define FS_FATAL_WRITEPROTECT	0xFFFFFFA2	///< Write protected
#define FS_FATAL_INVALIDCOMMAND	0xFFFFFFA1	///< Invalid command number
#define FS_FATAL_INVALIDUNIT	0xFFFFFFA0	///< Invalid unit number

#define HUMAN68K_PATH_MAX	96		///< Longest path allowed in Human68k

//===========================================================================
//
/// Human68k name space
//
//===========================================================================
namespace Human68k {
	/// File attribute bit
	enum attribute_t {
		AT_READONLY = 0x01,		///< Read only attribute
		AT_HIDDEN = 0x02,		///< Hidden attribute
		AT_SYSTEM = 0x04,		///< System attribute
		AT_VOLUME = 0x08,		///< Volume label attribute
		AT_DIRECTORY = 0x10,		///< Directory attribute
		AT_ARCHIVE = 0x20,		///< Archive attribute
		AT_ALL = 0xFF,			///< All attribute bits are 1
	};

	/// File open modes
	enum open_t {
		OP_READ = 0,			///< Read
		OP_WRITE = 1,			///< Write
		OP_FULL = 2,			///< Read/Write
		OP_MASK = 0x0F,			///< Decision mask
		OP_SHARE_NONE = 0x10,		///< Sharing forbidden
		OP_SHARE_READ = 0x20,		///< Read sharing
		OP_SHARE_WRITE = 0x30,		///< Write sharing
		OP_SHARE_FULL = 0x40,		///< Read/Write sharing
		OP_SHARE_MASK = 0x70,		///< Sharing decision mask
		OP_SPECIAL = 0x100,		///< Dictionary access
	};

	/// Seek types
	enum seek_t {
		SK_BEGIN = 0,			///< From the beginning of a file
		SK_CURRENT = 1,			///< From the current location
		SK_END = 2,			///< From the end of the file
	};

	/// Media byte
	enum media_t {
		MEDIA_2DD_10 = 0xE0,		///< 2DD/10 sector
		MEDIA_1D_9 = 0xE5,		///< 1D/9 sector
		MEDIA_2D_9 = 0xE6,		///< 2D/9 sector
		MEDIA_1D_8 = 0xE7,		///< 1D/8 sector
		MEDIA_2D_8 = 0xE8,		///< 2D/8 sector
		MEDIA_2HT = 0xEA,		///< 2HT
		MEDIA_2HS = 0xEB,		///< 2HS
		MEDIA_2HDE = 0xEC,		///< 2DDE
		MEDIA_1DD_9 = 0xEE,		///< 1DD/9 sector
		MEDIA_1DD_8 = 0xEF,		///< 1DD/8 sector
		MEDIA_MANUAL = 0xF1,		///< Remote drive (manual eject)
		MEDIA_REMOVABLE = 0xF2,		///< Remote drive (removable)
		MEDIA_REMOTE = 0xF3,		///< Remote drive
		MEDIA_DAT = 0xF4,		///< SCSI-DAT
		MEDIA_CDROM = 0xF5,		///< SCSI-CDROM
		MEDIA_MO = 0xF6,		///< SCSI-MO
		MEDIA_SCSI_HD = 0xF7,		///< SCSI-HD
		MEDIA_SASI_HD = 0xF8,		///< SASI-HD
		MEDIA_RAMDISK = 0xF9,		///< RAM disk
		MEDIA_2HQ = 0xFA,		///< 2HQ
		MEDIA_2DD_8 = 0xFB,		///< 2DD/8 sector
		MEDIA_2DD_9 = 0xFC,		///< 2DD/9 sector
		MEDIA_2HC = 0xFD,		///< 2HC
		MEDIA_2HD = 0xFE,		///< 2HD
	};

	struct namests_t {
		BYTE wildcard;			///< Wildcard character length
		BYTE drive;			///< Drive number
		BYTE path[65];			///< Path (subdirectory +/)
		BYTE name[8];			///< File name (PADDING 0x20)
		BYTE ext[3];			///< Extension (PADDING 0x20)
		BYTE add[10];			///< File name addition (PADDING 0x00)

		void GetCopyPath(BYTE* szPath) const;
		void GetCopyFilename(BYTE* szFilename) const;
	};

	struct files_t {
		BYTE fatr;			///< + 0 search attribute; read-only
		//		BYTE drive;	///< + 1 drive number; read-only
		DWORD sector;			///< + 2 directory sector; DOS _FILES first address substitute
		//		WORD cluster;	///< + 6 directory cluster; details unknown (unused)
		WORD offset;			///< + 8 directory entry; write-only
		//		BYTE name[8];	///< +10 working file name; write-only (unused)
		//		BYTE ext[3];	///< +18 working extension; write-only (unused)
		BYTE attr;			///< +21 file attribute; write-only
		WORD time;			///< +22 last change time of day; write-only
		WORD date;			///< +24 last change date; write-only
		DWORD size;			///< +26 file size; write-only
		BYTE full[23];			///< +30 full name; write-only
	};

	struct fcb_t {
		//		BYTE pad00[6];	///< + 0~+ 5	(unused)
		DWORD fileptr;			///< + 6~+ 9	file pointer
		//		BYTE pad01[4];	///< +10~+13	(unused)
		WORD mode;			///< +14~+15	open mode
		//		BYTE pad02[16];	///< +16~+31	(unused)
		//		DWORD zero;	///< +32~+35	zeros are written when opened (unused)
		//		BYTE name[8];	///< +36~+43	file name (PADDING 0x20) (unused)
		//		BYTE ext[3];	///< +44~+46	extension (PADDING 0x20) (unused)
		BYTE attr;			///< +47	file attribute
		//		BYTE add[10];	///< +48~+57	file name addition (PADDING 0x00) (unused)
		WORD time;			///< +58~+59	last change time of day
		WORD date;			///< +60~+61	last change date
		//		WORD cluster;	///< +62~+63	cluster number (unused)
		DWORD size;			///< +64~+67	file size
		//		BYTE pad03[28];	///< +68~+95	FAT cache (unused)
	};

	struct capacity_t {
		WORD freearea;			///< + 0	Number of available clusters
		WORD clusters;			///< + 2	Total number of clusters
		WORD sectors;			///< + 4	Number of sectors per cluster
		WORD bytes;			///< + 6	Number of bytes per sector
	};

	struct ctrldrive_t {
		BYTE status;			///< +13	status
		BYTE pad[3];			///< Padding
	};

	struct dpb_t {
		WORD sector_size;		///< + 0	Number of bytes in one sector
		BYTE cluster_size;		///< + 2	Number sectors in one cluster -1
		BYTE shift;			///< + 3	Number of cluster→sector shifts
		WORD fat_sector;		///< + 4	FAT first sector number
		BYTE fat_max;			///< + 6	FAT storage quantity
		BYTE fat_size;			///< + 7	FAT controlled sector number (excluding duplicates)
		WORD file_max;			///< + 8	Number of files in the root directory
		WORD data_sector;		///< +10	First sector number of data storage
		WORD cluster_max;		///< +12	Total number of clusters +1
		WORD root_sector;		///< +14	First sector number of root directory
		//	DWORD driverentry;	///< +16	Device driver pointer (unused)
		BYTE media;			///< +20	Media identifier
		//	BYTE flag;		///< +21	Flag used by DPB (unused)
	};

	/// Directory entry struct
	struct dirent_t {
		BYTE name[8];			///< + 0	File name (PADDING 0x20)
		BYTE ext[3];			///< + 8	Extension (PADDING 0x20)
		BYTE attr;			///< +11	File attribute
		BYTE add[10];			///< +12	File name addition (PADDING 0x00)
		WORD time;			///< +22	Last change time of day
		WORD date;			///< +24	Last change date
		WORD cluster;			///< +26	Cluster number
		DWORD size;			///< +28	File size
	};

	/// IOCTRL parameter union
	union ioctrl_t {
		BYTE buffer[8];			///< Access in byte units
		DWORD param;			///< Parameter (First 4 bytes)
		WORD media;			///< Media byte (First 2 bytes)
	};

	/// Command line parameter struct
	/**
	The driver itself is included in the beginning of the argument, 
	so setting to a length longer than HUMAN68K_PATH_MAX
	*/
	struct argument_t {
		BYTE buf[256];			///< Command line argument
	};
}

/// Number of FILES buffers
/**
Under normal circumstances it's enough with just a few buffers,
but Human68k multitasking may lead to multiple threads working
deeply in the system, which is why this value is set this high.

Default is 20 buffers.
*/
#define XM6_HOST_FILES_MAX	20

/// Number of FCB buffers
/**
This decides how many files can be opened at the same time.

Default is 100 files.
*/
#define XM6_HOST_FCB_MAX	100

/// Max number of virtual clusters and sectors
/**
Number of virtual sectors used for accessing the first sector of a file entity.
Allocating a generous amount to exceed the number of threads lzdsys uses for access.

Default is 10 sectors.
*/
#define XM6_HOST_PSEUDO_CLUSTER_MAX	10

/// Number of caches for directory entries
/**
Human68k carries out a large number of checks of directory entries when doing an operation 
inside a subdirectory. This specifies the number of caches used to speed up this operation. 
Cache is allocated per drive. The more you add the faster it gets, but use too many 
and the host OS gets under a heavy load, so be careful.

Default is 16.
*/
#define XM6_HOST_DIRENTRY_CACHE_MAX	16

/// Max number of entries that can be stored per directory
/**
When a large number of files are stored in a directory, a larger amount of data than 
contemporanous applications can handle will be returned. This may lead to errors such as 
partial data being recognized, performance dropping significantly, or OOM crashes.
To guard against this, an upper limit is defined here. In the case of a particular 
file manager, the upper limit is 2560 files. This is one good example to use as reference.

Default is around 60000 entries. (Upper limit of the FAT root directory)
*/
#define XM6_HOST_DIRENTRY_FILE_MAX	65535

/// Max number of patterns for file name deduplication
/**
The file names on the Human68k side are automatically created based on the file system on 
the host side. However, Human68k have stricter file name length restrictions than the host has. 
Because of this, there is a risk that file name duplication will occur. When this happens, 
WindrvXM will use a certain renaming heuristic to generate alternate file names to resolve 
the duplication. Theoretically, there are over 60 million (36^5) unique file names that 
can be generated by this method. However, in reality any more than a few hundred 
deduplications will take excessive processing time. So here an upper limit to deduplication 
is set in order to maintain system performance. If a system is operated with common sense, 
you should only need a few dozen deduplication patterns, so this value can be kept low 
to further improve performance. In the case deduplication is not carried out, multiple files 
with the same name will be created. When trying to access such files, 
only the first entry will ever be accessed.

Default is 36 patterns.
*/
#define XM6_HOST_FILENAME_PATTERN_MAX	36

/// Duplicate file identification mark
/**
A symbol used to distinguish between host and Human68k files.
Do not use a command shell escape character, or similar protected symbol.

Default is '@'.
*/
#define XM6_HOST_FILENAME_MARK	'@'

/// WINDRV operational flags
/**
Normally set to 0. When put in the OS trash can for deletion, it is set to 1.
Other values are reserved for future use.
Can be used for future extentions such as internal operational flags or mock media byte.
*/
enum {
	WINDRV_OPT_REMOVE =		0x00000001,	///< Bit 0: File delete process			0:Directly 1:Trash can
	WINDRV_OPT_ALPHABET =		0x00000020,	///< Bit 5: File name comparison; Alphabet distinction		0:No 1:Yes	0:-C 1:+C
	WINDRV_OPT_COMPARE_LENGTH =	0x00000040,	///< Bit 6: File name comparison; String length (unimplemented)	0:18+3 1:8+3	0:+T 1:-T
	WINDRV_OPT_CONVERT_LENGTH =	0x00000080,	///< Bit 7: File name conversion; String length		0:18+3 1:8+3	0:-A 1:+A
	WINDRV_OPT_CONVERT_SPACE =	0x00000100,	///< Bit 8: File name conversion; Space		0:No 1:'_'
	WINDRV_OPT_CONVERT_BADCHAR =	0x00000200,	///< Bit 9: File name conversion; Invalid char		0:No 1:'_'
	WINDRV_OPT_CONVERT_HYPHENS =	0x00000400,	///< Bit10: File name conversion; Middle hyphen	0:No 1:'_'
	WINDRV_OPT_CONVERT_HYPHEN =	0x00000800,	///< Bit11: File name conversion; Initial hyphen	0:No 1:'_'
	WINDRV_OPT_CONVERT_PERIODS =	0x00001000,	///< Bit12: File name conversion; Middle period	0:No 1:'_'
	WINDRV_OPT_CONVERT_PERIOD =	0x00002000,	///< Bit13: File name conversion; Initial period	0:No 1:'_'
	WINDRV_OPT_REDUCED_SPACE =	0x00010000,	///< Bit16: File name reduction; Space		0:No 1:Reduced
	WINDRV_OPT_REDUCED_BADCHAR =	0x00020000,	///< Bit17: File name reduction; Invalid char		0:No 1:Reduced
	WINDRV_OPT_REDUCED_HYPHENS =	0x00040000,	///< Bit18: File name reduction Middle hyphen	0:No 1:Reduced
	WINDRV_OPT_REDUCED_HYPHEN =	0x00080000,	///< Bit19: File name reduction Initial hyphen	0:No 1:Reduced
	WINDRV_OPT_REDUCED_PERIODS =	0x00100000,	///< Bit20: File name reduction Middle period	0:No 1:Reduced
	WINDRV_OPT_REDUCED_PERIOD =	0x00200000,	///< Bit21: File name reduction Initial period	0:No 1:Reduced
	// Bit24～30 Duplicate file identification mark			0:Automatic 1～127:Chars
};

/// File system operational flag
/**
Normal is 0. Becomes 1 if attempting to mount in read-only mode.
Reserving the other values for future use.
Insurance against hard-to-detect devices such as homemade USB storage.
*/
enum {
	FSFLAG_WRITE_PROTECT =		0x00000001,	///< Bit0: Force write protect
	FSFLAG_REMOVABLE =		0x00000002,	///< Bit1: Force removable media
	FSFLAG_MANUAL =			0x00000004,	///< Bit2: Force manual eject
};

//===========================================================================
//
/// Full ring list
///
/// First (root.next) is the most recent object.
/// Last (root.prev) is the oldest / unused object.
/// For code optimization purposes, always upcast the pointer when deleting.
//
//===========================================================================
class CRing {
public:
	CRing() { Init(); }
	~CRing() { Remove(); }
	void  Init() { next = prev = this; }

	CRing*  Next() const { return next; }			///< Get the next element
	CRing*  Prev() const { return prev; }			///< Get the previous element

	void  Insert(CRing* pRoot)
	{
			// Separate the relevant objects
		ASSERT(next);
		ASSERT(prev);
		next->prev = prev;
		prev->next = next;
		// Insert into the beginning of the ring
		ASSERT(pRoot);
		ASSERT(pRoot->next);
		next = pRoot->next;
		prev = pRoot;
		pRoot->next->prev = this;
		pRoot->next = this;
	}
										///< Separate objects & insert into the beginning of the ring

	void  InsertTail(CRing* pRoot)
	{
			// Separate the relevant objects
		ASSERT(next);
		ASSERT(prev);
		next->prev = prev;
		prev->next = next;
		// Insert into the end of the ring
		ASSERT(pRoot);
		ASSERT(pRoot->prev);
		next = pRoot;
		prev = pRoot->prev;
		pRoot->prev->next = this;
		pRoot->prev = this;
	}
										///< Separate objects & insert into the end of the ring

	void  InsertRing(CRing* pRoot)
	{
			if (next == prev) return;

		// Insert into the beginning of the ring
		ASSERT(pRoot);
		ASSERT(pRoot->next);
		pRoot->next->prev = prev;
		prev->next = pRoot->next;
		pRoot->next = next;
		next->prev = pRoot;

		// Empty self
		next = prev = this;
	}
										///< Separate objects except self & insert into the beginning of the ring

	void  Remove()
	{
			// Separate the relevant objects
		ASSERT(next);
		ASSERT(prev);
		next->prev = prev;
		prev->next = next;
		// To be safe, assign self (nothing stops you from separating any number of times)
		next = prev = this;
	}
										///< Separate objects

private:
	CRing* next;						///< Next element
	CRing* prev;						///< Previous element
};

//===========================================================================
//
/// Directory Entry: File Name
//
//===========================================================================
class CHostFilename {
public:
	CHostFilename();
	static size_t  Offset() { return offsetof(CHostFilename, m_szHost); }	///< Get offset location

	void  SetHost(const TCHAR* szHost);					///< Set the name of the host
	const TCHAR*  GetHost() const { return m_szHost; }	///< Get the name of the host
	void  ConvertHuman(int nCount = -1);					///< Convert the Human68k name
	void  CopyHuman(const BYTE* szHuman);					///< Copy the Human68k name
	BOOL  isReduce() const;							///< Inspect if the Human68k name is generated
	BOOL  isCorrect() const { return m_bCorrect; }		///< Inspect if the Human68k file name adhers to naming rules
	const BYTE*  GetHuman() const { return m_szHuman; }	///< Get Human68k file name
	const BYTE*  GetHumanLast() const 
	{ return m_pszHumanLast; }				///< Get Human68k file name
	const BYTE*  GetHumanExt() const { return m_pszHumanExt; }///< Get Human68k file name
	void  SetEntryName();							///< Set Human68k directory entry
	void  SetEntryAttribute(BYTE nHumanAttribute)
	{ m_dirHuman.attr = nHumanAttribute; }			///< Set Human68k directory entry
	void  SetEntrySize(DWORD nHumanSize)
	{ m_dirHuman.size = nHumanSize; }				///< Set Human68k directory entry
	void  SetEntryDate(WORD nHumanDate)
	{ m_dirHuman.date = nHumanDate; }				///< Set Human68k directory entry
	void  SetEntryTime(WORD nHumanTime)
	{ m_dirHuman.time = nHumanTime; }				///< Set Human68k directory entry
	void  SetEntryCluster(WORD nHumanCluster)
	{ m_dirHuman.cluster = nHumanCluster; }			///< Set Human68k directory entry
	const Human68k::dirent_t*  GetEntry() const 
	{ return &m_dirHuman; }					///< Get Human68k directory entry
	BOOL  CheckAttribute(DWORD nHumanAttribute) const;			///< Determine Human68k directory entry attributes
	BOOL  isSameEntry(const Human68k::dirent_t* pdirHuman) const
	{ ASSERT(pdirHuman); return memcmp(&m_dirHuman, pdirHuman, sizeof(m_dirHuman)) == 0; }
										///< Determine Human68k directory entry match

	// Path name operations
	static const BYTE*  SeparateExt(const BYTE* szHuman);			///< Extract extension from Human68k file name

private:
	static BYTE*  CopyName(BYTE* pWrite, const BYTE* pFirst, const BYTE* pLast);
										///< Copy Human68k file name elements

	const BYTE* m_pszHumanLast;		///< Last position of the Human68k internal name of the relevant entry
	const BYTE* m_pszHumanExt;		///< Position of the extension of the Human68k internal name of the relevant entry
	BOOL m_bCorrect;			///< TRUE if the relevant entry of the Human68k internal name is correct
	BYTE m_szHuman[24];			///< Human68k internal name of the relevant entry
	Human68k::dirent_t m_dirHuman;		///< All information for the Human68k relevant entry
	TCHAR m_szHost[FILEPATH_MAX];		///< The host name of the relevant entry (variable length)
};

//===========================================================================
//
/// Directory entry: path name
///
/// A file path in Human68k always begings with / and ends with /
/// They don't hold unit numbers.
/// Include the base path part of the name on the host side for a performance boost.
//
//===========================================================================
/** @note
Most Human68k applications are written in a way that expects time stamps not to
get updated for new directories created as a result of file operations, which
triggers updates to directory entires.
However, on the host file system, new directories do typically get an updated time stamp.

The unfortunate outcome is that when copying a directory for instance, the time stamp 
will get overwritten even if the application did not intend for the time stamp to get updated.

Here follows an implementation of a directory cache FAT time stamp  emulation feature.
At the time of a file system update on the host side, time stamp information will be restored
in order to achieve expected behavior on the Human68k side.
*/
class CHostPath: public CRing {
	/// For memory management
	struct ring_t {
		CRing r;
		CHostFilename f;
	};

public:
	/// Search buffer
	struct find_t {
		DWORD count;			///< Search execution count + 1 (When 0 the below value is invalid)
		DWORD id;			///< Entry unique ID for the path of the next search
		const ring_t* pos;		///< Position of the next search (When identical to unique ID)
		Human68k::dirent_t entry;	///< Contents of the next seach entry

		void  Clear() { count = 0; }	///< Initialize
	};

	CHostPath();
	~CHostPath();
	void  Clean();								///< Initialialize for reuse

	void  SetHuman(const BYTE* szHuman);					///< Directly specify the name on the Human68k side
	void  SetHost(const TCHAR* szHost);					///< Directly specify the name on the host side
	BOOL  isSameHuman(const BYTE* szHuman) const;				///< Compare the name on the Human68k side
	BOOL  isSameChild(const BYTE* szHuman) const;				///< Compare the name on the Human68k side
	const TCHAR*  GetHost() const { return m_szHost; }	///< Obtain the name on the host side
	const CHostFilename*  FindFilename(const BYTE* szHuman, DWORD nHumanAttribute = Human68k::AT_ALL) const;
										///< Find file name
	const CHostFilename*  FindFilenameWildcard(const BYTE* szHuman, DWORD nHumanAttribute, find_t* pFind) const;
										///< Find file name (with support for wildcards)
	BOOL  isRefresh();							///< Check that the file change has been done
	void  Refresh();							///< Refresh file
	void  Backup();								/// Backup the time stamp on the host side
	void  Restore() const;							/// Restore the time stamp on the host side
	void  Release();							///< Update

	// CHostEntry is an external API that we use
	static void  InitId() { g_nId = 0; }					///< Initialize the counter for the unique ID generation

private:
	static ring_t*  Alloc(size_t nLength);					///< Allocate memory for the file name
	static void  Free(ring_t* pRing);					///< Release memory for the file name
	static int  Compare(const BYTE* pFirst, const BYTE* pLast, const BYTE* pBufFirst, const BYTE* pBufLast);
										///< Compare string (with support for wildcards)

	CRing m_cRing;								///< For CHostFilename linking
	time_t m_tBackup;							///< For time stamp restoration
	BOOL m_bRefresh;							///< Refresh flag
	DWORD m_nId;								///< Unique ID (When the value has changed, it means an update has been made)
	BYTE m_szHuman[HUMAN68K_PATH_MAX];					///< The internal Human68k name for the relevant entry
	TCHAR m_szHost[FILEPATH_MAX];						///< The host side name for the relevant entry

	static DWORD g_nId;							///< Counter for the unique ID generation
};

//===========================================================================
//
/// File search processing
///
/// It's pretty much impossible to process Human68k file names as Unicode internally. 
/// So, we carry out binary conversion for processing. We leave it up to the
/// directory entry cache to handle the conversion, which allows WINDRV to read 
/// everything as Shift-JIS. Additionally, it allows Human68k names to be
/// fully independent of base path assignments.
///
/// We create directory entry cache just before file handling.
/// Since creating directory entires is very costly, we try to reuse created entries
/// as much as humanly possible.
///
/// There are three kinds of file search. They are all processed in CHostFiles::Find()
/// 1. Search by path name only; the only attribute is 'directory'; _CHKDIR _CREATE
/// 2. Path + file name + attribute search; _OPEN
/// 3. Path + wildcard + attribute search; _FILES _NFILES
/// The search results are kept as directory entry data.
//
//===========================================================================
class CHostFiles {
public:
	CHostFiles() { SetKey(0); Init(); }
	void  Init();

	void  SetKey(DWORD nKey) { m_nKey = nKey; }			///< Set search key
	BOOL  isSameKey(DWORD nKey) const { return m_nKey == nKey; }	///< Compare search key
	void  SetPath(const Human68k::namests_t* pNamests);				///< Create path and file name internally
	BOOL  isRootPath() const { return m_szHumanPath[1] == '\0'; }			///< Check if root directory
	void  SetPathWildcard() { m_nHumanWildcard = 1; }				///< Enable file search using wildcards
	void  SetPathOnly() { m_nHumanWildcard = 0xFF; }				///< Enable only path names
	BOOL  isPathOnly() const { return m_nHumanWildcard == 0xFF; }			///< Check if set to only path names
	void  SetAttribute(DWORD nHumanAttribute) { m_nHumanAttribute = nHumanAttribute; }
											///< Set search attribute
	BOOL  Find(DWORD nUnit, class CHostEntry* pEntry);				///< Find files on the Human68k side, generating data on the host side
	const CHostFilename*  Find(CHostPath* pPath);					///< Find file name
	void  SetEntry(const CHostFilename* pFilename);					///< Store search results on the Human68k side
	void  SetResult(const TCHAR* szPath);						///< Set names on the host side
	void  AddResult(const TCHAR* szPath);						///< Add file name to the name on the host side
	void  AddFilename();								///< Add the new Human68k file name to the name on the host side

	const TCHAR*  GetPath() const { return m_szHostResult; }		///< Get the name on the host side

	const Human68k::dirent_t*  GetEntry() const { return &m_dirHuman; }///< Get Human68k directory entry

	DWORD  GetAttribute() const { return m_dirHuman.attr; }		///< Get Human68k attribute
	WORD  GetDate() const { return m_dirHuman.date; }			///< Get Human68k date
	WORD  GetTime() const { return m_dirHuman.time; }			///< Get Human68k time
	DWORD  GetSize() const { return m_dirHuman.size; }		///< Get Human68k file size
	const BYTE*  GetHumanFilename() const { return m_szHumanFilename; }///< Get Human68k file name
	const BYTE*  GetHumanResult() const { return m_szHumanResult; }	///< Get Human68k file name search results
	const BYTE*  GetHumanPath() const { return m_szHumanPath; }	///< Get Human68k path name

private:
	DWORD m_nKey;						///< FILES buffer address for Human68k; 0 is unused
	DWORD m_nHumanWildcard;					///< Human68k wildcard data
	DWORD m_nHumanAttribute;				///< Human68k search attribute
	CHostPath::find_t m_findNext;				///< Next search location data
	Human68k::dirent_t m_dirHuman;				///< Search results: Human68k file data
	BYTE m_szHumanFilename[24];				///< Human68k file name
	BYTE m_szHumanResult[24];				///< Search results: Human68k file name
	BYTE m_szHumanPath[HUMAN68K_PATH_MAX];
								///< Human68k path name
	TCHAR m_szHostResult[FILEPATH_MAX];			///< Search results: host's full path name
};

//===========================================================================
//
/// File search memory manager
//
//===========================================================================
class CHostFilesManager {
public:
#ifdef _DEBUG
	~CHostFilesManager();
#endif	// _DEBUG
	void  Init();						///< Initialization (when the driver is installed)
	void  Clean();						///< Release (when starting up or resetting)

	CHostFiles*  Alloc(DWORD nKey);
	CHostFiles*  Search(DWORD nKey);
	void  Free(CHostFiles* pFiles);
private:
	/// For memory management
	struct ring_t {
		CRing r;
		CHostFiles f;
	};

	CRing m_cRing;						///< For attaching to CHostFiles
};

//===========================================================================
//
/// FCB processing
//
//===========================================================================
class CHostFcb {
public:
	CHostFcb() { SetKey(0); Init(); }
	~CHostFcb() { Close(); }
	void  Init();

	void  SetKey(DWORD nKey) { m_nKey = nKey; }			///< Set search key
	BOOL  isSameKey(DWORD nKey) const { return m_nKey == nKey; }	///< Compare search key
	void  SetUpdate() { m_bUpdate = TRUE; }				///< Update
	BOOL  isUpdate() const { return m_bUpdate; }			///< Get update state
	BOOL  SetMode(DWORD nHumanMode);						///< Set file open mode
	void  SetFilename(const TCHAR* szFilename);					///< Set file name
	void  SetHumanPath(const BYTE* szHumanPath);					///< Set Human68k path name
	const BYTE*  GetHumanPath() const { return m_szHumanPath; }	///< Get Human68k path name

	BOOL  Create(DWORD nHumanAttribute, BOOL bForce);	///< Create file
	BOOL  Open();									///< Open file
	BOOL  Rewind(DWORD nOffset);							///< Seek file
	DWORD  Read(BYTE* pBuffer, DWORD nSize);					///< Read file
	DWORD  Write(const BYTE* pBuffer, DWORD nSize);					///< Write file
	BOOL  Truncate();								///< Truncate file
	DWORD  Seek(DWORD nOffset, DWORD nHumanSeek);					///< Seek file
	BOOL  TimeStamp(DWORD nHumanTime);						///< Set file time stamp
	BOOL  Close();									///< Close file

private:
	DWORD m_nKey;									///< Human68k FCB buffer address (0 if unused)
	BOOL m_bUpdate;									///< Update flag
	FILE* m_pFile;									///< Host side file object
	const char* m_pszMode;								///< Host side file open mode
	bool m_bFlag;									///< Host side file open flag
	BYTE m_szHumanPath[HUMAN68K_PATH_MAX];
											///< Human68k path name
	TCHAR m_szFilename[FILEPATH_MAX];						///< Host side file name
};

//===========================================================================
//
/// FCB processing manager
//
//===========================================================================
class CHostFcbManager {
public:
	#ifdef _DEBUG
	~CHostFcbManager();
	#endif	// _DEBUG
	void  Init();								///< Initialization (when the driver is installed)
	void  Clean();								///< Release (when starting up or resetting)

	CHostFcb*  Alloc(DWORD nKey);
	CHostFcb*  Search(DWORD nKey);
	void  Free(CHostFcb* p);

private:
	/// For memory management
	struct ring_t {
		CRing r;
		CHostFcb f;
	};

	CRing m_cRing;								///< For attaching to CHostFcb
};

//===========================================================================
//
/// Host side drive
///
/// Keeps the required data for each drive, managed in CHostEntry.
//
//===========================================================================
class CHostDrv
{
public:
	CHostDrv();
	~CHostDrv();
	void  Init(const TCHAR* szBase, DWORD nFlag);				///< Initialization (device startup and load)

	BOOL  isWriteProtect() const { return m_bWriteProtect; }
	BOOL  isEnable() const { return m_bEnable; }		///< Is it accessible?
	BOOL  isMediaOffline();	
	BYTE  GetMediaByte() const;
	DWORD  GetStatus() const;
	void  SetEnable(BOOL bEnable);						///< Set media status
	BOOL CheckMedia();							///< Check if media was changed
	void Update();								///< Update media status
	void Eject();
	void  GetVolume(TCHAR* szLabel);					///< Get volume label
	BOOL  GetVolumeCache(TCHAR* szLabel) const;				///< Get volume label from cache
	DWORD  GetCapacity(Human68k::capacity_t* pCapacity);
	BOOL  GetCapacityCache(Human68k::capacity_t* pCapacity) const;		///< Get capacity from cache

	// Cache operations
	void  CleanCache();							///< Update all cache
	void  CleanCache(const BYTE* szHumanPath);				///< Update cache for the specified path
	void  CleanCacheChild(const BYTE* szHumanPath);				///< Update all cache below the specified path
	void  DeleteCache(const BYTE* szHumanPath);				///< Delete the cache for the specified path
	CHostPath*  FindCache(const BYTE* szHuman);				///< Inspect if the specified path is cached
	CHostPath*  CopyCache(CHostFiles* pFiles);				///< Acquire the host side name on the basis of cache information
	CHostPath*  MakeCache(CHostFiles* pFiles);				///< Get all required data to construct a host side name
	BOOL  Find(CHostFiles* pFiles);						///< Find host side name (path + file name (can be abbreviated) + attribute)

private:
	// Path name operations
	static const BYTE*  SeparateCopyFilename(const BYTE* szHuman, BYTE* szBuffer);
										///< Split and copy the first element of the Human68k full path name

	void  Lock() {}
	void  Unlock() {}

	/// For memory management
	struct ring_t {
		CRing r;
		CHostPath f;
	};

	BOOL m_bWriteProtect;						///< TRUE if write-protected
	BOOL m_bEnable;							///< TRUE if media is usable
	DWORD m_nRing;							///< Number of stored path names
	CRing m_cRing;							///< For attaching to CHostPath
	Human68k::capacity_t m_capCache;				///< Sector data cache: if "sectors == 0" then not cached
	BOOL m_bVolumeCache;						///< TRUE if the volume label has been read
	TCHAR m_szVolumeCache[24];					///< Volume label cache
	TCHAR m_szBase[FILEPATH_MAX];					///< Base path
};

//===========================================================================
//
/// Directory entry management
//
//===========================================================================
class CHostEntry {
public:
	CHostEntry();
	~CHostEntry();
	void  Init();								///< Initialization (when the driver is installed)
	void  Clean();								///< Release (when starting up or resetting)

	// Cache operations
	void  CleanCache();							///< Update all cache
	void  CleanCache(DWORD nUnit);						///< Update cache for the specified unit
	void  CleanCache(DWORD nUnit, const BYTE* szHumanPath);			///< Update cache for the specified path
	void  CleanCacheChild(DWORD nUnit, const BYTE* szHumanPath);		///< Update cache below the specified path
	void  DeleteCache(DWORD nUnit, const BYTE* szHumanPath);		///< Delete cache for the specified path
	BOOL  Find(DWORD nUnit, CHostFiles* pFiles);				///< Find host side name (path + file name (can be abbreviated) + attribute)
	void  ShellNotify(DWORD nEvent, const TCHAR* szPath);			///< Notify status change in the host side file system

	// Drive object operations
	void  SetDrv(DWORD nUnit, CHostDrv* pDrv);
	BOOL  isWriteProtect(DWORD nUnit) const;
	BOOL  isEnable(DWORD nUnit) const;					///< Is it accessible?
	BOOL  isMediaOffline(DWORD nUnit);
	BYTE  GetMediaByte(DWORD nUnit) const;
	DWORD  GetStatus(DWORD nUnit) const;					///< Get drive status
	BOOL CheckMedia(DWORD nUnit);						///< Media change check
	void Eject(DWORD nUnit);
	void  GetVolume(DWORD nUnit, TCHAR* szLabel);				///< Get volume label
	BOOL  GetVolumeCache(DWORD nUnit, TCHAR* szLabel) const;		///< Get volume label from cache
	DWORD  GetCapacity(DWORD nUnit, Human68k::capacity_t* pCapacity);
	BOOL  GetCapacityCache(DWORD nUnit, Human68k::capacity_t* pCapacity) const;
										///< Get cluster size from cache

	enum {
		DriveMax = 10							///< Max number of drive candidates
	};

private:
	CHostDrv* m_pDrv[DriveMax];						///< Host side drive object
	DWORD m_nTimeout;							///< Last time a timeout check was carried out
};

//===========================================================================
//
/// Host side file system
//
//===========================================================================
/** @note
Current state of affairs:

While it violates the design philosophy of XM6, we should find a way for 
'class Windrv' and 'class CWindrv' to have a direct pointer to 'class CFileSys'. 
This way, we get the following benefits.

Benefit no. 1
Makes it possible to manage a large number of command handler methods in one place. 
There is a high chance the command handlers will change drastically because of 
host system architectural changes, so we will save a huge amount of maintenance work
in the long run.

Benefit no. 2
We would get rid of virtual funcion code for processing table creation and lookup.
It is not feasible to implement code in XM6 for simultaneous use of file system objects.
Therefore file system object polymorphism is a waste of CPU cycles.

I made the change as an experiment. Performance did improve.
The improvement was obvious from looking at the source the compiler spit out 
after changing the FILESYS_FAST_STRUCTURE value in windrv.h.
You may understand now why I decided to rant here.

The easy solution is to put the content of 'class CFileSys' into 'class CWindrv'.
(To be honest, I really want to deprecate 'class CHost'... I wonder if there's a good way...)
*/
class CFileSys
{
public:
	CFileSys();
	virtual ~CFileSys() {};

	void Reset();								///< Reset (close all)
	void Init();								///< Initialization (device startup and load)

	// Command handlers
	DWORD InitDevice(const Human68k::argument_t* pArgument);		///< $40 - Device startup
	int CheckDir(DWORD nUnit, const Human68k::namests_t* pNamests);		///< $41 - Directory check
	int MakeDir(DWORD nUnit, const Human68k::namests_t* pNamests);		///< $42 - Create directory
	int RemoveDir(DWORD nUnit, const Human68k::namests_t* pNamests);	///< $43 - Delete directory
	int Rename(DWORD nUnit, const Human68k::namests_t* pNamests, const Human68k::namests_t* pNamestsNew);
										///< $44 - Change file name
	int Delete(DWORD nUnit, const Human68k::namests_t* pNamests);		///< $45 - Delete file
	int Attribute(DWORD nUnit, const Human68k::namests_t* pNamests, DWORD nHumanAttribute);
										///< $46 - Get / set file attribute
	int Files(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::files_t* pFiles);
										///< $47 - Find file
	int NFiles(DWORD nUnit, DWORD nKey, Human68k::files_t* pFiles);		///< $48 - Find next file
	int Create(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::fcb_t* pFcb, DWORD nHumanAttribute, BOOL bForce);
										///< $49 - Create file
	int Open(DWORD nUnit, DWORD nKey, const Human68k::namests_t* pNamests, Human68k::fcb_t* pFcb);
										///< $4A - Open file
	int Close(DWORD nUnit, DWORD nKey, Human68k::fcb_t* pFcb);		///< $4B - Close file
	int Read(DWORD nKey, Human68k::fcb_t* pFcb, BYTE* pAddress, DWORD nSize);
										///< $4C - Read file
	int Write(DWORD nKey, Human68k::fcb_t* pFcb, const BYTE* pAddress, DWORD nSize);
										///< $4D - Write file
	int Seek(DWORD nKey, Human68k::fcb_t* pFcb, DWORD nSeek, int nOffset);	///< $4E - Seek file
	DWORD TimeStamp(DWORD nUnit, DWORD nKey, Human68k::fcb_t* pFcb, DWORD nHumanTime);
										///< $4F - Get / set file timestamp
	int GetCapacity(DWORD nUnit, Human68k::capacity_t* pCapacity);		///< $50 - Get capacity
	int CtrlDrive(DWORD nUnit, Human68k::ctrldrive_t* pCtrlDrive);		///< $51 - Inspect / control drive status
	int GetDPB(DWORD nUnit, Human68k::dpb_t* pDpb);				///< $52 - Get DPB
	int DiskRead(DWORD nUnit, BYTE* pBuffer, DWORD nSector, DWORD nSize);	///< $53 - Read sectors
	int DiskWrite(DWORD nUnit);						///< $54 - Write sectors
	int Ioctrl(DWORD nUnit, DWORD nFunction, Human68k::ioctrl_t* pIoctrl);	///< $55 - IOCTRL
	int Flush(DWORD nUnit);							///< $56 - Flush
	int CheckMedia(DWORD nUnit);						///< $57 - Media change check
	int Lock(DWORD nUnit);							///< $58 - Lock

	void SetOption(DWORD nOption);						///< Set option
	DWORD GetOption() const { return m_nOption; }		///< Get option
	DWORD GetDefault() const { return m_nOptionDefault; }	///< Get default options
	static DWORD GetFileOption() { return g_nOption; }			///< Get file name change option
	void ShellNotify(DWORD nEvent, const TCHAR* szPath)
	{ m_cEntry.ShellNotify(nEvent, szPath); }			///< Notify host side file system status change

	enum {
		DriveMax = CHostEntry::DriveMax					///< Max number of drive candidates
	};

private:
	void  InitOption(const Human68k::argument_t* pArgument);
	BOOL  FilesVolume(DWORD nUnit, Human68k::files_t* pFiles);		///< Get volume label

	DWORD m_nUnits;								///< Number of current drive objects (Changes for every resume)

	DWORD m_nOption;							///< Current runtime flag
	DWORD m_nOptionDefault;							///< Runtime flag at reset

	DWORD m_nDrives;							///< Number of candidates for base path status restoration (scan every time if 0)

	DWORD m_nKernel;							///< Counter for kernel check
	DWORD m_nKernelSearch;							///< Initial address for NUL device

	DWORD m_nHostSectorCount;						///< Virtual sector identifier

	CHostFilesManager m_cFiles;						///< File search memory
	CHostFcbManager m_cFcb;							///< FCB operation memory
	CHostEntry m_cEntry;							///< Drive object and directory entry

	DWORD m_nHostSectorBuffer[XM6_HOST_PSEUDO_CLUSTER_MAX];
										///< Entity that the virtual sector points to

	DWORD m_nFlag[DriveMax];						///< Candidate runtime flag for base path restoration
	TCHAR m_szBase[DriveMax][FILEPATH_MAX];					///< Candidate for base path restoration
	static DWORD g_nOption;							///< File name change flag
};