#include <assert.h>
#include <lauxlib.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include "klib/kvec.h"
#include "nvim/api/extmark.h"
#include "nvim/api/keysets_defs.h"
#include "nvim/api/private/defs.h"
#include "nvim/api/private/dispatch.h"
#include "nvim/api/private/helpers.h"
#include "nvim/api/private/validate.h"
#include "nvim/buffer_defs.h"
#include "nvim/charset.h"
#include "nvim/decoration.h"
#include "nvim/decoration_defs.h"
#include "nvim/decoration_provider.h"
#include "nvim/drawscreen.h"
#include "nvim/extmark.h"
#include "nvim/globals.h"
#include "nvim/grid.h"
#include "nvim/highlight_group.h"
#include "nvim/map_defs.h"
#include "nvim/marktree.h"
#include "nvim/marktree_defs.h"
#include "nvim/mbyte.h"
#include "nvim/memline.h"
#include "nvim/memory.h"
#include "nvim/memory_defs.h"
#include "nvim/move.h"
#include "nvim/pos_defs.h"
#include "nvim/sign.h"

#include "api/extmark.c.generated.h"

void api_extmark_free_all_mem(void)
{
  String name;
  map_foreach_key(&namespace_ids, name, {
    xfree(name.data);
  })
  map_destroy(String, &namespace_ids);
  set_destroy(uint32_t, &namespace_localscope);
}

/// Creates a new namespace or gets an existing one. [namespace]()
///
/// Namespaces are used for buffer highlights and virtual text, see
/// |nvim_buf_set_extmark()|.
///
/// Namespaces can be named or anonymous. If `name` matches an existing
/// namespace, the associated id is returned. If `name` is an empty string
/// a new, anonymous namespace is created.
///
/// @param name Namespace name or empty string
/// @return Namespace id
Integer nvim_create_namespace(String name)
  FUNC_API_SINCE(5)
{
  handle_T id = map_get(String, int)(&namespace_ids, name);
  if (id > 0) {
    return (Integer)id;
  }
  id = next_namespace_id++;
  if (name.size > 0) {
    String name_alloc = copy_string(name, NULL);
    map_put(String, int)(&namespace_ids, name_alloc, id);
  }
  return (Integer)id;
}

/// Gets existing, non-anonymous |namespace|s.
///
/// @return dict that maps from names to namespace ids.
DictOf(Integer) nvim_get_namespaces(Arena *arena)
  FUNC_API_SINCE(5)
{
  Dict retval = arena_dict(arena, map_size(&namespace_ids));
  String name;
  handle_T id;

  map_foreach(&namespace_ids, name, id, {
    PUT_C(retval, name.data, INTEGER_OBJ(id));
  })

  return retval;
}

const char *describe_ns(NS ns_id, const char *unknown)
{
  String name;
  handle_T id;
  map_foreach(&namespace_ids, name, id, {
    if ((NS)id == ns_id && name.size) {
      return name.data;
    }
  })
  return unknown;
}

// Is the Namespace in use?
bool ns_initialized(uint32_t ns)
{
  if (ns < 1) {
    return false;
  }
  return ns < (uint32_t)next_namespace_id;
}

Array virt_text_to_array(VirtText vt, bool hl_name, Arena *arena)
{
  Array chunks = arena_array(arena, kv_size(vt));
  for (size_t i = 0; i < kv_size(vt); i++) {
    size_t j = i;
    for (; j < kv_size(vt); j++) {
      if (kv_A(vt, j).text != NULL) {
        break;
      }
    }

    Array hl_array = arena_array(arena, i < j ? j - i + 1 : 0);
    for (; i < j; i++) {
      int hl_id = kv_A(vt, i).hl_id;
      if (hl_id >= 0) {
        ADD_C(hl_array, hl_group_name(hl_id, hl_name));
      }
    }

    char *text = kv_A(vt, i).text;
    int hl_id = kv_A(vt, i).hl_id;
    Array chunk = arena_array(arena, 2);
    ADD_C(chunk, CSTR_AS_OBJ(text));
    if (hl_array.size > 0) {
      if (hl_id >= 0) {
        ADD_C(hl_array, hl_group_name(hl_id, hl_name));
      }
      ADD_C(chunk, ARRAY_OBJ(hl_array));
    } else if (hl_id >= 0) {
      ADD_C(chunk, hl_group_name(hl_id, hl_name));
    }
    ADD_C(chunks, ARRAY_OBJ(chunk));
  }
  return chunks;
}

static Array extmark_to_array(MTPair extmark, bool id, bool add_dict, bool hl_name, Arena *arena)
{
  MTKey start = extmark.start;
  Array rv = arena_array(arena, 4);
  if (id) {
    ADD_C(rv, INTEGER_OBJ((Integer)start.id));
  }
  ADD_C(rv, INTEGER_OBJ(start.pos.row));
  ADD_C(rv, INTEGER_OBJ(start.pos.col));

  if (add_dict) {
    // TODO(bfredl): coding the size like this is a bit fragile.
    // We want ArrayOf(Dict(set_extmark)) as the return type..
    Dict dict = arena_dict(arena, ARRAY_SIZE(set_extmark_table));

    PUT_C(dict, "ns_id", INTEGER_OBJ((Integer)start.ns));

    PUT_C(dict, "right_gravity", BOOLEAN_OBJ(mt_right(start)));

    if (mt_paired(start)) {
      PUT_C(dict, "end_row", INTEGER_OBJ(extmark.end_pos.row));
      PUT_C(dict, "end_col", INTEGER_OBJ(extmark.end_pos.col));
      PUT_C(dict, "end_right_gravity", BOOLEAN_OBJ(extmark.end_right_gravity));
    }

    if (mt_no_undo(start)) {
      PUT_C(dict, "undo_restore", BOOLEAN_OBJ(false));
    }

    if (mt_invalidate(start)) {
      PUT_C(dict, "invalidate", BOOLEAN_OBJ(true));
    }
    if (mt_invalid(start)) {
      PUT_C(dict, "invalid", BOOLEAN_OBJ(true));
    }

    decor_to_dict_legacy(&dict, mt_decor(start), hl_name, arena);

    ADD_C(rv, DICT_OBJ(dict));
  }

  return rv;
}

/// Gets the position (0-indexed) of an |extmark|.
///
/// @param buf  Buffer id, or 0 for current buffer
/// @param ns_id  Namespace id from |nvim_create_namespace()|
/// @param id  Extmark id
/// @param opts  Optional parameters. Keys:
///          - details: Whether to include the details dict
///          - hl_name: Whether to include highlight group name instead of id, true if omitted
/// @param[out] err   Error details, if any
/// @return 0-indexed (row, col, details?) tuple or empty list () if extmark id was absent.  The
/// optional `details` dictionary contains the same keys as `opts` in |nvim_buf_set_extmark()|,
/// except for `id`, `conceal_lines` and `ephemeral`. It also contains the following keys:
///
/// - ns_id: |namespace| id
/// - invalid: boolean that indicates whether the mark is hidden because the entirety of
/// text span range is deleted. See also the key `invalidate` in |nvim_buf_set_extmark()|.
Tuple(Integer, Integer, *DictAs(extmark_details))
nvim_buf_get_extmark_by_id(Buffer buf, Integer ns_id, Integer id, Dict(get_extmark) * opts,
                           Arena *arena, Error *err)
  FUNC_API_SINCE(7)
{
  Array rv = ARRAY_DICT_INIT;

  buf_T *b = find_buffer_by_handle(buf, err);

  if (!b) {
    return rv;
  }

  VALIDATE_INT(ns_initialized((uint32_t)ns_id), "ns_id", ns_id, {
    return rv;
  });

  bool details = opts->details;

  bool hl_name = GET_BOOL_OR_TRUE(opts, get_extmark, hl_name);

  MTPair extmark = extmark_from_id(b, (uint32_t)ns_id, (uint32_t)id);
  if (extmark.start.pos.row < 0) {
    return rv;
  }
  return extmark_to_array(extmark, false, details, hl_name, arena);
}

/// Gets |extmarks| in "traversal order" from a |charwise| region defined by
/// buffer positions (inclusive, 0-indexed |api-indexing|).
///
/// Region can be given as (row,col) tuples, or valid extmark ids (whose
/// positions define the bounds). 0 and -1 are understood as (0,0) and (-1,-1)
/// respectively, thus the following are equivalent:
///
/// ```lua
/// vim.api.nvim_buf_get_extmarks(0, my_ns, 0, -1, {})
/// vim.api.nvim_buf_get_extmarks(0, my_ns, {0,0}, {-1,-1}, {})
/// ```
///
/// If `end` is less than `start`, marks are returned in reverse order.
/// (Useful with `limit`, to get the first marks prior to a given position.)
///
/// Note: For a reverse range, `limit` does not actually affect the traversed
/// range, just how many marks are returned
///
/// Note: when using extmark ranges (marks with a end_row/end_col position)
/// the `overlap` option might be useful. Otherwise only the start position
/// of an extmark will be considered.
///
/// Note: legacy signs placed through the |:sign| commands are implemented
/// as extmarks and will show up here. Their details array will contain a
/// `sign_name` field.
///
/// Example:
///
/// ```lua
/// local api = vim.api
/// local pos = api.nvim_win_get_cursor(0)
/// local ns  = api.nvim_create_namespace('my-plugin')
/// -- Create new extmark at line 1, column 1.
/// local m1  = api.nvim_buf_set_extmark(0, ns, 0, 0, {})
/// -- Create new extmark at line 3, column 1.
/// local m2  = api.nvim_buf_set_extmark(0, ns, 2, 0, {})
/// -- Get extmarks only from line 3.
/// local ms  = api.nvim_buf_get_extmarks(0, ns, {2,0}, {2,0}, {})
/// -- Get all marks in this buffer + namespace.
/// local all = api.nvim_buf_get_extmarks(0, ns, 0, -1, {})
/// vim.print(ms)
/// ```
///
/// @param buf  Buffer id, or 0 for current buffer
/// @param ns_id  Namespace id from |nvim_create_namespace()| or -1 for all namespaces
/// @param start  Start of range: a 0-indexed (row, col) or valid extmark id
/// (whose position defines the bound). |api-indexing|
/// @param end  End of range (inclusive): a 0-indexed (row, col) or valid
/// extmark id (whose position defines the bound). |api-indexing|
/// @param opts  Optional parameters. Keys:
///          - limit:  Maximum number of marks to return
///          - details: Whether to include the details dict
///          - hl_name: Whether to include highlight group name instead of id, true if omitted
///          - overlap: Also include marks which overlap the range, even if
///                     their start position is less than `start`
///          - type: Filter marks by type: "highlight", "sign", "virt_text" and "virt_lines"
/// @param[out] err   Error details, if any
/// @return List of `[extmark_id, row, col, details?]` tuples in "traversal order". For the
/// `details` dictionary, see |nvim_buf_get_extmark_by_id()|.
ArrayOf(DictAs(get_extmark_item)) nvim_buf_get_extmarks(Buffer buf, Integer ns_id, Object start,
                                                        Object end,
                                                        Dict(get_extmarks) *opts, Arena *arena,
                                                        Error *err)
  FUNC_API_SINCE(7)
{
  Array rv = ARRAY_DICT_INIT;

  buf_T *b = find_buffer_by_handle(buf, err);
  if (!b) {
    return rv;
  }

  VALIDATE_INT(ns_id == -1 || ns_initialized((uint32_t)ns_id), "ns_id", ns_id, {
    return rv;
  });

  bool details = opts->details;
  bool hl_name = GET_BOOL_OR_TRUE(opts, get_extmarks, hl_name);

  ExtmarkType type = kExtmarkNone;
  if (HAS_KEY(opts, get_extmarks, type)) {
    if (strequal(opts->type.data, "sign")) {
      type = kExtmarkSign;
    } else if (strequal(opts->type.data, "virt_text")) {
      type = kExtmarkVirtText;
    } else if (strequal(opts->type.data, "virt_lines")) {
      type = kExtmarkVirtLines;
    } else if (strequal(opts->type.data, "highlight")) {
      type = kExtmarkHighlight;
    } else {
      VALIDATE_EXP(false, "type", "sign, virt_text, virt_lines or highlight", opts->type.data, {
        return rv;
      });
    }
  }

  Integer limit = HAS_KEY(opts, get_extmarks, limit) ? opts->limit : -1;

  if (limit == 0) {
    return rv;
  } else if (limit < 0) {
    limit = INT64_MAX;
  }

  int l_row;
  colnr_T l_col;
  if (!extmark_get_index_from_obj(b, ns_id, start, &l_row, &l_col, err)) {
    return rv;
  }

  int u_row;
  colnr_T u_col;
  if (!extmark_get_index_from_obj(b, ns_id, end, &u_row, &u_col, err)) {
    return rv;
  }

  size_t rv_limit = (size_t)limit;
  bool reverse = l_row > u_row || (l_row == u_row && l_col > u_col);
  if (reverse) {
    limit = INT64_MAX;  // limit the return value instead
    int row = l_row;
    l_row = u_row;
    u_row = row;
    colnr_T col = l_col;
    l_col = u_col;
    u_col = col;
  }

  // note: ns_id=-1 allowed, represented as UINT32_MAX
  ExtmarkInfoArray marks = extmark_get(b, (uint32_t)ns_id, l_row, l_col, u_row,
                                       u_col, (int64_t)limit, type, opts->overlap);

  rv = arena_array(arena, MIN(kv_size(marks), rv_limit));
  if (reverse) {
    for (int i = (int)kv_size(marks) - 1; i >= 0 && kv_size(rv) < rv_limit; i--) {
      ADD_C(rv, ARRAY_OBJ(extmark_to_array(kv_A(marks, i), true, details, hl_name, arena)));
    }
  } else {
    for (size_t i = 0; i < kv_size(marks); i++) {
      ADD_C(rv, ARRAY_OBJ(extmark_to_array(kv_A(marks, i), true, details, hl_name, arena)));
    }
  }

  kv_destroy(marks);
  return rv;
}

/// Creates or updates an |extmark|.
///
/// By default a new extmark is created when no id is passed in, but it is also
/// possible to create a new mark by passing in a previously unused id or move
/// an existing mark by passing in its id. The caller must then keep track of
/// existing and unused ids itself. (Useful over RPC, to avoid waiting for the
/// return value.)
///
/// Using the optional arguments, it is possible to use this to highlight
/// a range of text, and also to associate virtual text to the mark.
///
/// If present, the position defined by `end_col` and `end_row` should be after
/// the start position in order for the extmark to cover a range.
/// An earlier end position is not an error, but then it behaves like an empty
/// range (no highlighting).
///
/// @param buf  Buffer id, or 0 for current buffer
/// @param ns_id  Namespace id from |nvim_create_namespace()|
/// @param line  Line where to place the mark, 0-based. |api-indexing|
/// @param col  Column where to place the mark, 0-based. |api-indexing|
/// @param opts  Optional parameters.
///               - id : id of the extmark to edit.
///               - end_row : ending line of the mark, 0-based inclusive.
///               - end_col : ending col of the mark, 0-based exclusive, or -1 to extend the range to end of line.
///               - hl_group : highlight group used for the text range. This and below
///                   highlight groups can be supplied either as a string or as an integer,
///                   the latter of which can be obtained using |nvim_get_hl_id_by_name()|.
///
///                   Multiple highlight groups can be stacked by passing an array (highest
///                   priority last).
///               - hl_eol : when true, for a multiline highlight covering the
///                          EOL of a line, continue the highlight for the rest
///                          of the screen line (just like for diff and
///                          cursorline highlight).
///               - virt_text : [](virtual-text) to link to this mark.
///                   A list of `[text, highlight]` tuples, each representing a
///                   text chunk with specified highlight. `highlight` element
///                   can either be a single highlight group, or an array of
///                   multiple highlight groups that will be stacked
///                   (highest priority last).
///               - virt_text_pos : position of virtual text. Possible values:
///                 - "eol": right after eol character (default).
///                 - "eol_right_align": display right aligned in the window
///                                      unless the virtual text is longer than
///                                      the space available. If the virtual
///                                      text is too long, it is truncated to
///                                      fit in the window after the EOL
///                                      character. If the line is wrapped, the
///                                      virtual text is shown after the end of
///                                      the line rather than the previous
///                                      screen line.
///                 - "overlay": display over the specified column, without
///                              shifting the underlying text.
///                 - "right_align": display right aligned in the window.
///                 - "inline": display at the specified column, and
///                             shift the buffer text to the right as needed.
///               - virt_text_win_col : position the virtual text at a fixed
///                                     window column (starting from the first
///                                     text column of the screen line) instead
///                                     of "virt_text_pos".
///               - virt_text_hide : hide the virtual text when the background
///                                  text is selected or hidden because of
///                                  scrolling with 'nowrap' or 'smoothscroll'.
///                                  Currently only affects "overlay" virt_text.
///               - virt_text_repeat_linebreak : repeat the virtual text on
///                                              wrapped lines.
///               - hl_mode : control how highlights are combined with the
///                           highlights of the text. Currently only affects
///                           virt_text highlights, but might affect `hl_group`
///                           in later versions.
///                 - "replace": only show the virt_text color. This is the default.
///                 - "combine": combine with background text color.
///                 - "blend": blend with background text color.
///                            Not supported for "inline" virt_text.
///
///               - virt_lines : virtual lines to add next to this mark
///                   This should be an array over lines, where each line in
///                   turn is an array over `[text, highlight]` tuples. In
///                   general, buffer and window options do not affect the
///                   display of the text. In particular 'wrap'
///                   and 'linebreak' options do not take effect, so
///                   the number of extra screen lines will always match
///                   the size of the array. However the 'tabstop' buffer
///                   option is still used for hard tabs. By default lines are
///                   placed below the buffer line containing the mark.
///
///               - virt_lines_above: place virtual lines above instead.
///               - virt_lines_leftcol: Place virtual lines in the leftmost
///                                     column of the window, bypassing
///                                     sign and number columns.
///               - virt_lines_overflow: controls how to handle virtual lines wider
///                   than the window. Currently takes the one of the following values:
///                 - "trunc": truncate virtual lines on the right (default).
///                 - "scroll": virtual lines can scroll horizontally with 'nowrap',
///                    otherwise the same as "trunc".
///               - ephemeral : for use with |nvim_set_decoration_provider()|
///                   callbacks. The mark will only be used for the current
///                   redraw cycle, and not be permanently stored in the buffer.
///               - right_gravity : boolean that indicates the direction
///                   the extmark will be shifted in when new text is inserted
///                   (true for right, false for left). Defaults to true.
///               - end_right_gravity : boolean that indicates the direction
///                   the extmark end position (if it exists) will be shifted
///                   in when new text is inserted (true for right, false
///                   for left). Defaults to false.
///               - undo_restore : Restore the exact position of the mark
///                   if text around the mark was deleted and then restored by undo.
///                   Defaults to true.
///               - invalidate : boolean that indicates whether to hide the
///                   extmark if the entirety of its range is deleted. For
///                   hidden marks, an "invalid" key is added to the "details"
///                   array of |nvim_buf_get_extmarks()| and family. If
///                   "undo_restore" is false, the extmark is deleted instead.
///               - priority: a priority value for the highlight group, sign
///                   attribute or virtual text. For virtual text, item with
///                   highest priority is drawn last. For example treesitter
///                   highlighting uses a value of 100.
///               - strict: boolean that indicates extmark should not be placed
///                   if the line or column value is past the end of the
///                   buffer or end of the line respectively. Defaults to true.
///               - sign_text: string of length 1-2 used to display in the
///                   sign column.
///               - sign_hl_group: highlight group used for the sign column text.
///               - number_hl_group: highlight group used for the number column.
///               - line_hl_group: highlight group used for the whole line.
///               - cursorline_hl_group: highlight group used for the sign
///                   column text when the cursor is on the same line as the
///                   mark and 'cursorline' is enabled.
///               - conceal: string which should be either empty or a single
///                   character. Enable concealing similar to |:syn-conceal|.
///                   When a character is supplied it is used as |:syn-cchar|.
///                   "hl_group" is used as highlight for the cchar if provided,
///                   otherwise it defaults to |hl-Conceal|.
///               - conceal_lines: string which should be empty. When
///                   provided, lines in the range are not drawn at all
///                   (according to 'conceallevel'); the next unconcealed line
///                   is drawn instead.
///               - spell: boolean indicating that spell checking should be
///                   performed within this extmark
///               - ui_watched: boolean that indicates the mark should be drawn
///                   by a UI. When set, the UI will receive win_extmark events.
///                   Note: the mark is positioned by virt_text attributes. Can be
///                   used together with virt_text.
///               - url: A URL to associate with this extmark. In the TUI, the OSC 8 control
///                   sequence is used to generate a clickable hyperlink to this URL.
///
/// @param[out]  err   Error details, if any
/// @return Id of the created/updated extmark
Integer nvim_buf_set_extmark(Buffer buf, Integer ns_id, Integer line, Integer col,
                             Dict(set_extmark) *opts, Error *err)
  FUNC_API_SINCE(7)
{
  DecorHighlightInline hl = DECOR_HIGHLIGHT_INLINE_INIT;
  // TODO(bfredl): in principle signs with max one (1) hl group and max 4 bytes of text.
  // should be a candidate for inlining as well.
  DecorSignHighlight sign = DECOR_SIGN_HIGHLIGHT_INIT;
  DecorVirtText virt_text = DECOR_VIRT_TEXT_INIT;
  DecorVirtText virt_lines = DECOR_VIRT_LINES_INIT;
  char *url = NULL;
  bool has_hl = false;
  bool has_hl_multiple = false;

  buf_T *b = find_buffer_by_handle(buf, err);
  if (!b) {
    goto error;
  }

  VALIDATE_INT(ns_initialized((uint32_t)ns_id), "ns_id", ns_id, {
    goto error;
  });

  uint32_t id = 0;
  if (HAS_KEY(opts, set_extmark, id)) {
    VALIDATE_EXP((opts->id > 0), "id", "positive Integer", NULL, {
      goto error;
    });

    id = (uint32_t)opts->id;
  }

  int line2 = -1;
  bool did_end_line = false;

  // For backward compatibility we support "end_line" as an alias for "end_row"
  if (HAS_KEY(opts, set_extmark, end_line)) {
    VALIDATE(!HAS_KEY(opts, set_extmark, end_row),
             "%s", "cannot use both 'end_row' and 'end_line'", {
      goto error;
    });

    opts->end_row = opts->end_line;
    did_end_line = true;
  }

  bool strict = GET_BOOL_OR_TRUE(opts, set_extmark, strict);

  if (HAS_KEY(opts, set_extmark, end_row) || did_end_line) {
    Integer val = opts->end_row;
    VALIDATE_RANGE((val >= 0 && !(val > b->b_ml.ml_line_count && strict)), "end_row", {
      goto error;
    });
    line2 = (int)val;
  }

  colnr_T col2 = -1;
  if (HAS_KEY(opts, set_extmark, end_col)) {
    Integer val = opts->end_col;
    VALIDATE_RANGE((val >= -1 && val <= MAXCOL), "end_col", {
      goto error;
    });
    if (val == -1) {
      val = MAXCOL;
    }

    col2 = (int)val;
  }

  if (HAS_KEY(opts, set_extmark, hl_group)) {
    if (opts->hl_group.type == kObjectTypeArray) {
      Array arr = opts->hl_group.data.array;
      if (arr.size >= 1) {
        hl.hl_id = object_to_hl_id(arr.items[0], "hl_group item", err);
        if (ERROR_SET(err)) {
          goto error;
        }
      }
      for (size_t i = 1; i < arr.size; i++) {
        int hl_id = object_to_hl_id(arr.items[i], "hl_group item", err);
        if (ERROR_SET(err)) {
          goto error;
        }
        if (hl_id) {
          has_hl_multiple = true;
        }
      }
    } else {
      hl.hl_id = object_to_hl_id(opts->hl_group, "hl_group", err);
      if (ERROR_SET(err)) {
        goto error;
      }
    }
    has_hl = hl.hl_id > 0;
  }

  sign.hl_id = (int)opts->sign_hl_group;
  sign.cursorline_hl_id = (int)opts->cursorline_hl_group;
  sign.number_hl_id = (int)opts->number_hl_group;
  sign.line_hl_id = (int)opts->line_hl_group;

  if (sign.hl_id || sign.cursorline_hl_id || sign.number_hl_id || sign.line_hl_id) {
    sign.flags |= kSHIsSign;
  }

  if (HAS_KEY(opts, set_extmark, conceal)) {
    hl.flags |= kSHConceal;
    has_hl = true;
    if (opts->conceal.size > 0) {
      int ch;
      hl.conceal_char = utfc_ptr2schar(opts->conceal.data, &ch);
      VALIDATE(hl.conceal_char && vim_isprintc(ch), "%s", "conceal char has to be printable", {
        goto error;
      });
    }
  }

  if (HAS_KEY(opts, set_extmark, conceal_lines)) {
    hl.flags |= kSHConcealLines;
    has_hl = true;
    if (opts->conceal_lines.size > 0) {
      VALIDATE(*opts->conceal_lines.data == NUL, "%s", "conceal_lines has to be an empty string", {
        goto error;
      });
    }
  }

  if (HAS_KEY(opts, set_extmark, virt_text)) {
    virt_text.data.virt_text = parse_virt_text(opts->virt_text, err, &virt_text.width);
    if (ERROR_SET(err)) {
      goto error;
    }
  }

  if (HAS_KEY(opts, set_extmark, virt_text_pos)) {
    String str = opts->virt_text_pos;
    if (strequal("eol", str.data)) {
      virt_text.pos = kVPosEndOfLine;
    } else if (strequal("overlay", str.data)) {
      virt_text.pos = kVPosOverlay;
    } else if (strequal("right_align", str.data)) {
      virt_text.pos = kVPosRightAlign;
    } else if (strequal("eol_right_align", str.data)) {
      virt_text.pos = kVPosEndOfLineRightAlign;
    } else if (strequal("inline", str.data)) {
      virt_text.pos = kVPosInline;
    } else {
      VALIDATE_S(false, "virt_text_pos", str.data, {
        goto error;
      });
    }
  }

  if (HAS_KEY(opts, set_extmark, virt_text_win_col)) {
    virt_text.col = (int)opts->virt_text_win_col;
    virt_text.pos = kVPosWinCol;
  }

  hl.flags |= opts->hl_eol ? kSHHlEol : 0;
  virt_text.flags |= ((opts->virt_text_hide ? kVTHide : 0)
                      | (opts->virt_text_repeat_linebreak ? kVTRepeatLinebreak : 0));

  if (HAS_KEY(opts, set_extmark, hl_mode)) {
    String str = opts->hl_mode;
    if (strequal("replace", str.data)) {
      virt_text.hl_mode = kHlModeReplace;
    } else if (strequal("combine", str.data)) {
      virt_text.hl_mode = kHlModeCombine;
    } else if (strequal("blend", str.data)) {
      if (virt_text.pos == kVPosInline) {
        VALIDATE(false, "%s", "cannot use 'blend' hl_mode with inline virtual text", {
          goto error;
        });
      }
      virt_text.hl_mode = kHlModeBlend;
    } else {
      VALIDATE_S(false, "hl_mode", str.data, {
        goto error;
      });
    }
  }

  int virt_lines_flags = opts->virt_lines_leftcol ? kVLLeftcol : 0;
  if (HAS_KEY(opts, set_extmark, virt_lines_overflow)) {
    String str = opts->virt_lines_overflow;
    if (strequal("scroll", str.data)) {
      virt_lines_flags |= kVLScroll;
    } else if (!strequal("trunc", str.data)) {
      VALIDATE_S(false, "virt_lines_overflow", str.data, {
        goto error;
      });
    }
  }

  if (HAS_KEY(opts, set_extmark, virt_lines)) {
    Array a = opts->virt_lines;
    for (size_t j = 0; j < a.size; j++) {
      VALIDATE_T("virt_text_line", kObjectTypeArray, a.items[j].type, {
        goto error;
      });
      int dummig;
      VirtText jtem = parse_virt_text(a.items[j].data.array, err, &dummig);
      kv_push(virt_lines.data.virt_lines, ((struct virt_line){ jtem, virt_lines_flags }));
      if (ERROR_SET(err)) {
        goto error;
      }
    }
  }

  virt_lines.flags |= opts->virt_lines_above ? kVTLinesAbove : 0;

  if (HAS_KEY(opts, set_extmark, priority)) {
    VALIDATE_RANGE((opts->priority >= 0 && opts->priority <= UINT16_MAX), "priority", {
      goto error;
    });
    hl.priority = (DecorPriority)opts->priority;
    sign.priority = (DecorPriority)opts->priority;
    virt_text.priority = (DecorPriority)opts->priority;
    virt_lines.priority = (DecorPriority)opts->priority;
  }

  if (HAS_KEY(opts, set_extmark, sign_text)) {
    sign.text[0] = 0;
    VALIDATE_S(init_sign_text(NULL, sign.text, opts->sign_text.data), "sign_text", "", {
      goto error;
    });
    sign.flags |= kSHIsSign;
  }

  bool right_gravity = GET_BOOL_OR_TRUE(opts, set_extmark, right_gravity);

  // Only error out if they try to set end_right_gravity without
  // setting end_col or end_row
  VALIDATE(!(line2 == -1 && col2 == -1 && HAS_KEY(opts, set_extmark, end_right_gravity)),
           "%s", "cannot set end_right_gravity without end_row or end_col", {
    goto error;
  });

  colnr_T len = 0;

  if (HAS_KEY(opts, set_extmark, spell)) {
    hl.flags |= (opts->spell) ? kSHSpellOn : kSHSpellOff;
    has_hl = true;
  }

  if (HAS_KEY(opts, set_extmark, url)) {
    url = string_to_cstr(opts->url);
    has_hl = true;
  }

  if (opts->ui_watched) {
    hl.flags |= kSHUIWatched;
    if (virt_text.pos == kVPosOverlay) {
      // TODO(bfredl): in a revised interface this should be the default.
      hl.flags |= kSHUIWatchedOverlay;
    }
    has_hl = true;
  }

  VALIDATE_RANGE((line >= 0), "line", {
    goto error;
  });

  if (line > b->b_ml.ml_line_count) {
    VALIDATE_RANGE(!strict, "line", {
      goto error;
    });
    line = b->b_ml.ml_line_count;
  } else if (line < b->b_ml.ml_line_count) {
    len = opts->ephemeral ? MAXCOL : ml_get_buf_len(b, (linenr_T)line + 1);
  }

  if (col == -1) {
    col = len;
  } else if (col > len) {
    VALIDATE_RANGE(!strict, "col", {
      goto error;
    });
    col = len;
  } else if (col < -1) {
    VALIDATE_RANGE(false, "col", {
      goto error;
    });
  }

  if (col2 >= 0) {
    if (line2 >= 0 && line2 < b->b_ml.ml_line_count) {
      len = opts->ephemeral ? MAXCOL : ml_get_buf_len(b, (linenr_T)line2 + 1);
    } else if (line2 == b->b_ml.ml_line_count) {
      // We are trying to add an extmark past final newline
      len = 0;
    } else {
      // reuse len from before
      line2 = (int)line;
    }
    if (col2 > len) {
      VALIDATE_RANGE(!strict, "end_col", {
        goto error;
      });
      col2 = len;
    }
  } else if (line2 >= 0) {
    col2 = 0;
  }

  if (opts->ephemeral && decor_state.win && decor_state.win->w_buffer == b) {
    int r = (int)line;
    int c = (int)col;
    if (line2 == -1) {
      line2 = r;
      col2 = c;
    }

    DecorPriority subpriority = 0;
    if (HAS_KEY(opts, set_extmark, _subpriority)) {
      VALIDATE_RANGE((opts->_subpriority >= 0 && opts->_subpriority <= UINT16_MAX),
                     "_subpriority", {
        goto error;
      });
      subpriority = (DecorPriority)opts->_subpriority;
    }

    if (kv_size(virt_text.data.virt_text)) {
      decor_range_add_virt(&decor_state, r, c, line2, col2, decor_put_vt(virt_text, NULL), true);
    }
    if (kv_size(virt_lines.data.virt_lines)) {
      decor_range_add_virt(&decor_state, r, c, line2, col2, decor_put_vt(virt_lines, NULL), true);
    }
    if (has_hl) {
      DecorSignHighlight sh = decor_sh_from_inline(hl);
      sh.url = url;
      decor_range_add_sh(&decor_state, r, c, line2, col2, &sh, true, (uint32_t)ns_id, id,
                         subpriority);
    }
  } else {
    if (opts->ephemeral) {
      api_set_error(err, kErrorTypeException,
                    "cannot set emphemeral mark outside of a decoration provider");
      goto error;
    }

    uint16_t decor_flags = 0;

    DecorVirtText *decor_alloc = NULL;
    if (kv_size(virt_text.data.virt_text)) {
      decor_alloc = decor_put_vt(virt_text, decor_alloc);
      if (virt_text.pos == kVPosInline) {
        decor_flags |= MT_FLAG_DECOR_VIRT_TEXT_INLINE;
      }
    }
    if (kv_size(virt_lines.data.virt_lines)) {
      decor_alloc = decor_put_vt(virt_lines, decor_alloc);
      decor_flags |= MT_FLAG_DECOR_VIRT_LINES;
    }

    uint32_t decor_indexed = DECOR_ID_INVALID;

    if (sign.flags & kSHIsSign) {
      sign.next = decor_indexed;
      decor_indexed = decor_put_sh(sign);
      if (sign.text[0]) {
        decor_flags |= MT_FLAG_DECOR_SIGNTEXT;
      }
      if (sign.number_hl_id || sign.line_hl_id || sign.cursorline_hl_id) {
        decor_flags |= MT_FLAG_DECOR_SIGNHL;
      }
    }

    if (has_hl_multiple) {
      Array arr = opts->hl_group.data.array;
      for (size_t i = arr.size - 1; i > 0; i--) {  // skip hl_group[0], handled as hl.hl_id below
        int hl_id = object_to_hl_id(arr.items[i], "hl_group item", err);
        if (hl_id > 0) {
          DecorSignHighlight sh = DECOR_SIGN_HIGHLIGHT_INIT;
          sh.hl_id = hl_id;
          sh.flags = opts->hl_eol ? kSHHlEol : 0;
          sh.next = decor_indexed;
          decor_indexed = decor_put_sh(sh);
          decor_flags |= MT_FLAG_DECOR_HL;
        }
      }
    }

    if (hl.flags & kSHConcealLines) {
      decor_flags |= MT_FLAG_DECOR_CONCEAL_LINES;
    }

    DecorInline decor = DECOR_INLINE_INIT;
    if (decor_alloc || decor_indexed != DECOR_ID_INVALID || url != NULL
        || schar_high(hl.conceal_char)) {
      if (has_hl) {
        DecorSignHighlight sh = decor_sh_from_inline(hl);
        sh.url = url;
        sh.next = decor_indexed;
        decor_indexed = decor_put_sh(sh);
      }
      decor.ext = true;
      decor.data.ext = (DecorExt){ .sh_idx = decor_indexed, .vt = decor_alloc };
    } else {
      decor.data.hl = hl;
    }

    if (has_hl) {
      decor_flags |= MT_FLAG_DECOR_HL;
    }

    extmark_set(b, (uint32_t)ns_id, &id, (int)line, (colnr_T)col, line2, col2,
                decor, decor_flags, right_gravity, opts->end_right_gravity,
                !GET_BOOL_OR_TRUE(opts, set_extmark, undo_restore),
                opts->invalidate, err);
    if (ERROR_SET(err)) {
      decor_free(decor);
      return 0;
    }
  }

  return (Integer)id;

error:
  clear_virttext(&virt_text.data.virt_text);
  clear_virtlines(&virt_lines.data.virt_lines);
  if (url != NULL) {
    xfree(url);
  }

  return 0;
}

/// Removes an |extmark|.
///
/// @param buf Buffer id, or 0 for current buffer
/// @param ns_id Namespace id from |nvim_create_namespace()|
/// @param id Extmark id
/// @param[out] err   Error details, if any
/// @return true if the extmark was found, else false
Boolean nvim_buf_del_extmark(Buffer buf, Integer ns_id, Integer id, Error *err)
  FUNC_API_SINCE(7)
{
  buf_T *b = find_buffer_by_handle(buf, err);

  if (!b) {
    return false;
  }
  VALIDATE_INT(ns_initialized((uint32_t)ns_id), "ns_id", ns_id, {
    return false;
  });

  return extmark_del_id(b, (uint32_t)ns_id, (uint32_t)id);
}

/// Clears |namespace|d objects (highlights, |extmarks|, virtual text) from
/// a region.
///
/// Lines are 0-indexed. |api-indexing|  To clear the namespace in the entire
/// buffer, specify line_start=0 and line_end=-1.
///
/// @param buf     Buffer id, or 0 for current buffer
/// @param ns_id      Namespace to clear, or -1 to clear all namespaces.
/// @param line_start Start of range of lines to clear
/// @param line_end   End of range of lines to clear (exclusive) or -1 to clear
///                   to end of buffer.
/// @param[out] err   Error details, if any
void nvim_buf_clear_namespace(Buffer buf, Integer ns_id, Integer line_start, Integer line_end,
                              Error *err)
  FUNC_API_SINCE(5)
{
  buf_T *b = find_buffer_by_handle(buf, err);
  if (!b) {
    return;
  }

  VALIDATE_RANGE((line_start >= 0 && line_start < MAXLNUM), "line number", {
    return;
  });

  if (line_end < 0 || line_end > MAXLNUM) {
    line_end = MAXLNUM;
  }
  extmark_clear(b, (ns_id < 0 ? 0 : (uint32_t)ns_id),
                (int)line_start, 0,
                (int)line_end - 1, MAXCOL);
}

/// Set or change decoration provider for a |namespace|
///
/// This is a very general purpose interface for having Lua callbacks
/// being triggered during the redraw code.
///
/// The expected usage is to set |extmarks| for the currently
/// redrawn buffer. |nvim_buf_set_extmark()| can be called to add marks
/// on a per-window or per-lines basis. Use the `ephemeral` key to only
/// use the mark for the current screen redraw (the callback will be called
/// again for the next redraw).
///
/// Note: this function should not be called often. Rather, the callbacks
/// themselves can be used to throttle unneeded callbacks. the `on_start`
/// callback can return `false` to disable the provider until the next redraw.
/// Similarly, return `false` in `on_win` will skip the `on_line` and `on_range` calls
/// for that window (but any extmarks set in `on_win` will still be used).
/// A plugin managing multiple sources of decoration should ideally only set
/// one provider, and merge the sources internally. You can use multiple `ns_id`
/// for the extmarks set/modified inside the callback anyway.
///
/// Note: doing anything other than setting extmarks is considered experimental.
/// Doing things like changing options are not explicitly forbidden, but is
/// likely to have unexpected consequences (such as 100% CPU consumption).
/// Doing `vim.rpcnotify` should be OK, but `vim.rpcrequest` is quite dubious
/// for the moment.
///
/// Note: It is not allowed to remove or update extmarks in `on_line` or `on_range` callbacks.
///
/// @param ns_id  Namespace id from |nvim_create_namespace()|
/// @param opts  Table of callbacks:
///             - on_start: called first on each screen redraw
///               ```
///                 ["start", tick]
///               ```
///             - on_buf: called for each buffer being redrawn (once per edit,
///               before window callbacks)
///               ```
///                 ["buf", bufnr, tick]
///               ```
///             - on_win: called when starting to redraw a specific window.
///               ```
///                 ["win", winid, bufnr, toprow, botrow]
///               ```
///             - on_line: (deprecated, use on_range instead)
///               ```
///                 ["line", winid, bufnr, row]
///               ```
///             - on_range: called for each buffer range being redrawn.
///               Range is end-exclusive and may span multiple lines. Range
///               bounds point to the first byte of a character. An end position
///               of the form (lnum, 0), including (number of lines, 0), is valid
///               and indicates that EOL of the preceding line is included.
///               ```
///                 ["range", winid, bufnr, begin_row, begin_col, end_row, end_col]
///               ```
///
///               In addition to returning a boolean, it is also allowed to
///               return a `skip_row, skip_col` pair of integers. This implies
///               that this function does not need to be called until a range
///               which continues beyond the skipped position. A single integer
///               return value `skip_row` is short for `skip_row, 0`
///
///             - on_end: called at the end of a redraw cycle
///               ```
///                 ["end", tick]
///               ```
void nvim_set_decoration_provider(Integer ns_id, Dict(set_decoration_provider) *opts, Error *err)
  FUNC_API_SINCE(7) FUNC_API_LUA_ONLY
{
  DecorProvider *p = get_decor_provider((NS)ns_id, true);
  assert(p != NULL);
  decor_provider_clear(p);

  // regardless of what happens, it seems good idea to redraw
  redraw_all_later(UPD_NOT_VALID);  // TODO(bfredl): too soon?

  struct {
    const char *name;
    LuaRef *source;
    LuaRef *dest;
  } cbs[] = {
    { "on_start", &opts->on_start, &p->redraw_start },
    { "on_buf", &opts->on_buf, &p->redraw_buf },
    { "on_win", &opts->on_win, &p->redraw_win },
    { "on_line", &opts->on_line, &p->redraw_line },
    { "on_range", &opts->on_range, &p->redraw_range },
    { "on_end", &opts->on_end, &p->redraw_end },
    { "_on_hl_def", &opts->_on_hl_def, &p->hl_def },
    { "_on_spell_nav", &opts->_on_spell_nav, &p->spell_nav },
    { "_on_conceal_line", &opts->_on_conceal_line, &p->conceal_line },
    { NULL, NULL, NULL },
  };

  for (size_t i = 0; cbs[i].source && cbs[i].dest && cbs[i].name; i++) {
    LuaRef *v = cbs[i].source;
    if (*v <= 0) {
      continue;
    }

    *(cbs[i].dest) = *v;
    *v = LUA_NOREF;
  }

  p->state = kDecorProviderActive;
  p->hl_valid++;
  p->hl_cached = false;
}

/// Gets the line and column of an |extmark|.
///
/// Extmarks may be queried by position, name or even special names
/// in the future such as "cursor".
///
/// @param[out] lnum extmark line
/// @param[out] colnr extmark column
///
/// @return true if the extmark was found, else false
static bool extmark_get_index_from_obj(buf_T *buf, Integer ns_id, Object obj, int *row,
                                       colnr_T *col, Error *err)
{
  // Check if it is mark id
  if (obj.type == kObjectTypeInteger) {
    Integer id = obj.data.integer;
    if (id == 0) {
      *row = 0;
      *col = 0;
      return true;
    } else if (id == -1) {
      *row = MAXLNUM;
      *col = MAXCOL;
      return true;
    } else if (id < 0) {
      VALIDATE_INT(false, "mark id", id, {
        return false;
      });
    }

    MTPair extmark = extmark_from_id(buf, (uint32_t)ns_id, (uint32_t)id);

    VALIDATE_INT((extmark.start.pos.row >= 0), "mark id (not found)", id, {
      return false;
    });
    *row = extmark.start.pos.row;
    *col = extmark.start.pos.col;
    return true;

    // Check if it is a position
  } else if (obj.type == kObjectTypeArray) {
    Array pos = obj.data.array;
    VALIDATE_EXP((pos.size == 2
                  && pos.items[0].type == kObjectTypeInteger
                  && pos.items[1].type == kObjectTypeInteger),
                 "mark position", "2 Integer items", NULL, {
      return false;
    });

    Integer pos_row = pos.items[0].data.integer;
    Integer pos_col = pos.items[1].data.integer;
    *row = (int)(pos_row >= 0 ? pos_row : MAXLNUM);
    *col = (colnr_T)(pos_col >= 0 ? pos_col : MAXCOL);
    return true;
  } else {
    VALIDATE_EXP(false, "mark position", "mark id Integer or 2-item Array", NULL, {
      return false;
    });
  }
}

VirtText parse_virt_text(Array chunks, Error *err, int *width)
{
  VirtText virt_text = KV_INITIAL_VALUE;
  int w = 0;
  for (size_t i = 0; i < chunks.size; i++) {
    VALIDATE_T("chunk", kObjectTypeArray, chunks.items[i].type, {
      goto free_exit;
    });
    Array chunk = chunks.items[i].data.array;
    VALIDATE((chunk.size > 0 && chunk.size <= 2 && chunk.items[0].type == kObjectTypeString),
             "%s", "Invalid chunk: expected Array with 1 or 2 Strings", {
      goto free_exit;
    });

    String str = chunk.items[0].data.string;

    int hl_id = -1;
    if (chunk.size == 2) {
      Object hl = chunk.items[1];
      if (hl.type == kObjectTypeArray) {
        Array arr = hl.data.array;
        for (size_t j = 0; j < arr.size; j++) {
          hl_id = object_to_hl_id(arr.items[j], "virt_text highlight", err);
          if (ERROR_SET(err)) {
            goto free_exit;
          }
          if (j < arr.size - 1) {
            kv_push(virt_text, ((VirtTextChunk){ .text = NULL, .hl_id = hl_id }));
          }
        }
      } else {
        hl_id = object_to_hl_id(hl, "virt_text highlight", err);
        if (ERROR_SET(err)) {
          goto free_exit;
        }
      }
    }

    char *text = transstr(str.size > 0 ? str.data : "", false);  // allocates
    w += (int)mb_string2cells(text);

    kv_push(virt_text, ((VirtTextChunk){ .text = text, .hl_id = hl_id }));
  }

  if (width != NULL) {
    *width = w;
  }
  return virt_text;

free_exit:
  clear_virttext(&virt_text);
  return virt_text;
}

/// @nodoc
String nvim__buf_debug_extmarks(Buffer buf, Boolean keys, Boolean dot, Error *err)
  FUNC_API_SINCE(7) FUNC_API_RET_ALLOC
{
  buf_T *b = find_buffer_by_handle(buf, err);
  if (!b) {
    return NULL_STRING;
  }

  return mt_inspect(b->b_marktree, keys, dot);
}

/// Set some properties for namespace
///
/// @param ns_id Namespace
/// @param opts Optional parameters to set:
///           - wins: a list of windows to be scoped in
///
void nvim__ns_set(Integer ns_id, Dict(ns_opts) *opts, Error *err)
{
  VALIDATE_INT(ns_initialized((uint32_t)ns_id), "ns_id", ns_id, {
    return;
  });

  bool set_scoped = true;

  if (HAS_KEY(opts, ns_opts, wins)) {
    if (opts->wins.size == 0) {
      set_scoped = false;
    }

    Set(ptr_t) windows = SET_INIT;
    for (size_t i = 0; i < opts->wins.size; i++) {
      Integer win = opts->wins.items[i].data.integer;

      win_T *wp = find_window_by_handle((Window)win, err);
      if (!wp) {
        return;
      }

      set_put(ptr_t, &windows, wp);
    }

    FOR_ALL_TAB_WINDOWS(tp, wp) {
      if (set_has(ptr_t, &windows, wp) && !set_has(uint32_t, &wp->w_ns_set, (uint32_t)ns_id)) {
        set_put(uint32_t, &wp->w_ns_set, (uint32_t)ns_id);

        if (map_has(uint32_t, wp->w_buffer->b_extmark_ns, (uint32_t)ns_id)) {
          changed_window_setting(wp);
        }
      }

      if (set_has(uint32_t, &wp->w_ns_set, (uint32_t)ns_id) && !set_has(ptr_t, &windows, wp)) {
        set_del(uint32_t, &wp->w_ns_set, (uint32_t)ns_id);

        if (map_has(uint32_t, wp->w_buffer->b_extmark_ns, (uint32_t)ns_id)) {
          changed_window_setting(wp);
        }
      }
    }

    set_destroy(ptr_t, &windows);
  }

  if (set_scoped && !set_has(uint32_t, &namespace_localscope, (uint32_t)ns_id)) {
    set_put(uint32_t, &namespace_localscope, (uint32_t)ns_id);

    // When a namespace becomes scoped, any window which contains
    // elements associated with namespace needs to be redrawn
    FOR_ALL_TAB_WINDOWS(tp, wp) {
      if (map_has(uint32_t, wp->w_buffer->b_extmark_ns, (uint32_t)ns_id)) {
        changed_window_setting(wp);
      }
    }
  } else if (!set_scoped && set_has(uint32_t, &namespace_localscope, (uint32_t)ns_id)) {
    set_del(uint32_t, &namespace_localscope, (uint32_t)ns_id);

    // When a namespace becomes unscoped, any window which does not
    // contain elements associated with namespace needs to be redrawn
    FOR_ALL_TAB_WINDOWS(tp, wp) {
      if (map_has(uint32_t, wp->w_buffer->b_extmark_ns, (uint32_t)ns_id)) {
        changed_window_setting(wp);
      }
    }
  }
}

/// Get the properties for namespace
///
/// @param ns_id Namespace
/// @return  Map defining the namespace properties, see |nvim__ns_set()|
Dict(ns_opts) nvim__ns_get(Integer ns_id, Arena *arena, Error *err)
{
  Dict(ns_opts) opts = KEYDICT_INIT;

  Array windows = ARRAY_DICT_INIT;

  PUT_KEY(opts, ns_opts, wins, windows);

  VALIDATE_INT(ns_initialized((uint32_t)ns_id), "ns_id", ns_id, {
    return opts;
  });

  if (!set_has(uint32_t, &namespace_localscope, (uint32_t)ns_id)) {
    return opts;
  }

  size_t count = 0;
  FOR_ALL_TAB_WINDOWS(tp, wp) {
    if (set_has(uint32_t, &wp->w_ns_set, (uint32_t)ns_id)) {
      count++;
    }
  }

  windows = arena_array(arena, count);

  FOR_ALL_TAB_WINDOWS(tp, wp) {
    if (set_has(uint32_t, &wp->w_ns_set, (uint32_t)ns_id)) {
      ADD(windows, INTEGER_OBJ(wp->handle));
    }
  }

  PUT_KEY(opts, ns_opts, wins, windows);

  return opts;
}
