#include <libexplain/creat.h>
#include <libexplain/stat.h>
#include <libexplain/mkdir.h>
#include <libexplain/write.h>
#include <libexplain/unlink.h>
#include <libexplain/rename.h>
#include <libexplain/open.h>
#include <assert.h>
#include <sys/stat.h>

#include "../shared/MiscSupport.h"

#include "Explain.h"


namespace Explain
{

  std::string explainCreat(std::string const &fileName, int permissions)
  {
    char message[3000];
    // I'm not sure if this stuff about the trailing 0 is really required.
    // It is with some other system calls and standard libraries.
    message[sizeof(message)-1] = 0;
    explain_message_creat(message, sizeof(message)-1, fileName.c_str(),
                          permissions);
    // If we returned the empty string that could cause some confusion.
    // In particular, many places we return "" on success, an error message
    // on failure.
    assert(message[0]);
    return message;
  }

  std::string explainMkdir(std::string const &pathname, mode_t mode)
  {
    char message[3000];
    explain_message_mkdir(message, sizeof(message)-1, pathname.c_str(), mode);
    assert(message[0]);
    return message;
  }

  std::string explainWrite(int fildes, const void *data, long data_size)
  {
    char message[3000];
    explain_message_write(message, sizeof(message), fildes, data, data_size);
    assert(message[0]);
    return message;
  }

  std::string explainUnlink(char const *fileName)
  {
    char message[3000];
    explain_message_unlink(message, sizeof(message), fileName);
    assert(message[0]);
    return message;
  }

  std::string explainRename(char const *oldpath, char const *newpath)
  {
    char message[3000];
    explain_message_rename(message, sizeof(message), oldpath, newpath);
    assert(message[0]);
    return message;
  }

  std::string explainOpen(const  char  *pathname, int flags, int mode)
  {
    char message[3000];
    explain_message_open(message, sizeof(message), pathname, flags, mode);
    assert(message[0]);
    return message;
  }

  std::string explainStat(const char *pathname, struct stat *buf)
  {
    char message[3000];
    explain_message_stat(message, sizeof(message), pathname, buf);
    assert(message[0]);
    return message;
  }

  std::string dumpProtectionAndMode(mode_t mode)
  {
    TclList result;
    if (S_ISDIR(mode))
      result<<"DIR";
    if (S_ISCHR(mode))
      result<<"CHR";
    if (S_ISBLK(mode))
      result<<"BLK";
    if (S_ISREG(mode))
      result<<"REG";
    if (S_ISFIFO(mode))
      result<<"FIFO";
    if (S_ISLNK(mode))
      result<<"LNK";
    if (S_ISSOCK(mode))
      result<<"SOCK";
    if (mode & S_ISUID)
      result<<"set-user-ID";
    if (mode & S_ISGID)
      result<<"set-group-ID";
    if (mode & S_ISVTX)
      result<<"sticky";
    char buffer[30];
    sprintf(buffer, "%#o", mode);
    result<<buffer;
    // Note that the permission bits (owner read, world write, etc.) are only
    // visible in the octal notation.  That's what I'm used to so it works.
    //
    // It would be tempting to treat set-user-ID, set-group-ID, and sticky the
    // same way, as they could all be used as an input to the chmod command. 
    // But I don't remember those numeric codes.
    //
    // There may be other types of special files not listed here.  See
    // https://www.gnu.org/software/libc/manual/html_node/Testing-File-Type.html#Testing-File-Type
    // for a few more possibilities.
    return result;
  }

  std::string dumpStat(struct stat const &fileStatus)
  {
    TclList msg;
    msg<<TclList("st_dev", fileStatus.st_dev, "ID of device containing file");
    msg<<TclList("st_ino", fileStatus.st_ino, "inode number");
    msg<<TclList("st_mode", dumpProtectionAndMode(fileStatus.st_mode),
                 "protection");
    msg<<TclList("st_nlink", fileStatus.st_nlink, "number of hard links");
    msg<<TclList("st_uid", fileStatus.st_uid, "user ID of owner");
    msg<<TclList("st_gid", fileStatus.st_gid, "group ID of owner");
    msg<<TclList("st_rdev", fileStatus.st_rdev, "device ID (if special file)");
    msg<<TclList("st_size", fileStatus.st_size, "total size, in bytes");
    msg<<TclList("st_blksize", fileStatus.st_blksize,
                 "blocksize for filesystem I/O");
    msg<<TclList("st_blocks", fileStatus.st_blocks,
                 "number of 512B blocks allocated");
    msg<<TclList("st_atim", fileStatus.st_atim, "time of last access");
    msg<<TclList("st_mtim", fileStatus.st_mtim, "time of last modification");
    msg<<TclList("st_ctim", fileStatus.st_ctim, "time of last status change");
    return msg;
  }

}