#pragma once
#include "fs/VFS.h"
#include <luna/Atomic.h>
#include <luna/Badge.h>
#include <luna/Buffer.h>
#include <luna/StaticString.h>
#include <luna/Vector.h>

namespace TmpFS
{
    class FileSystem : public VFS::FileSystem
    {
      public:
        SharedPtr<VFS::Inode> root_inode() const override
        {
            return m_root_inode;
        }

        Result<SharedPtr<VFS::Inode>> create_file_inode() override;
        Result<SharedPtr<VFS::Inode>> create_dir_inode(SharedPtr<VFS::Inode> parent) override;

        static Result<SharedPtr<VFS::FileSystem>> create();

        virtual ~FileSystem() = default;

      private:
        FileSystem() = default;

        void set_root(SharedPtr<VFS::Inode> root);

        SharedPtr<VFS::Inode> m_root_inode;
        Vector<SharedPtr<VFS::Inode>> m_inodes;

        Atomic<usize> m_next_inode_number { 2 };
    };

    class FileInode : public VFS::FileInode
    {
      public:
        FileInode() = default;

        void set_fs(FileSystem& fs, Badge<FileSystem>)
        {
            m_fs = &fs;
        }

        void set_inode_number(usize inum, Badge<FileSystem>)
        {
            m_inode_number = inum;
        }

        VFS::FileSystem& fs() const override
        {
            return *m_fs;
        }

        usize inode_number() const override
        {
            return m_inode_number;
        }

        Result<usize> read(u8*, usize, usize) const override;

        Result<usize> write(const u8*, usize, usize) override;

        Result<void> truncate(usize size) override;

        virtual ~FileInode() = default;

      private:
        VFS::FileSystem* m_fs;
        Buffer m_data_buffer;
        usize m_inode_number;
    };

    class DirInode : public VFS::Inode
    {
      public:
        DirInode() = default;

        void set_fs(FileSystem& fs, Badge<FileSystem>)
        {
            m_fs = &fs;
        }

        void set_inode_number(usize inum, Badge<FileSystem>)
        {
            m_inode_number = inum;
        }

        void set_self(SharedPtr<VFS::Inode> self, Badge<FileSystem>)
        {
            m_self = self;
        }

        Result<SharedPtr<VFS::Inode>> find(const char* name) const override;

        Result<usize> read(u8*, usize, usize) const override
        {
            return err(EISDIR);
        }

        Result<usize> write(const u8*, usize, usize) override
        {
            return err(EISDIR);
        }

        Result<void> truncate(usize) override
        {
            return err(EISDIR);
        }

        VFS::FileSystem& fs() const override
        {
            return *m_fs;
        }

        usize inode_number() const override
        {
            return m_inode_number;
        }

        VFS::InodeType type() const override
        {
            return VFS::InodeType::Directory;
        }

        Result<SharedPtr<VFS::Inode>> create_file(const char* name) override;
        Result<SharedPtr<VFS::Inode>> create_subdirectory(const char* name) override;

        Result<void> add_entry(SharedPtr<VFS::Inode> inode, const char* name);

        virtual ~DirInode() = default;

      private:
        VFS::FileSystem* m_fs;
        usize m_inode_number;

        SharedPtr<VFS::Inode> m_self;

        struct Entry
        {
            SharedPtr<VFS::Inode> inode;
            StaticString<128> name;
        };

        Vector<Entry> m_entries;
    };
}