/*
 * libfud
 * Copyright 2024 Dominick Allen
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef FUD_DIRECTORY_HPP
#define FUD_DIRECTORY_HPP

#include "fud_result.hpp"
#include "fud_status.hpp"
#include "fud_string.hpp"
#include "fud_option.hpp"

#include <cstdint>
#include <cstdio>
#include <ctime>
#include <dirent.h>

namespace fud {

enum class DirectoryEntryType : uint8_t
{
    Block,
    Character,
    Directory,
    NamedPipe,
    SymbolicLink,
    RegularFile,
    UnixSocket,
    Unknown
};

constexpr const char* DirectoryEntryTypeToString(DirectoryEntryType entryType)
{
    switch (entryType) {
    case DirectoryEntryType::Block:
        return "Block";
    case DirectoryEntryType::Character:
        return "Character";
    case DirectoryEntryType::Directory:
        return "Directory";
    case DirectoryEntryType::NamedPipe:
        return "Named Pipe";
    case DirectoryEntryType::SymbolicLink:
        return "Symbolic Link";
    case DirectoryEntryType::RegularFile:
        return "Regular File";
    case DirectoryEntryType::UnixSocket:
        return "Unix Socket";
    case DirectoryEntryType::Unknown:
    default:
        return "Unknown";
    }
}

struct Stat;

/** \brief Simplified Directory Entry */
struct DirectoryEntry {
    String name;
    size_t inode;
    size_t size;
    size_t links;
    time_t modificationTime;
    DirectoryEntryType entryType;

    static Result<DirectoryEntry, FudStatus> fromStat(const String& name, const Stat& statBuffer);

    [[nodiscard]] constexpr bool isDirectory() const
    {
        return entryType == DirectoryEntryType::Directory;
    }

    [[nodiscard]] constexpr bool isRegularFile() const
    {
        return entryType == DirectoryEntryType::RegularFile;
    }
};

class Directory {
  public:
    // explicit Directory(const String& name);
    static Result<Directory, FudStatus> make(const String& name);
    Directory(const Directory& rhs) = delete;
    Directory(Directory&& rhs) noexcept;
    ~Directory();
    Directory& operator=(const Directory& rhs) = delete;
    Directory& operator=(Directory&& rhs) noexcept = delete;

    constexpr const String& name() const {
        return m_name;
    }

    constexpr int errorCode() const
    {
        return m_errorCode;
    }

    Result<DirectoryEntry, FudStatus> info();

    Result<Option<DirectoryEntry>, FudStatus> getNextEntry();

    FudStatus reset();

  private:
    Directory() = default;

    String m_name{};
    DIR* m_directory{nullptr};
    int m_errorCode{-1};
    int m_dirFd{-1};
};

} // namespace fud

#endif