#pragma once

#if !defined(MIJIN_VIRTUAL_FILESYSTEM_RELATIVE_HPP_INCLUDED)
#define MIJIN_VIRTUAL_FILESYSTEM_RELATIVE_HPP_INCLUDED 1

#include "./filesystem.hpp"
#include "../internal/common.hpp"

namespace mijin
{

//
// public defines
//

//
// public constants
//

//
// public types
//

template<typename TWrapped>
class RelativeFileSystemAdapter : public FileSystemAdapter
{
private:
    TWrapped wrapped_;
    fs::path root_;
public:
    template<typename... TArgs>
    explicit RelativeFileSystemAdapter(fs::path root, TArgs&&... args)
        : wrapped_(std::forward<TArgs>(args)...), root_(std::move(root)) {}
    RelativeFileSystemAdapter(const RelativeFileSystemAdapter&) = default;
    RelativeFileSystemAdapter(RelativeFileSystemAdapter&&) MIJIN_NOEXCEPT = default;

    RelativeFileSystemAdapter& operator=(const RelativeFileSystemAdapter&) = default;
    RelativeFileSystemAdapter& operator=(RelativeFileSystemAdapter&&) MIJIN_NOEXCEPT = default;

    fs::path getHomeFolder() override;
    std::vector<FileInfo> listFiles(const fs::path& folder) override;
    FileInfo getFileInfo(const fs::path& file) override;
    Optional<fs::path> getNativePath(const fs::path& file) override;
    StreamError open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
private:
    fs::path appendPath(const fs::path& other) const MIJIN_NOEXCEPT;
};

//
// public functions
//

template<typename TWrapped>
fs::path RelativeFileSystemAdapter<TWrapped>::getHomeFolder()
{
    return root_;
}

template<typename TWrapped>
std::vector<FileInfo> RelativeFileSystemAdapter<TWrapped>::listFiles(const fs::path& folder)
{
    std::vector<FileInfo> result;

    result = wrapped_.listFiles(appendPath(folder));
    for (FileInfo& fileInfo : result) {
        fileInfo.path = "/" / fileInfo.path.lexically_relative(root_);
    }
    return result;
}

template<typename TWrapped>
FileInfo RelativeFileSystemAdapter<TWrapped>::getFileInfo(const fs::path& file)
{
    return wrapped_.getFileInfo(appendPath(file));
}

template<typename TWrapped>
Optional<fs::path> RelativeFileSystemAdapter<TWrapped>::getNativePath(const fs::path& file)
{
    return wrapped_.getNativePath(appendPath(file));
}

template<typename TWrapped>
StreamError RelativeFileSystemAdapter<TWrapped>::open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
{
    return wrapped_.open(appendPath(path), mode, outStream);
}

template<typename TWrapped>
fs::path RelativeFileSystemAdapter<TWrapped>::appendPath(const fs::path& other) const MIJIN_NOEXCEPT
{
    fs::path combinedPath = root_;
    if (other.is_absolute()) {
        combinedPath += other;
    }
    else {
        combinedPath /= other;
    }
    return combinedPath.lexically_normal();
}

namespace vfs_pipe
{
template<typename TBase>
struct RelativeBuilder : Builder<RelativeBuilder<TBase>, RelativeFileSystemAdapter<typename TBase::adapter_t>>
{
    fs::path root;
    TBase base;

    std::unique_ptr<RelativeFileSystemAdapter<typename TBase::adapter_t>> build()
    {
        return std::make_unique<RelativeFileSystemAdapter<typename TBase::adapter_t>>(root, std::move(*base.build()));
    }
};

struct RelativeOptions
{
    fs::path root;
};

[[nodiscard]]
inline RelativeOptions relative_to(fs::path root) noexcept
{
    return {.root = std::move(root) };
}

template<typename TBase>
[[nodiscard]]
RelativeBuilder<TBase> operator|(TBase other, RelativeOptions options) noexcept
{
    return {.root = std::move(options.root), .base = std::move(other) };
}
}
} // namespace mijin

#endif // !defined(MIJIN_VIRTUAL_FILESYSTEM_RELATIVE_HPP_INCLUDED)