#ifndef GASPARDOS_FILE_EXPLORER_HPP
#define GASPARDOS_FILE_EXPLORER_HPP
#include <stdint.h>
#include <map>
#include <set>
#include <string>
#include <vector>

namespace gaspardos
{
    namespace desktop
    {
        std::string normalize(const std::string& path);
        std::string parentPath(const std::string& path);
        std::string fileName(const std::string& path);
        std::string join(const std::string& folder, const std::string& name);
        bool        validName(const std::string& name);
        bool        toWide(const std::string& utf8, std::wstring& out);
        bool        validUtf8(const std::string& text);
        std::string fromUtf16(const uint16_t* text, unsigned length);
        std::string utf8(uint32_t code);
        std::size_t previousChar(const std::string& text, std::size_t pos);
        std::size_t nextChar(const std::string& text, std::size_t pos);

        struct FileEntry
        {
            std::string name, path;
            bool        directory;
            uint64_t    bytes;

            FileEntry() : directory(false), bytes(0)
            {
            }
        };

        class FileAccess
        {
        public:
            virtual ~FileAccess()
            {
            }

            virtual std::vector<FileEntry> roots()                                              = 0;
            virtual int64_t                stat(const std::string& path, FileEntry& entry)      = 0;
            virtual int64_t                openDirectory(const std::string& path)               = 0;
            virtual int64_t                next(int64_t handle, FileEntry& entry)               = 0;
            virtual int64_t                close(int64_t handle)                                = 0;
            virtual int64_t                mkdir(const std::string& path)                       = 0;
            virtual int64_t read(const std::string& path, std::string& data, std::size_t limit) = 0;
            // create must use exclusive creation and never change a preexisting file.
            virtual int64_t create(const std::string& path, const std::string& data) = 0;
            virtual int64_t rename(const std::string& from, const std::string& to)   = 0;
            virtual int64_t remove(const std::string& path)                          = 0;
        };

        class DirectoryListing
        {
            FileAccess& access_;
            int64_t     handle_;
            std::string path_;
            std::size_t memory_;
            unsigned    idle_;
            bool        closing_;
            DirectoryListing(const DirectoryListing&);
            DirectoryListing& operator=(const DirectoryListing&);

        public:
            std::vector<FileEntry> entries;
            bool                   loading;
            int64_t                error;
            explicit DirectoryListing(FileAccess& access);
            ~DirectoryListing();
            bool begin(const std::string& path);
            bool tick();
            void cancel();
        };

        class FileExplorer
        {
        public:
            enum Mode
            {
                OpenFile,
                SaveFile,
                SelectFolder
            };

        private:
            FileAccess&      access_;
            DirectoryListing listing_;
            Mode             mode_;
            bool             overwrite_, confirmation_, finished_, accepted_;
            int              selected_;
            std::string      directory_, result_, confirmationPath_;
            FileExplorer(const FileExplorer&);
            FileExplorer& operator=(const FileExplorer&);

        public:
            std::vector<FileEntry> volumes;
            std::string            message;
            explicit FileExplorer(FileAccess& access);
            void begin(Mode mode, const std::string& initial, bool overwrite = false);
            bool navigate(const std::string& directory);
            bool tick();
            void select(int index);
            void activate(int index);
            bool accept(const std::string& name);
            bool createFolder(const std::string& name);
            void cancel();

            const std::vector<FileEntry>& entries() const
            {
                return listing_.entries;
            }

            const std::string& directory() const
            {
                return directory_;
            }

            const std::string& result() const
            {
                return result_;
            }

            bool loading() const
            {
                return listing_.loading;
            }

            bool finished() const
            {
                return finished_;
            }

            bool accepted() const
            {
                return accepted_;
            }

            bool confirming() const
            {
                return confirmation_;
            }

            int selected() const
            {
                return selected_;
            }

            Mode mode() const
            {
                return mode_;
            }
        };

        struct TreeRow
        {
            FileEntry entry;
            unsigned  depth;
            bool      expanded;
        };

        class DirectoryTree
        {
            FileAccess&                                    access_;
            DirectoryListing                               listing_;
            std::string                                    root_, loadingPath_;
            std::map<std::string, std::vector<FileEntry> > children_;
            std::set<std::string>                          expanded_;
            void append(const FileEntry& entry, unsigned depth);
            void rebuild();
            DirectoryTree(const DirectoryTree&);
            DirectoryTree& operator=(const DirectoryTree&);

        public:
            std::vector<TreeRow> rows;
            std::string          message;
            explicit DirectoryTree(FileAccess& access);
            bool open(const std::string& root);
            void toggle(std::size_t index);
            bool tick();

            const std::string& root() const
            {
                return root_;
            }

            bool loading() const
            {
                return listing_.loading;
            }
        };

        // Transactional save: exclusive .gaspardedit.tmp / .gaspardedit.bak siblings.
        // A failed commit attempts rollback; retained artifacts are reported in message.
        bool saveFile(FileAccess&        access,
                      const std::string& path,
                      const std::string& data,
                      bool               overwrite,
                      std::string&       message);
    }  // namespace desktop
}  // namespace gaspardos
#endif
