require('core.snippets.shorthands')
require('core.snippets.functions')

--- shortcut to choose between java access modifiers
---@param idx number index of the node
---@return table choice_node
local function access_modifiers(idx)
  return c(idx, {
    t("public "),
    t("private "),
    t("protected "),
    t("default "),
  })
end

--- shortcut to choose between java modifiers
---@param idx number index of the node
---@return table choice_node
local function modifiers(idx)
  return c(idx, {
    t(""),
    t("abstract "),
    t("final ")
  })
end

--- find the current class and return its name if not available defaults to
--- the file name
---@return string
local function java_class()
  -- set the starting node to the node under the cursor
  local node = require("nvim-treesitter.ts_utils").get_node_at_cursor()

  while node do
    -- check if we're in a class
    if node:type() == "class_declaration" then
      -- find the class name in the class declaration and return it
      for i = 0, node:child_count() - 1 do
        local child = node:child(i)
        if child and child:type() == "identifier" then
          return vim.treesitter.get_node_text(child, 0)
        end
      end
    end
    node = node:parent()
  end

  -- if no class can be found default to the current file name
  return file_name()
end


return {
  -- method snippet
  s({ trig = [[fn\|constr]], trigEngine = "vim" }, {
    access_modifiers(1),
    modifiers(2),
    d(3, function(_, snip)
      if snip.trigger == "constr" then
        return sn(nil, {
          f(java_class, {})
        })
      else
        return sn(nil, {
          c(1, {
            t("void"),
            t("int"),
            t("double"),
            t("boolean"),
            t("String"),
            t("char"),
            i(nil, "myType"),
          }),
          t(" "),
          i(2, "myFunc"),
        })
      end
    end, {}),
    t("("),
    i(4),
    t(")"),
    c(5, {
      t(""),
      sn(nil, { t({ "", " throws " }), i(1, "Error") }),
    }),
    d(6, function(args)
      if args[1][1] == "abstract " then
        -- if the function is abstract do not include a body
        return sn(nil, {
          t(";")
        })
      else
        -- if the function isn't abstract include a body
        return sn(nil, {
          t({ " {", "\t" }),
          i(1),
          t({ "", "}" })
        })
      end
    end, { 2 })
  }),

  s("main", {
    t({ "public static void main(String[] args) {", "\t" }),
    i(0),
    t({ "", "}" })
  }),

  -- class snippet
  s({ trig = [[class\|interface]], trigEngine = "vim" }, {
    access_modifiers(1),
    modifiers(2),
    d(3, function(_, snip)
      local opts = { t("class "), t("interface ") }
      if snip.trigger == "interface" then
        -- flip interface and class
        opts[1], opts[2] = opts[2], opts[1]
      end

      return sn(nil, {
        c(1, opts)
      })
    end, {}),
    c(4, {
      f(file_name, {}),
      i(0, "MyClass")
    }),
    c(5, {
      t(" "),
      sn(nil, { t({" implements "}), i(1), t(" ") }),
      sn(nil, { t({" extends "}), i(1), t(" ") }),
    }),
    t({ "{", "\t" }),
    i(0),
    t({ "", "}" })
  }),

  -- pacakage snippet
  s("package", {
    t("package "),
    f(function()
      -- get path
      local dir = vim.fn.expand("%:h")
      -- remove prefix
      dir = dir:gsub("src/main/java/", "")
      -- convert to package path
      dir = dir:gsub("/", ".")

      return dir
    end, {}),
    t(";"),
    t({ "", "", "" })
  }),

  -- try, catch, finally snippet
  s("try", {
    t({"try {", "\t"}),
    i(1),
    t({"", "} catch ("}),
    i(2, "Error e"),
    t({") {", "\t"}),
    i(3),
    t({"", "}"}),
    c(4, {
      t(""),
      sn(nil, { t({" finally {", "\t"}), i(1), t({"", "}"}) })
    })
  })
}