--[[
Computable Pandoc:
  (C) 2023 perro hi@perrotuerto.blog
  License: GPLv3 https://git.cuates.net/perro/computable-pandoc/src/branch/no-masters/LICENSE.txt
  Source: https://git.cuates.net/perro/computable-pandoc
]]--

require "fennel"
require "nat"

local lua_dog = require("dog")

dog.import()

---------------------------------- LITERATE ----------------------------------

-- Stores all literate stuff
local lit = {}

-- Indicates status
lit.status = true

-- Stores literate functions
lit.fns = {}

-- Returns specific grammar
function lit.g(name)

  -- Stores all grammars
  local grammars = {}

  -- Shortcuts
  local P, S, R, Cf, Cc, Ct, V, Cs, Cg, Cb, B, C, Cmt =
    lpeg.P, lpeg.S, lpeg.R, lpeg.Cf, lpeg.Cc, lpeg.Ct, lpeg.V,
    lpeg.Cs, lpeg.Cg, lpeg.Cb, lpeg.B, lpeg.C, lpeg.Cmt

  -- Lexical elements
  local newline = P"\r"^-1 * P"\n"
  local space = S" \t"
  local anyspace = S" \t\r\n"
  local spot = (1 - anyspace)
  local any = (spot + space)
  local yamlheader = space^0 * P"---" * space^0 * newline
  local yamlfooter = space^0 * P"..." * space^0 * newline^-1
  local yamlbody = -yamlfooter * any^0 * newline
  local label = R("az", "AZ") * R("az", "AZ", "09", "__")^0
  local ref = -B"\\" * P"#" * C(label)
  local notref = (1 - ref)^0

  -- Function declaration grammar
  grammars["declaration"] = P {
    "Declaration";
    Declaration = Ct(V"YAML" * V"Code", "name");
    YAML = C(yamlheader * yamlbody^0 * yamlfooter);
    Code = C((any + newline)^0);
  }

  -- Argument references grammar
  grammars["references"] = notref * P {
    "References";
    References = Ct((ref * notref)^0);
  } * -1

  return grammars[name]
end

-- Prints located messages
function lit.puts(yaml_key, ...)

  -- Returns debug level as number
  local function debuglevel(str)
    if str == "ERROR" then
      lit.status = false
      return 2
    elseif str == "WARNING" then
      return 1
    else
      return 0
    end
  end

  -- Gets located message
  local function getmsg(key, ...)
    local msg = pandoc.metatotable(pandoc.read([[---
INFO:
  checking:
    en: "Checking:\n#1"
    es: "Comprobando:\n#1"
  skip_check:
    en: "Skipping '#1': this check is not supported"
    es: "Skipping '#1': esta comprobación no está soportada"
WARNING:
  ignore_lang:
    en: "Keys 'cmd' and 'lang' present: '#1' overrides '#2'"
    es: "Llaves 'cmd' y 'lang' presentes: '#1' sobrescribe '#2'"
ERROR:
  invalid_key:
    en: Invalid key '#1'
    es: Clave '#1' inválida
  invalid_path:
    en: Invalid path '#1' in key '#2'
    es: Ruta '#1' inválida en clave '#2'
  invalid_type:
    en: Invalid type '#1' in key '#2'
    es: Tipo '#1' inválido en clave '#2'
  invalid_value:
    en: Invalid value '#1' in key '#2'
    es: Valor '#1' inválido en clave '#2'
  invalid_cmd:
    en: Invalid cmd '#1'
    es: Comando '#1' inválido
  no_key:
    en: Key '#1' not found
    es: Clave '#1' no encontrada
  aborted:
    en: Aborted due previous errors
    es: Abortado debido a previos errores
  meta_empty:
    en: Empty metadata
    es: Metadatos vacíos
  meta_invalid:
    en: Invalid metadata
    es: Metadatos inválidos
...
]]).meta)
    local levelname, level, lang = "INFO", 0, os.lang()
    for mtype, msgs in pairs(msg) do
      if msgs[key] then
        key = (msgs[key][lang] ~= nil and msgs[key][lang] or msgs[key]["en"])
        for i, str in ipairs({...}) do
          key = key:gsub("#" .. i, str)
        end
        levelname, level = mtype, debuglevel(mtype)
        break
      end
    end
    return key, levelname, level
  end

  local verbosity = debuglevel(PANDOC_STATE.verbosity)
  local msg, levelname, level = getmsg(yaml_key, ...)
  if level >= verbosity then
    print("[" .. levelname .. "] [LIT] " .. msg)
  end
end

-- Parses and evaluates literate functions in document
function lit.exam(doc)

  -- Extracts function declarations
  local function extract(codeblock)

    -- Checks function declarations
    local function check(match)

      -- Stores valid declaration
      local declaration = {}

      -- Valid metadata structure
      local metastruct = {
        ["mandatory"] = {
          -- Value as table == whole patterns to match
          ["id"] = {"%a[_%w]*"},
        },
        ["optional"] = {
          ["lang"] = {
            "lua", "fennel", "python", "js", "ruby", "lisp", "graphviz",
          },
          ["cmd"] = {".+"},
          -- Value as string == type to match
          ["args"] = "table",
          ["shift"] = "boolean",
          ["wipe"] = "boolean",
          ["typed"] = "boolean",
          ["link"] = "path",
          ["img"] = "path",
          ["alt"] = "string",
          ["dump"] = "path",
          ["quote"] = "boolean",
        },
      }

      -- Language commands
      -- Eachs command is a table of table;
      -- First table indicates one or more internal or external evaluations
      -- Second table indicates one or more commands to try
      local langcmds = {
        ["lua"] = {["int_eval"] = { "CMD1", "CMD2", } },
        ["fennel"] = {["int_eval"] = { "CMD1", "CMD2", } },
        ["python"] = {["ext_eval"] = { "CMD1", "CMD2", } },
        ["js"] = {["ext_eval"] = { "CMD1", "CMD2", } },
        ["ruby"] = {["ext_eval"] = { "CMD1", "CMD2", } },
        ["lisp"] = {["ext_eval"] = { "CMD1", "CMD2", } },
        ["graphviz"] = {["ext_eval"] = { "CMD1", "CMD2", } },
      }

      -- Prints error
      -- Since error messages debuglevel are "ERROR", lit.status turns false
      -- Flush the declaration to avoid storage in lit.fns
      local function putserr(...)
        lit.puts(...)
        declaration = {}
      end

      -- Adds 'eval' key in declaration
      -- This key indicates what to eval
      local function addeval()
        declaration["eval"] = {}
        -- If lang and cmd are present, ignores lang and use cmd as eval
        if declaration["lang"] and declaration["cmd"] then
          lit.puts("ignore_lang", declaration["cmd"], declaration["lang"])
          declaration["eval"] = {["ext_eval"] = { declaration["cmd"] } }
        -- If neither lang or cmd are presents, defaults lang and eval to lua
        elseif not(declaration["lang"]) and not(declaration["cmd"])then
          declaration["lang"] = "lua"
          declaration["eval"] = langcmds["lua"]
        -- If only lang present, eval is lang
        elseif declaration["lang"] and not(declaration["cmd"]) then
          declaration["eval"] = langcmds[declaration["lang"]]
        -- If only cmd present, eval is cmd
        elseif not(declaration["lang"]) and declaration["cmd"] then
          declaration["eval"] = {["ext_eval"] = { declaration["cmd"] } }
        end
      end

      -- Checks for valid command for Unix systems
      local function checkcmd()
        if declaration["cmd"] then
          local cmd = declaration["cmd"]:split()[1]
          if os.isunix() then
            local status = io.try("type", cmd)
            if not(status) then
              putserr("invalid_cmd", cmd)
            end
          else
            lit.puts("skip_check", "checkcmd")
          end
        end
      end

      -- Checks for extra, unwanted and wrong metadata
      local function checkextra()
        for key, _ in pairs(declaration) do
          local missing1 = metastruct["mandatory"][key] == nil
          local missing2 = metastruct["optional"][key] == nil
          if missing1 and missing2 then
            putserr("invalid_key", key)
          end
        end
      end

      -- Checks for valid metadata
      local function checkmeta(kind)

        -- Checks for valid metadata type
        local function checktype(type1, key)
          local val = declaration[key]
          local type2 = type(val)
          if type1 ~= type2 then
            if type1 == "path" then
              if not(pandoc.path.directory(val):isdir()) then
                putserr("invalid_path", val, key)
              end
            else
              putserr("invalid_type", type2, key)
            end
          end
        end

        -- Checks for valid metadata pattern
        local function checkpattern(table, key)
          local val = tostring(declaration[key])
          local err = key
          for _, pattern in pairs(table) do
            if val:match("^" .. pattern .. "$") then
              err = ""
              break
            end
          end
          if not(err:isempty()) then
            putserr("invalid_value", val, err)
          end
        end

        for key, val in pairs(metastruct[kind]) do
          if declaration[key] == nil and kind == "mandatory" then
            putserr("no_key", key)
          elseif declaration[key] and type(val) == "table" then
            checkpattern(val, key)
          elseif declaration[key] then
            checktype(val, key)
          end
        end
      end

      -- Parses metadata
      local function parsemeta(yaml)
        local isok, res = pcall(pandoc.read, yaml)
        if isok and not(pandoc.utils.stringify(res.meta):isempty()) then
          declaration = pandoc.metatotable(res.meta)
          checkmeta("mandatory")
          checkmeta("optional")
          checkextra()
          checkcmd()
          if next(declaration) then addeval() end
        elseif isok and pandoc.utils.stringify(res.meta):isempty() then
          putserr("meta_empty")
        else
          putserr("meta_invalid")
        end
      end

      -- TODO
      -- Parses code
      local function parsecode(rawcode)
        local code = ""
        local references = lpeg.match(lit.g("references"), rawcode)
        if references then
          for _, ref in ipairs(references) do
            print("reference:", ref)
          end
        end
        declaration["code"] = code
      end

      if match then
        lit.puts("checking", table.concat(match, ""):indent())
        parsemeta(match[1])
        if next(declaration) then parsecode(match[2]) end
      end
      return declaration
    end

    local parsed = check(lpeg.match(lit.g("declaration"), codeblock.text))
    if next(parsed) then
      -- TODO:
      -- Eval parsed lit.fns and modify code block accordingly
      lit.fns[parsed["id"]] = parsed
    end
    return codeblock
  end

  -- Calls literate functions
  local function call(el)

    -- TODO
    -- Calls literate functions in code inlines
    local function codecall(code)
      return pandoc.Str("EVAL: " .. pandoc.utils.stringify(code))
    end

    local function metacall(meta)
      local function inlinescall(inlines)
        return inlines:walk {
          Code = function(code) return codecall(code) end
        }
      end

      for key, val in pairs(meta) do
        if pandoc.utils.type(val) == "Inlines" then
          meta[key] = inlinescall(val)
        elseif pandoc.utils.type(val) == "List" then
          for i, item in ipairs(val) do
            if pandoc.utils.type(item) == "Inlines" then
              meta[key][i] = inlinescall(item)
            end
          end
        end
      end
      return meta
    end

    if pandoc.utils.type(el) == "Meta" then
      return metacall(el)
    else
      return codecall(el)
    end
  end

  -- Asserts literate status
  local function assert()
    if not(lit.status) then
      lit.puts("aborted")
      os.exit(1)
    end
  end

  doc = doc:walk { CodeBlock = function(block) return extract(block) end }
  doc = doc:walk { Meta = function(meta) return call(meta) end }
  doc = doc:walk { Code = function(code) return call(code) end }
  return doc:walk { Pandoc = function(_) assert() end }
end

------------------------------------ PANDOC -----------------------------------

return {
  -- Parses and evals literate programming
  { Pandoc = function(e) return lit.exam(e) end },
  -- TODO Parses and evals natural programming
  -- { Inlines = function(e) return nat.get(pandoc.utils.stringify(e)) end },
}