#ifndef __filesystem_h__
#define __filesystem_h__

#include <chrono>
#include <cstdint>
#include <locale>
#include <stdexcept>
#include <string>
#include <system_error>
#include <memory>

#include <dirent.h>

/*
 *
 * light-weight implementation of n3803
 *
 *
 */

namespace filesystem {

	class path;
	class filesystem_error;

	using std::error_code;
	using std::system_error;

	class path {

	public:

		typedef char value_type;
		typedef std::basic_string<value_type> string_type;
		static constexpr value_type preferred_separator = '/';


		// constructors and destructor
		path() = default;
		path(const path& p) = default;
		path(path&& p) noexcept :
			_path(std::move(p._path)) {
			p.invalidate();
		}

		template<class Source>
		path(Source const& source) :
			_path(source) {}

		template <class InputIterator>
		path(InputIterator begin, InputIterator end) :
			_path(begin, end) {}

		template <class Source>
		path(Source const& source, const std::locale& loc);

		template <class InputIterator>
		path(InputIterator begin, InputIterator end, const std::locale& loc);

		~path() = default;

		// assignments
		path& operator=(const path& p) {
			if (this != &p)	{
				_path = p._path;
				_info = p._info;
			}
			return *this;
		}
		path& operator=(path&& p) noexcept {
			if (this != &p) {
				_path = std::move(p._path);
				_info = p._info;
				p.invalidate();
			}
			return *this;
		}

		template <class Source>
		path& operator=(Source const& source) {
			invalidate();
			_path = source;
			return *this;
		}

		path& assign(const path &p) {
			return (*this = p);
		}

		template <class Source>
		path& assign(Source const& source) {
			invalidate();
			_path.assign(source);
			return *this;
		}

		template <class InputIterator>
		path& assign(InputIterator begin, InputIterator end) {
			invalidate();
			_path.assign(begin, end);
			return *this;
		}


		// appends
		path& operator/=(const path& p) {
			return append(p);
		}



		template <class Source>
		path& operator/=(Source const& source) {
			return append(source);
		}



		// consider this a specialization of append.
		path& append(const path &p);

		path& append(const string_type &s);


		template <class Source>
		path& append(Source const& source) {
			return append(path(source));
		}

		template <class InputIterator>
		path& append(InputIterator begin, InputIterator end) {
			return append(path(begin, end));
		}


		// concatenation
		path& operator+=(const path& x) {
			invalidate();
			_path += x._path;
			return *this;
		}

		path& operator+=(const string_type& x) {
			invalidate();
			_path += x;			
			return *this;
		}

		path& operator+=(const value_type* x) {
			invalidate();
			_path += x;
			return *this;
		}

		path& operator+=(value_type x) {
			invalidate();
			_path += x;			
			return *this;
		}

		template <class Source>
		path& operator+=(Source const& x) {
			invalidate();
			_path += x;
			return *this;	
		}

		template <class charT>
		path& operator+=(charT x){
			invalidate();
			_path += x;			
			return *this;
		}

		template <class Source>
		path& concat(Source const& x) {
			invalidate();
			_path += x;
			return *this;
		}

		template <class InputIterator>
		path& concat(InputIterator begin, InputIterator end) {
			invalidate();
			_path.append(begin, end);
			return *this;
		}


		// modifiers
		void  clear() noexcept {
			invalidate();
			_path.clear();
		}

		path& make_preferred() {
			return *this;
		}
		path& remove_filename();
		path& replace_filename(const path& replacement);
		path& replace_extension(/* const path& replacement = path() */);
		path& replace_extension(const path& replacement);

		void  swap(path& rhs) noexcept {
			std::swap(_path, rhs._path);
			std::swap(_info, rhs._info);
		}

		// native format observers
		const string_type& native() const noexcept {
			return _path;
		}

		const value_type* c_str() const noexcept {
			return _path.c_str();
		}

		operator string_type() const {
			return _path;
		}

		template <class charT, class traits = std::char_traits<charT>,
			class Allocator = std::allocator<charT> >
		std::basic_string<charT, traits, Allocator> string(const Allocator& a = Allocator()) const;

		std::string string() const {
			return _path;
		}

		std::wstring wstring() const;
		std::string u8string() const;
		std::u16string u16string() const;
		std::u32string u32string() const;

		// generic format observers
		template <class charT, class traits = std::char_traits<charT>,
			class Allocator = std::allocator<charT> >
			std::basic_string<charT, traits, Allocator>
		generic_string(const Allocator& a = Allocator()) const;
		std::string    generic_string() const {
			return _path;
		}
		std::wstring   generic_wstring() const;
		std::string    generic_u8string() const;
		std::u16string generic_u16string() const;
		std::u32string generic_u32string() const;

		// compare
		int compare(const path& p) const noexcept;
		int compare(const std::string& s) const;
		int compare(const value_type* s) const;

		// decomposition
		path root_name() const;
		path root_directory() const;
		path root_path() const;
		path relative_path() const;
		path parent_path() const;
		path filename() const;
		path stem() const;
		path extension() const;

		// query
		bool empty() const noexcept {
			return _path.empty();
		}

		bool has_root_name() const;
		bool has_root_directory() const;
		bool has_root_path() const;
		bool has_relative_path() const;
		bool has_parent_path() const;
		bool has_filename() const;
		bool has_stem() const;
		bool has_extension() const;

		bool is_absolute() const {
			return !empty() && _path[0] == '/';
		}

		bool is_relative() const {
			return empty() || _path[0] != '/';
		}

		// iterators
		class iterator;
		typedef iterator const_iterator;
		iterator begin() const;
		iterator end() const;

	private:

		void invalidate() const {
			_info.valid = false;
		}

		void study() const;
		path &append_common(const std::string &s);




		string_type _path;

		mutable struct {
			bool valid = false;
			value_type special;
			int stem;
			int extension;
		} _info;

	};


	inline void swap(path& lhs, path& rhs) noexcept {
		lhs.swap(rhs);
	}

/*
	// ugh, this is boost, not stl.
	inline std::size_t hash_value(const path& p) noexcept {
		return std::hash_value(p._path);
	}
*/
	inline bool operator==(const path& lhs, const path& rhs) noexcept {
		return lhs.compare(rhs) == 0;
	}

	inline bool operator!=(const path& lhs, const path& rhs) noexcept {
		return lhs.compare(rhs) != 0;
	}

	inline bool operator< (const path& lhs, const path& rhs) noexcept {
		return lhs.compare(rhs) < 0;
	}
	inline bool operator<=(const path& lhs, const path& rhs) noexcept {
		return lhs.compare(rhs) <= 0;
	}
	inline bool operator> (const path& lhs, const path& rhs) noexcept {
		return lhs.compare(rhs) > 0;		
	}
	inline bool operator>=(const path& lhs, const path& rhs) noexcept {
		return lhs.compare(rhs) >= 0;		
	}
	inline path operator/ (const path& lhs, const path& rhs) {
		path tmp = lhs;
		return tmp.append(rhs);
	}

	//template <class charT, class traits>
	//basic_ostream<charT, traits>&
	//operator<<(basic_ostream<charT, traits>& os, const path& p);
	//template <class charT, class traits>
	//basic_istream<charT, traits>&
	///operator>>(basic_istream<charT, traits>& is, path& p);
	template <class Source>
	 	path u8path(Source const& source);
	template <class InputIterator>
	 	path u8path(InputIterator begin, InputIterator end);


	class filesystem_error : public system_error
	{
		public:
		filesystem_error(const std::string& what_arg, error_code ec) :
			system_error(ec, what_arg)
		{}

		filesystem_error(const std::string& what_arg, const path& p1, error_code ec) : 
			system_error(ec, what_arg), _p1(p1)
		{}

		filesystem_error(const std::string& what_arg, const path& p1, const path& p2, error_code ec) :
			system_error(ec, what_arg), _p1(p1), _p2(p2)
		{}

		const path& path1() const noexcept {
			return _p1;
		}
		const path& path2() const noexcept {
			return _p2;
		}

		//const char* what() const noexcept;

		private:
		path _p1;
		path _p2;
	};



	enum class file_type {

		none = 0,
		not_found = -1,
		regular = 1,
		directory = 2,
		symlink = 3,
		block = 4,
		character = 5,
		fifo = 6,
		socket = 7,
		unknown = 8
	};

	enum perms {

		none = 0,
		owner_read = 0400,
		owner_write = 0200,
		owner_exec = 0100,
		owner_all = 0700,

		group_read = 040,
		group_write = 020,
		group_exec = 010,
		group_all = 070,

		others_read = 04,
		others_write = 02,
		others_exec = 01,
		others_all = 07,

		all = 0777,
		set_uid = 04000,
		set_gid = 02000,
		sticky_bit = 01000,
		mask = 07777,

		unknown = 0xffff,

		add_perms = 0x10000,
		remove_perms = 0x20000,
		resolve_symlinks = 0x40000,

	};


	class file_status
	{
		public:
		// constructors
		explicit file_status(file_type ft = file_type::none, perms prms = perms::unknown) noexcept:
			_ft(ft), _prms(prms) {}

		file_status(const file_status&) noexcept = default;
		file_status(file_status&&) noexcept = default;
		~file_status() = default;

		file_status& operator=(const file_status&) noexcept = default;
		file_status& operator=(file_status&&) noexcept = default;

		// observers
		file_type type() const noexcept {
			return _ft;
		}

		perms permissions() const noexcept {
			return _prms;
		}

		// modifiers
		void type(file_type ft) noexcept {
			_ft = ft;
		}
		void permissions(perms prms) noexcept {
			_prms = prms;
		}

		private:
		file_type _ft = file_type::none;
		perms _prms = perms::unknown;
	};


	struct space_info  // returned by space function
	{
		uintmax_t capacity;
		uintmax_t free;
		uintmax_t available; // free space available to a non-privileged process
	};

	enum class directory_options
	{
		none,
		follow_directory_symlink,
		skip_permission_denied
	};

	//typedef std::chrono::time_point<trivial-clock> file_time_type;
	typedef std::chrono::time_point<std::chrono::system_clock> file_time_type;

	enum class copy_options
	{
		none = 0,
		skip_existing = 1,
		overwrite_existing = 2,
		update_existing = 4,
		recurive = 8,
		copy_symlinks = 16,
		skip_symlinks = 32,
		directories_only = 64,
		create_symlinks = 128,
		create_hard_links = 256
	};

	path current_path();
	path current_path(error_code& ec);
	void current_path(const path& p);
	void current_path(const path& p, error_code& ec) noexcept;

	path absolute(const path& p, const path& base=current_path());

	path canonical(const path& p, const path& base = current_path());
	path canonical(const path& p, error_code& ec);
	path canonical(const path& p, const path& base, error_code& ec);

	void copy(const path& from, const path& to);
	void copy(const path& from, const path& to, error_code& ec) noexcept;
	void copy(const path& from, const path& to, copy_options options);
	void copy(const path& from, const path& to, copy_options options, error_code& ec) noexcept;

	bool copy_file(const path& from, const path& to);
	bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
	bool copy_file(const path& from, const path& to, copy_options option);
	bool copy_file(const path& from, const path& to, copy_options option, error_code& ec) noexcept;
	void copy_symlink(const path& existing_symlink, const path& new_symlink);

	void copy_symlink(const path& existing_symlink, const path& new_symlink, error_code& ec) noexcept;

	bool create_directories(const path& p);
	bool create_directories(const path& p, error_code& ec) noexcept;

	bool create_directory(const path& p);
	bool create_directory(const path& p, error_code& ec) noexcept;
	bool create_directory(const path& p, const path& attributes);
	bool create_directory(const path& p, const path& attributes, error_code& ec) noexcept;

	void create_directory_symlink(const path& to, const path& new_symlink);
	void create_directory_symlink(const path& to, const path& new_symlink, error_code& ec) noexcept;

	void create_hard_link(const path& to, const path& new_hard_link);
	void create_hard_link(const path& to, const path& new_hard_link, error_code& ec) noexcept;

	void create_symlink(const path& to, const path& new_symlink);
	void create_symlink(const path& to, const path& new_symlink, error_code& ec) noexcept;




	file_status status(const path& p);
	file_status status(const path& p, error_code& ec) noexcept;

	file_status symlink_status(const path& p);
	file_status symlink_status(const path& p, error_code& ec) noexcept;

	inline bool status_known(file_status s) noexcept {
		return s.type() != file_type::none;
	}

	inline bool exists(file_status s) noexcept {
		return status_known(s) && s.type() != file_type::not_found;
	}

	inline bool exists(const path& p) {
		return exists(status(p));
	}
	inline bool exists(const path& p, error_code& ec) noexcept {
		return exists(status(p, ec));
	}


	bool         equivalent(const path& p1, const path& p2);
	bool         equivalent(const path& p1, const path& p2, error_code& ec) noexcept;

	uintmax_t    file_size(const path& p);
	uintmax_t    file_size(const path& p, error_code& ec) noexcept;

	uintmax_t    hard_link_count(const path& p);
	uintmax_t    hard_link_count(const path& p, error_code& ec) noexcept;

	inline bool is_block_file(file_status s) noexcept {
		return s.type() == file_type::block;
	}
	inline bool is_block_file(const path& p) {
		return is_block_file(status(p));
	}
	inline bool is_block_file(const path& p, error_code& ec) noexcept {
		return is_block_file(status(p, ec));		
	}

	inline bool is_character_file(file_status s) noexcept {
		return s.type() == file_type::character;
	}
	inline bool is_character_file(const path& p) {
		return is_character_file(status(p));
	}
	inline bool is_character_file(const path& p, error_code& ec) noexcept {
		return is_character_file(status(p, ec));		
	}

	inline bool is_directory(file_status s) noexcept {
		return s.type() == file_type::directory;
	}
	inline bool is_directory(const path& p) {
		return is_directory(status(p));
	}
	inline bool is_directory(const path& p, error_code& ec) noexcept {
		return is_directory(status(p, ec));		
	}

	bool is_empty(const path& p);
	bool is_empty(const path& p, error_code& ec) noexcept;


	inline bool is_fifo(file_status s) noexcept {
		return s.type() == file_type::fifo;
	}
	inline bool is_fifo(const path& p) {
		return is_fifo(status(p));
	}
	inline bool is_fifo(const path& p, error_code& ec) noexcept {
		return is_fifo(status(p, ec));		
	}

	inline bool is_socket(file_status s) noexcept {
		return s.type() == file_type::socket;
	}
	inline bool is_socket(const path& p) {
		return is_socket(status(p));
	}
	inline bool is_socket(const path& p, error_code& ec) noexcept {
		return is_socket(status(p, ec));		
	}


	inline bool is_symlink(file_status s) noexcept {
		return s.type() == file_type::symlink;
	}
	inline bool is_symlink(const path& p) {
		return is_symlink(status(p));
	}
	inline bool is_symlink(const path& p, error_code& ec) noexcept {
		return is_symlink(status(p, ec));		
	}


	inline bool is_regular_file(file_status s) noexcept {
		return s.type() == file_type::regular;
	}

	inline bool is_regular_file(const path& p) {
		return is_regular_file(status(p));
	}

	inline bool is_regular_file(const path& p, error_code& ec) noexcept {
		return is_regular_file(status(p, ec));
	}

	inline bool is_other(file_status s) noexcept {
		return exists(s) && !is_regular_file(s) && ! is_directory(s) && !is_symlink(s);	
	}

	inline bool is_other(const path& p) {
		return is_other(status(p));
	}

	inline bool is_other(const path& p, error_code& ec) noexcept {
		return is_other(status(p, ec));		
	}


	

	file_time_type last_write_time(const path& p);
	file_time_type last_write_time(const path& p, error_code& ec) noexcept;
	void last_write_time(const path& p, file_time_type new_time);
	void last_write_time(const path& p, file_time_type new_time, error_code& ec) noexcept;

	void permissions(const path& p, perms prms);
	void permissions(const path& p, perms prms, error_code& ec) noexcept;

	path read_symlink(const path& p);
	path read_symlink(const path& p, error_code& ec);
	bool remove(const path& p);
	bool remove(const path& p, error_code& ec) noexcept;
	uintmax_t remove_all(const path& p);
	uintmax_t remove_all(const path& p, error_code& ec) noexcept;
	void rename(const path& from, const path& to);
	void rename(const path& from, const path& to, error_code& ec) noexcept;
	void resize_file(const path& p, uintmax_t size);
	void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
	space_info space(const path& p);
	space_info space(const path& p, error_code& ec) noexcept;
	file_status status(const path& p);
	file_status status(const path& p, error_code& ec) noexcept;
	bool status_known(file_status s) noexcept;
	file_status symlink_status(const path& p);
	file_status symlink_status(const path& p, error_code& ec) noexcept;
	path system_complete(const path& p);
	path system_complete(const path& p, error_code& ec);
	path temp_directory_path();
	path temp_directory_path(error_code& ec);




	class directory_entry {

	public:

		// constructors and destructor
		directory_entry() = default;
		directory_entry(const directory_entry&) = default;
		directory_entry(directory_entry&&) noexcept = default;
		explicit directory_entry(const path& p, file_status st=file_status(), file_status symlink_st=file_status());

		~directory_entry() = default;

		// modifiers
		directory_entry& operator=(const directory_entry&) = default;
		directory_entry& operator=(directory_entry&&) noexcept = default;
		void assign(const path& p, file_status st=file_status(),
			file_status symlink_st=file_status());
		void replace_filename(const path& p, file_status st=file_status(),
			file_status symlink_st=file_status());


		// observers
		const filesystem::path&  path() const noexcept {
			return _path;
		}

		file_status  status() const;
		file_status  status(error_code& ec) const noexcept;
		file_status  symlink_status() const;
		file_status  symlink_status(error_code& ec) const noexcept;


		bool operator< (const directory_entry& rhs) const noexcept;
		bool operator==(const directory_entry& rhs) const noexcept;
		bool operator!=(const directory_entry& rhs) const noexcept;
		bool operator<=(const directory_entry& rhs) const noexcept;
		bool operator> (const directory_entry& rhs) const noexcept;
		bool operator>=(const directory_entry& rhs) const noexcept;


	private:
		class path _path;
		mutable file_status _st;
		mutable file_status _lst;
	};


	class directory_iterator : public std::iterator<std::input_iterator_tag, directory_entry>
	{
	public:
		// member functions
		directory_iterator() noexcept = default;
		explicit directory_iterator(const path& p);
		directory_iterator(const path& p, error_code& ec) noexcept;

		directory_iterator(const directory_iterator&) = default;

		directory_iterator(directory_iterator&&) = default;
		~directory_iterator() = default;

		directory_iterator& operator=(const directory_iterator&) = default;
		directory_iterator& operator=(directory_iterator&&) = default;

		const directory_entry& operator*() const {
			return _imp->_entry;
		}
		const directory_entry* operator->() const {
			return &_imp->_entry;
		}
		directory_iterator& operator++();
		directory_iterator& increment(error_code& ec) noexcept;

		bool operator == (const directory_iterator &rhs) const noexcept {
			return _imp == rhs._imp;
		}
		bool operator != (const directory_iterator &rhs) const noexcept {
			return _imp != rhs._imp;
		}

		// other members as required by
		//  C++ Std, 24.1.1 Input iterators [input.iterators]



	private:

		void open_dir(const path &p, error_code &ec) noexcept;

		struct imp {
			path _path;
			directory_entry _entry;
			DIR *_dp = nullptr;

			imp() = default;
			imp(const path &p, DIR *dp) : _path(p), _dp(dp)
			{}

			~imp() {
				if (_dp) closedir(_dp);
			}
		};

		std::shared_ptr<imp> _imp;
	};


	/*
	 directory_iterator non-member functions
	*/
	inline const directory_iterator& begin(const directory_iterator& iter) noexcept {
		return iter;
	}

	inline directory_iterator end(const directory_iterator&) noexcept {
		return directory_iterator();
	}


}


namespace std
{

	inline void swap(filesystem::path& lhs, filesystem::path& rhs) noexcept {
		lhs.swap(rhs);
	}

	template<>
	struct hash<filesystem::path>
	{
		std::size_t operator()(const filesystem::path &p) const
		{
			std::hash<filesystem::path::string_type> hasher;
			return hasher(p.native());
		}
	};
}
 

#endif