/******************************************************************************/
/* FILESYSTEM ABSTRACTION *****************************************************/
/******************************************************************************/

#ifndef _H_EBCL_FILESYSTEM
#define _H_EBCL_FILESYSTEM

#include <ebcl/Strings.hh>
#include <ebcl/Utilities.hh>
namespace ebcl {


/*= FILESYSTEM PATH ==========================================================*/

class T_FSPath
{
    public:
	using T_Components = T_AutoArray< T_String , 16 >;

    private:

	// Root will be '/' on Unix, or a drive letter on Windows. Relative
	// paths will have a blank root.
	T_String root_;	
	T_Components components_;
	bool valid_;

    public:
	//----------------------------------------------------------------------
	// Helpers

	static bool IsValidComponent( T_String const& string ) noexcept;
	static bool IsValidRoot( T_String const& string ) noexcept;

	//----------------------------------------------------------------------
	// Basic constructors and assignment operators

	T_FSPath( ) noexcept;

	T_FSPath( T_FSPath const& other ) noexcept;
	T_FSPath& operator =( T_FSPath const& other ) noexcept;

	T_FSPath( T_FSPath&& other ) noexcept;
	T_FSPath& operator =( T_FSPath&& other ) noexcept;

	T_FSPath& swap( T_FSPath& other ) noexcept;

	// Construct from a string
	T_FSPath( T_String const& path ) noexcept;

	//----------------------------------------------------------------------

	bool isValid( ) const noexcept;

	T_String const& root( ) const noexcept;
	T_Components const& components( ) const noexcept;

	bool isRelative( ) const noexcept;
	bool isAbsolute( ) const noexcept;

	//----------------------------------------------------------------------

	// Convert the path into a string
	T_String toString( ) const noexcept;
	// Compute a hash value for the path
	uint32_t computeHash( ) const noexcept;
	// Append to a string builder
	void appendTo( T_StringBuilder& sb ) const noexcept;

	// Comparisons. On Windows the comparison will be case-insensitive.
	int32_t compareTo( T_FSPath const& other ) const noexcept;
	bool operator ==( T_FSPath const& other ) const noexcept;
	bool operator !=( T_FSPath const& other ) const noexcept;
	bool operator <( T_FSPath const& other ) const noexcept;
	bool operator <=( T_FSPath const& other ) const noexcept;
	bool operator >( T_FSPath const& other ) const noexcept;
	bool operator >=( T_FSPath const& other ) const noexcept;

	//----------------------------------------------------------------------

	// Returns the parent's path
	T_FSPath parent( ) const noexcept;

	// Returns the child's path
	T_FSPath child( T_String const& name ) const noexcept;

	// Appends the specified (relative) path to the current path and return
	// the result. If the path is absolute, the result will be invalid.
	T_FSPath operator +( T_FSPath const& other ) const noexcept;

	// Checks if the current path and the specified path have the same
	// parent and are different.
	bool inDirectoryOf( T_FSPath const& other ) const noexcept;

	// Checks if the current path is the direct parent of the specified path
	bool isParentOf( T_FSPath const& other ) const noexcept;
	// Checks if the current path is the direct child of the specified path
	bool isChildOf( T_FSPath const& other ) const noexcept;

	// Checks if the current path is a parent of the specified path
	bool isAbove( T_FSPath const& other ) const noexcept;
	// Checks if the current path is a child of the specified path
	bool isUnder( T_FSPath const& other ) const noexcept;

	// Create a relative path based on the current path and a "parent" path.
	// Both paths must be canonical and valid. If they have different roots,
	// a copy of the current path will be returned.
	T_FSPath makeRelative( T_FSPath const& relTo ) const noexcept;

	//----------------------------------------------------------------------

	// Checks whether the specified path is canonical
	bool isCanonical( ) const noexcept;
	// Return a canonical path from the current path
	T_FSPath canonical( ) const noexcept;
};
M_DECLARE_SWAP( T_FSPath );
M_DECLARE_HASH( T_FSPath );
M_LSHIFT_OP( T_StringBuilder , T_FSPath const& );


/*= FILESYSTEM ===============================================================*/

class Filesystem final
{
	Filesystem( ) = delete;
    public:
	// Return the absolute path to the current working directory
	static T_FSPath Cwd( ) noexcept;

};


/*= T_FSPath =================================================================*/
// FIXME: inline stuff should be moved

inline T_FSPath::T_FSPath( ) noexcept
	: root_{ } , components_{ } , valid_{ true }
{ }

/*----------------------------------------------------------------------------*/

inline T_FSPath::T_FSPath(
		T_FSPath const& other ) noexcept
	: root_{ other.root_ } , components_{ other.components_ } ,
		valid_{ other.valid_ }
{ }

inline T_FSPath& T_FSPath::operator =(
		T_FSPath const& other ) noexcept
{
	root_ = other.root_;
	components_ = other.components_;
	valid_ = other.valid_;
	return *this;
}

/*----------------------------------------------------------------------------*/

inline T_FSPath::T_FSPath( T_FSPath&& other ) noexcept
	: T_FSPath{ }
{
	swap( other );
}

inline T_FSPath& T_FSPath::operator =(
		T_FSPath&& other ) noexcept
{
	root_ = T_String{ };
	components_.free( );
	valid_ = true;
	return swap( other );
}

/*----------------------------------------------------------------------------*/

inline T_FSPath& T_FSPath::swap(
		T_FSPath& other ) noexcept
{
	using std::swap;
	swap( root_ , other.root_ );
	swap( components_ , other.components_ );
	swap( valid_ , other.valid_ );
	return *this;
}

inline M_DEFINE_SWAP( T_FSPath )
{
	lhs.swap( rhs );
}

/*----------------------------------------------------------------------------*/

inline bool T_FSPath::isValid( ) const noexcept
{
	return valid_;
}

inline T_String const& T_FSPath::root( ) const noexcept
{
	return root_;
}

inline T_FSPath::T_Components const& T_FSPath::components( ) const noexcept
{
	return components_;
}

inline bool T_FSPath::isRelative( ) const noexcept
{
	return !root_;
}

inline bool T_FSPath::isAbsolute( ) const noexcept
{
	return bool( root_ );
}

/*----------------------------------------------------------------------------*/

inline T_String T_FSPath::toString( ) const noexcept
{
	T_StringBuilder sb;
	appendTo( sb );
	return T_String{ std::move( sb ) };
}

inline M_DEFINE_HASH( T_FSPath )
{
	return item.computeHash( );
}

inline M_LSHIFT_OP( T_StringBuilder , T_FSPath const& )
{
	value.appendTo( obj );
	return obj;
}

/*----------------------------------------------------------------------------*/

inline bool T_FSPath::operator ==(
		T_FSPath const& other ) const noexcept
{
	return compareTo( other ) == 0;
}

inline bool T_FSPath::operator !=(
		T_FSPath const& other ) const noexcept
{
	return compareTo( other ) != 0;
}

inline bool T_FSPath::operator <(
		T_FSPath const& other ) const noexcept
{
	return compareTo( other ) < 0;
}

inline bool T_FSPath::operator <=(
		T_FSPath const& other ) const noexcept
{
	return compareTo( other ) <= 0;
}

inline bool T_FSPath::operator >(
		T_FSPath const& other ) const noexcept
{
	return compareTo( other ) > 0;
}

inline bool T_FSPath::operator >=(
		T_FSPath const& other ) const noexcept
{
	return compareTo( other ) >= 0;
}

/*----------------------------------------------------------------------------*/

inline bool T_FSPath::isChildOf(
		T_FSPath const& other ) const noexcept
{
	return other.isParentOf( *this );
}

inline bool T_FSPath::isUnder(
		T_FSPath const& other ) const noexcept
{
	return other.isAbove( *this );
}


} // namespace ebcl
#endif // _H_EBCL_FILESYSTEM