--[[
 POSIX library for Lua 5.1, 5.2 & 5.3.
 (c) Gary V. Vaughan <gary@vaughan.pe>, 2014-2015
]]
--[[--
 Legacy Lua POSIX bindings.

 APIs for maintaining compatibility with previous releases.

 @module posix
]]

local _argcheck = require "posix._argcheck"
local bit       = require "bit32"

local argerror, argtypeerror, badoption =
  _argcheck.argerror, _argcheck.argtypeerror, _argcheck.badoption
local band, bnot, bor = bit.band, bit.bnot, bit.bor
local checkint, checkselection, checkstring, checktable =
  _argcheck.checkint, _argcheck.checkselection, _argcheck.checkstring, _argcheck.checktable
local optint, optstring, opttable =
  _argcheck.optint, _argcheck.optstring, _argcheck.opttable
local toomanyargerror = _argcheck.toomanyargerror


local st = require "posix.sys.stat"

local S_IRUSR, S_IWUSR, S_IXUSR = st.S_IRUSR, st.S_IWUSR, st.S_IXUSR
local S_IRGRP, S_IWGRP, S_IXGRP = st.S_IRGRP, st.S_IWGRP, st.S_IXGRP
local S_IROTH, S_IWOTH, S_IXOTH = st.S_IROTH, st.S_IWOTH, st.S_IXOTH
local S_ISUID, S_ISGID, S_IRWXU, S_IRWXG, S_IRWXO =
  st.S_ISUID, st.S_ISGID, st.S_IRWXU, st.S_IRWXG, st.S_IRWXO

local mode_map = {
  { c = "r", b = S_IRUSR }, { c = "w", b = S_IWUSR }, { c = "x", b = S_IXUSR },
  { c = "r", b = S_IRGRP }, { c = "w", b = S_IWGRP }, { c = "x", b = S_IXGRP },
  { c = "r", b = S_IROTH }, { c = "w", b = S_IWOTH }, { c = "x", b = S_IXOTH },
}

local function pushmode (mode)
  local m = {}
  for i = 1, 9 do
    if band (mode, mode_map[i].b) ~= 0 then m[i] = mode_map[i].c else m[i] = "-" end
  end
  if band (mode, S_ISUID) ~= 0 then
    if band (mode, S_IXUSR) ~= 0 then m[3] = "s" else m[3] = "S" end
  end
  if band (mode, S_ISGID) ~= 0 then
    if band (mode, S_IXGRP) ~= 0 then m[6] = "s" else m[6] = "S" end
  end
  return table.concat (m)
end

local function rwxrwxrwx (modestr)
  local mode = 0
  for i = 1, 9 do
    if modestr:sub (i, i) == mode_map[i].c then
      mode = bor (mode, mode_map[i].b)
    elseif modestr:sub (i, i) == "s" then
      if i == 3 then
        mode = bor (mode, S_ISUID, S_IXUSR)
      elseif i == 6 then
        mode = bor (mode, S_ISGID, S_IXGRP)
      else
	return nil  -- bad mode
      end
    end
  end
  return mode
end

local function octal_mode (modestr)
  local mode = 0
  for i = 1, #modestr do
    mode = mode * 8 + tonumber (modestr:sub (i, i))
  end
  return mode
end

local function mode_munch (mode, modestr)
  if #modestr == 9 and modestr:match "^[-rswx]+$" then
    return rwxrwxrwx (modestr)
  elseif modestr:match "^[0-7]+$" then
    return octal_mode (modestr)
  elseif modestr:match "^[ugoa]+%s*[-+=]%s*[rswx]+,*" then
    modestr:gsub ("%s*(%a+)%s*(.)%s*(%a+),*", function (who, op, what)
      local bits, bobs = 0, 0
      if who:match "[ua]" then bits = bor (bits, S_ISUID, S_IRWXU) end
      if who:match "[ga]" then bits = bor (bits, S_ISGID, S_IRWXG) end
      if who:match "[oa]" then bits = bor (bits, S_IRWXO) end
      if what:match "r" then bobs = bor (bobs, S_IRUSR, S_IRGRP, S_IROTH) end
      if what:match "w" then bobs = bor (bobs, S_IWUSR, S_IWGRP, S_IWOTH) end
      if what:match "x" then bobs = bor (bobs, S_IXUSR, S_IXGRP, S_IXOTH) end
      if what:match "s" then bobs = bor (bobs, S_ISUID, S_ISGID) end
      if op == "+" then
	-- mode |= bits & bobs
	mode = bor (mode, band (bits, bobs))
      elseif op == "-" then
	-- mode &= ~(bits & bobs)
	mode = band (mode, bnot (band (bits, bobs)))
      elseif op == "=" then
	-- mode = (mode & ~bits) | (bits & bobs)
	mode = bor (band (mode, bnot (bits)), band (bits, bobs))
      end
    end)
    return mode
  else
    return nil, "bad mode"
  end
end

local M = {
  argerror        = argerror,
  argtypeerror    = argtypeerror,
  badoption       = badoption,
  checkstring     = checkstring,
  checktable      = checktable,
  optstring       = optstring,
  toomanyargerror = toomanyargerror,
}



--- Change the mode of the path.
-- @function chmod
-- @string path existing file path
-- @string mode one of the following formats:
--
--   * "rwxrwxrwx" (e.g. "rw-rw-r--")
--   * "ugo+-=rwx" (e.g. "u+w")
--   * +-=rwx" (e.g. "+w")
--
-- @return[1] int `0`, if successful
-- @return[2] nil
-- @treturn[2] string error message
-- @treturn[2] int errnum
-- @see chmod(2)
-- @usage P.chmod ('bin/dof', '+x')

local bit   = require "bit32"
local st    = require "posix.sys.stat"

local _chmod, stat = st.chmod, st.stat
local RWXALL = bit.bor (st.S_IRWXU, st.S_IRWXG, st.S_IRWXO)

local function chmod (path, modestr)
  local mode = (stat (path) or {}).st_mode
  local bits, err = mode_munch (mode or 0, modestr)
  if bits == nil then
    argerror ("chmod", 2, err, 2)
  end
  return _chmod (path, band (bits, RWXALL))
end

if _DEBUG ~= false then
  M.chmod = function (...)
    local argt = {...}
    checkstring ("chmod", 1, argt[1])
    checkstring ("chmod", 2, argt[2])
    if #argt > 2 then toomanyargerror ("chmod", 2, #argt) end
    return chmod (...)
  end
else
  M.chmod = chmod
end


--- Create a file.
-- This function is obsoleted by @{posix.fcntl.open} with `posix.O_CREAT`.
-- @function creat
-- @string path name of file to create
-- @string mode permissions with which to create file
-- @treturn[1] int file descriptor of file at *path*, if successful
-- @return[2] nil
-- @treturn[2] string error message
-- @treturn[2] int errnum
-- @see creat(2)
-- @see posix.chmod
-- @usage
--   fd = P.creat ("data", "rw-r-----")

local bit   = require "bit32"
local fcntl = require "posix.fcntl"
local st    = require "posix.sys.stat"

local band, bor   = bit.band, bit.bor
local creat_flags = bor (fcntl.O_CREAT, fcntl.O_WRONLY, fcntl.O_TRUNC)
local RWXALL      = bor (st.S_IRWXU, st.S_IRWXG, st.S_IRWXO)

local open = fcntl.open

local function creat (path, modestr)
  local mode, err = mode_munch (0, modestr)
  if mode == nil then
    argerror ("creat", 2, err, 2)
  end
  return open (path, creat_flags, band (mode, RWXALL))
end

if _DEBUG ~= false then
  M.creat = function (...)
    local argt = {...}
    checkstring ("creat", 1, argt[1])
    checkstring ("creat", 2, argt[2])
    if #argt > 2 then toomanyargerror ("creat", 2, #argt) end
    return creat (...)
  end
else
  M.creat = creat
end


--- Make a directory.
-- @function mkdir
-- @string path location in file system to create directory
-- @treturn[1] int `0`, if successful
-- @return[2] nil
-- @treturn[2] string error message
-- @treturn[2] int errnum

local bit = require "bit32"
local st  = require "posix.sys.stat"

local _mkdir = st.mkdir
local RWXALL = bit.bor (st.S_IRWXU, st.S_IRWXG, st.S_IRWXO)

local function mkdir (path)
  return _mkdir (path, RWXALL)
end

if _DEBUG ~= false then
  M.mkdir = function (...)
    local argt = {...}
    checkstring ("mkdir", 1, argt[1])
    if #argt > 1 then toomanyargerror ("mkdir", 1, #argt) end
    return mkdir (...)
  end
else
  M.mkdir = mkdir
end


--- Make a FIFO pipe.
-- @function mkfifo
-- @string path location in file system to create fifo
-- @treturn[1] int `0`, if successful
-- @return[2] nil
-- @treturn[2] string error message
-- @treturn[2] int errnum

local bit = require "bit32"
local st  = require "posix.sys.stat"

local _mkfifo = st.mkfifo
local RWXALL  = bit.bor (st.S_IRWXU, st.S_IRWXG, st.S_IRWXO)

local function mkfifo (path)
  return _mkfifo (path, RWXALL)
end

if _DEBUG ~= false then
  M.mkfifo = function (...)
    local argt = {...}
    checkstring ("mkfifo", 1, argt[1])
    if #argt > 1 then toomanyargerror ("mkfifo", 1, #argt) end
    return mkfifo (...)
  end
else
  M.mkfifo = mkfifo
end


--- Get a message queue identifier
-- @function msgget
-- @int key message queue id, or `IPC_PRIVATE` for a new queue
-- @int[opt=0] flags bitwise OR of zero or more from `IPC_CREAT` and `IPC_EXCL`
-- @string[opt="rw-rw-rw-"] mode execute bits are ignored
-- @treturn[1] int message queue identifier, if successful
-- @return[2] nil
-- @treturn[2] string error message
-- @treturn[2] int errnum
-- @see msgget(2)

local bit   = require "bit32"
local msg   = require "posix.sys.msg"
local st    = require "posix.sys.stat"

local _msgget   = msg.msgget
local band, bor = bit.band, bit.bor
local RWXALL    = bor (st.S_IRWXU, st.S_IRWXG, st.S_IRWXO)

local function msgget (key, msgflg, modestr)
  local mode, err = mode_munch (0, modestr)
  if mode == nil then
    argerror ("open", 3, err, 2)
  end
  return _msgget (key, bor (msgflg, band (mode, RWXALL)))
end

if not _msgget then
  -- Not supported by underlying system
elseif _DEBUG ~= false then
  M.msgget = function (...)
    local argt = {...}
    checkint ("msgget", 1, argt[1])
    if argt[2] ~= nil and type (argt[2]) ~= "number" then
      argtypeerror ("msgget", 2, "int or nil", argt[2])
    end
    if argt[3] ~= nil and type (argt[3]) ~= "string" then
      argtypeerror ("msgget", 3, "string or nil", argt[3])
    end
    if #argt > 3 then toomanyargerror ("msgget", 3, #argt) end
    return msgget (...)
  end
else
  M.msgget = msgget
end


--- Open a file.
-- @function open
-- @string path file to act on
-- @int oflags bitwise OR of zero or more of `O_RDONLY`, `O_WRONLY`, `O_RDWR`,
--   `O_APPEND`, `O_CREAT`, `O_DSYNC`, `O_EXCL`, `O_NOCTTY`, `O_NONBLOCK`,
--   `O_RSYNC`, `O_SYNC`, `O_TRUNC`
-- @string modestr (used with `O_CREAT`; see @{chmod} for format)
-- @treturn[1] int file descriptor for *path*, if successful
-- @return[2] nil
-- @treturn[2] string error message
-- @treturn[2] int errnum
-- @see open(2)
-- @usage
-- fd = P.open ("data", bit.bor (P.O_CREAT, P.O_RDWR), "rw-r-----")

local bit   = require "bit32"
local fcntl = require "posix.fcntl"

local _open, O_CREAT = fcntl.open, fcntl.O_CREAT
local band = bit.band

local function open (path, oflags, modestr)
  local mode
  if band (oflags, O_CREAT) ~= 0 then
    mode, err = mode_munch (0, modestr)
    if mode == nil then
      argerror ("open", 3, err, 2)
    end
    mode = band (mode, RWXALL)
  end
  return _open (path, oflags, mode)
end

if _DEBUG ~= false then
  M.open = function (...)
    local argt, maxt = {...}, 2
    checkstring ("open", 1, argt[1])
    local oflags = checkint ("open", 2, argt[2])
    if band (oflags, O_CREAT) ~= 0 then
      checkstring ("open", 3, argt[3])
      maxt = 3
    end
    if #argt > maxt then toomanyargerror ("open", maxt, #argt) end
    return open (...)
  end
else
  M.creat = creat
end


--- Set log priority mask
-- @function setlogmask
-- @int ... zero or more of `LOG_EMERG`, `LOG_ALERT`, `LOG_CRIT`,
--   `LOG_WARNING`, `LOG_NOTICE`, `LOG_INFO` and `LOG_DEBUG`
-- @treturn[1] int `0`, if successful
-- @return[2] nil
-- @treturn[2] string error message
-- @treturn[2] int errnum

local bit = require "bit32"
local log = require "posix.syslog"

local bor = bit.bor
local _setlogmask, LOG_MASK = log.setlogmask, log.LOG_MASK

local function setlogmask (...)
  local mask = 0
  for _, v in ipairs {...} do
    mask = bor (mask, LOG_MASK (v))
  end
  return _setlogmask (mask)
end

if _DEBUG ~= false then
  M.setlogmask = function (...)
    for i, v in ipairs {...} do
      optint ("setlogmask", i, v, 0) -- for "int or nil" error
    end
    return setlogmask (...)
  end
else
  M.setlogmask = setlogmask
end


--- Set file mode creation mask.
-- @function umask
-- @string[opt] mode file creation mask string
-- @treturn string previous umask
-- @see umask(2)
-- @see posix.sys.stat.umask

local st = require "posix.sys.stat"

local _umask, RWXALL = st.umask, bor (st.S_IRWXU, st.S_IRWXG, st.S_IRWXO)

local function umask (modestr)
  modestr = modestr or ""
  local mode = _umask (0)
  _umask (mode)
  mode = band (bnot (mode), RWXALL)
  if #modestr > 0 then
    local bits, err = mode_munch (mode, modestr)
    if bits == nil then
      argerror ("umask", 1, err, 2)
    end
    mode = band (bits, RWXALL)
    _umask (bnot (mode))
  end
  return pushmode (mode)
end


if _DEBUG ~= false then
  M.umask = function (modestr, ...)
    local argt = {modestr, ...}
    optstring ("umask", 1, modestr, "")
    if #argt > 1 then
      toomanyargerror ("umask", 1, #argt)
    end
    return umask (modestr)
  end
else
  M.umask = umask
end


return M