#ifndef NETFS_FUSE_H
#define NETFS_FUSE_H

#include <shared_mutex>
#include <functional>
#include <boost/filesystem/path.hpp>
#include <Ice/Ice.h>
#include <Glacier2/Session.h>
#include <service.h>
#include <entCache.h>
#include <typeConverter.h>
#include "fuseAppBase.h"
#include "fuseConfig.h"
#include "cache.h"
#include <visibility.h>
#include <boost/icl/interval_map.hpp>

namespace NetFS {
	class DLL_PUBLIC FuseApp : public FuseAppBase {
		private:
			class OpenDir {
				public:
					OpenDir(DirectoryPrxPtr remote, const std::string & path);

					DirectoryPrxPtr remote;
					DirectoryV2PrxPtr remoteV2;
					const std::string path;
			};
			typedef std::shared_ptr<OpenDir> OpenDirPtr;
			typedef std::map<int, OpenDirPtr> OpenDirs;

			class OpenFile {
				public:
					OpenFile(FilePrxPtr remote, const std::string & path, int flags);

					void flush();
					void wait() const;

					FilePrxPtr remote;
					const std::string path;
					const int flags;
					class WriteState;
					typedef boost::icl::interval_map<Ice::Long, std::shared_ptr<WriteState>> BGs;
					static BGs::interval_type range(off_t, size_t);
					BGs bg;
					mutable std::shared_mutex _lock;
			};
			typedef std::shared_ptr<OpenFile> OpenFilePtr;
			typedef std::map<int, OpenFilePtr> OpenFiles;

		public:
			FuseApp(const Ice::StringSeq &);
			~FuseApp();

		private:
			void * init (struct fuse_conn_info * info) override;
			int opt_parse(void *, const char * arg, int key, struct fuse_args *) override;

			void connectSession();
			void connectToService();
			void connectToVolume();
			void connectHandles();
			void verifyConnection();

		public:
			// misc
			int access(const char * p, int a) override;
			int getattr(const char * p, struct stat * s) override;
			int fgetattr(const char *, struct stat *, struct fuse_file_info *) override;
			int chmod(const char *, mode_t) override;
			int chown(const char *, uid_t, gid_t) override;
			int link(const char *, const char *) override;
			int readlink(const char *, char *, size_t) override;
			int rename(const char *, const char *) override;
			int symlink(const char *, const char *) override;
			int unlink(const char *) override;
			int utimens(const char *, const struct timespec tv[2]) override;
			int mknod(const char *, mode_t, dev_t) override;
			// dirs
			int opendir(const char * p, struct fuse_file_info * fi) override;
			int releasedir(const char *, struct fuse_file_info * fi) override;
			int readdir(const char *, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi) override;
			int mkdir(const char *, mode_t) override;
			int rmdir(const char *) override;
			// files
			int open(const char * p, struct fuse_file_info * fi) override;
			int create(const char *, mode_t, struct fuse_file_info *) override;
			int flush(const char *, struct fuse_file_info * fi) override;
			int release(const char *, struct fuse_file_info * fi) override;
			int read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi) override;
			int write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi) override;
			int truncate(const char *, off_t) override;
			int ftruncate(const char *, off_t, struct fuse_file_info *) override;
			// fs
			int statfs(const char *, struct statvfs *) override;
			// stuff
			int onError(const std::exception & err) throw() override;
			void beforeOperation() override;

			virtual struct fuse_context * fuse_get_context() = 0;

		protected:
			typedef std::function<Client::ResourcePtr()> Configurator;
			Configurator configurator;
			virtual NetFS::Client::ConfigurationPtr ReadConfiguration(const boost::filesystem::path &) const;
			virtual NetFS::Client::ResourcePtr configureFromFile(const std::string &, const std::string &) const;
			virtual NetFS::Client::ResourcePtr configureFromUri(const std::string &) const;

		private:
			template<typename Handle, typename ... Params>
			void setProxy(uint64_t & fh, const Params & ...);
			template<typename Handle>
			Handle getProxy(uint64_t localID);
			template<typename Handle>
			void clearProxy(uint64_t localID);
			template<typename Handle>
			std::map<int, Handle> & getMap();

			template<typename Rtn, typename F> static inline Rtn
				waitOnWriteRangeAndThen(size_t s, off_t o, const OpenFilePtr & of, const F & f);

			ReqEnv reqEnv();

			Ice::StringSeq iceArgs;
			Ice::CommunicatorPtr ic;
			Client::ResourcePtr fcr;
			mutable std::shared_mutex _proxymaplock;

			NetFS::VolumePrxPtr volume;
			NetFS::ServicePrxPtr service;
			Glacier2::SessionPrxPtr session;
			bool sessionOpened;

			std::string mountPoint;

			OpenDirs openDirs;
			OpenFiles openFiles;
			int openHandleId;

			EntCache<User> userLookup;
			EntCache<Group> groupLookup;
			EntryTypeConverter converter;

			typedef AdHoc::Cache<struct stat, std::string> StatCache;
			StatCache statCache;
	};
}

#endif