/////////////////////////////////////////////
// TEMP until I implement more generic language stuff
/////////////////////////////////////////////

#include "languages/tree_sitter_cpp.h"
#include "languages/tree_sitter_jai.h"
#include "languages/tree_sitter_bash.h"

////////////////////////////////////////////////////////////////////
// Language Management
////////////////////////////////////////////////////////////////////

function TSQuery*
tree_sitter_query_new(Application_Links* app, TSLanguage* language, String_Const_u8 query_string)
{
  u32 error_offset;
  TSQueryError query_error;

  TSQuery* result = ts_query_new(
    language, (const char *)query_string.str, (u32)query_string.size,
    &error_offset, &query_error
  );

  if (!result)
  {
    print_message(app, SCu8("Error creating query\n"));
    printf("%.*s\n", (int)Min(query_string.size-error_offset, 100), query_string.str + error_offset);
  }

  return result;
}

function void
tree_sitter_register_language(String_Const_u8 ext, TSLanguage* language, Tree_Sitter_Language_Queries queries, Tree_Sitter_Language_Flags flags)
{
  Tree_Sitter_Language_Definition* lang = 0;
  u64 hash = table_hash_u8(ext.str, ext.size);
  u64 slot = hash % ArrayCount(tree_sitter_languages.languages);
  for (Tree_Sitter_Language_Definition* l = tree_sitter_languages.languages[slot]; l != 0; l = l->next)
  {
    if (l->extension_hash == hash && string_match(l->extension, ext))
    {
      lang = l; break;
    }
  }

  if (lang == 0)
  {
    lang = push_array(&tree_sitter_languages.arena, Tree_Sitter_Language_Definition, 1);
    lang->next = tree_sitter_languages.languages[slot];
    tree_sitter_languages.languages[slot] = lang;

    lang->extension_hash = hash;
    lang->extension = push_string_copy(&tree_sitter_languages.arena, ext);
    lang->language = language;
    lang->queries = queries;
    lang->flags = flags;
  }
}

function Tree_Sitter_Language_Definition*
tree_sitter_language_from_file_extension(String_Const_u8 ext)
{
  Tree_Sitter_Language_Definition* result = 0;
  u64 ext_hash = table_hash_u8(ext.str, ext.size);
  u64 slot = ext_hash % ArrayCount(tree_sitter_languages.languages);
  for (Tree_Sitter_Language_Definition* l = tree_sitter_languages.languages[slot]; l != 0; l = l->next)
  {
    if (l->extension_hash == ext_hash && string_match(l->extension, ext))
    {
      result = l;
      break;
    }
  }
  return result;
}

function Tree_Sitter_Language_Definition*
tree_sitter_language_for_buffer(Application_Links* app, Buffer_ID buffer_id, Arena* arena)
{
  Tree_Sitter_Language_Definition* result = 0;
  String_Const_u8 file_name = push_buffer_file_name(app, arena, buffer_id);
  String_Const_u8 extension = string_file_extension(file_name);
  result = tree_sitter_language_from_file_extension(extension);
  return result;
}

function Tree_Sitter_Language_Definition*
tree_sitter_language_for_buffer(Application_Links* app, Buffer_ID buffer_id)
{
  Scratch_Block scratch(app);
  return tree_sitter_language_for_buffer(app, buffer_id, scratch);
}

/////////////////////////////////////////////
// Tree Sitter Hook Internals
/////////////////////////////////////////////

function void
tree_sitter_init(Application_Links* app)
{
  Buffer_ID buffer = create_buffer(
    app,
    string_u8_litexpr("*tree*"),
    BufferCreate_NeverAttachToFile | BufferCreate_AlwaysNew
  );
  buffer_set_setting(app, buffer, BufferSetting_Unimportant, true);
  buffer_set_setting(app, buffer, BufferSetting_ReadOnly, true);

  tree_sitter_languages.arena = make_arena_system(KB(16));

  tree_sitter_register_cpp(app);
  tree_sitter_register_jai(app);
  tree_sitter_register_bash(app);
}

function void
tree_sitter_begin_buffer(Application_Links* app, Buffer_ID buffer_id)
{
  Managed_Scope buffer_scope = buffer_get_managed_scope(app, buffer_id);
  Buffer_Tree_Sitter_Data* tree_data = scope_attachment(app, buffer_scope, buffer_tree_sitter_data_id, Buffer_Tree_Sitter_Data);
  tree_data->tree_mutex = system_mutex_make();
}

function void
tree_sitter_end_buffer(Application_Links* app, Buffer_ID buffer_id)
{
  Managed_Scope buffer_scope = buffer_get_managed_scope(app, buffer_id);

  Async_Task *tree_sitter_parse_task = scope_attachment(app, buffer_scope, buffer_tree_sitter_parse_task_id, Async_Task);
  if (tree_sitter_parse_task && async_task_is_running_or_pending(&global_async_system, *tree_sitter_parse_task))
  {
    async_task_cancel(app, &global_async_system, *tree_sitter_parse_task);
  }

  Buffer_Tree_Sitter_Data* tree_data = scope_attachment(app, buffer_scope, buffer_tree_sitter_data_id, Buffer_Tree_Sitter_Data);
  if (!tree_data || !tree_data->tree) return;
  system_mutex_acquire(tree_data->tree_mutex);
    ts_tree_delete(tree_data->tree);
  system_mutex_release(tree_data->tree_mutex);
  system_mutex_free(tree_data->tree_mutex);
}

function TSTree*
tree_sitter_buffer_get_tree_copy(Buffer_Tree_Sitter_Data* tree_data)
{
  TSTree* result = 0;
  // system_mutex_acquire(tree_data->tree_mutex);
  if (tree_data->tree) result = ts_tree_copy(tree_data->tree);
  // system_mutex_release(tree_data->tree_mutex);
  return result;
}

////////////////////////////////////////////////////////////////////
// Queries
////////////////////////////////////////////////////////////////////

function Tree_Sitter_Query_Cursor
tree_sitter_query_init(Application_Links* app, Buffer_ID buffer_id, TSQuery* query)
{
  Tree_Sitter_Query_Cursor result = {};
  result.buffer_id = buffer_id;
  result.query = query;
  result.ok = false;

  Managed_Scope buffer_scope = buffer_get_managed_scope(app, buffer_id);
  Buffer_Tree_Sitter_Data* tree_data = scope_attachment(app, buffer_scope, buffer_tree_sitter_data_id, Buffer_Tree_Sitter_Data);
  result.tree = tree_sitter_buffer_get_tree_copy(tree_data);
  if (result.tree) result.first_node = ts_tree_root_node(result.tree);

  result.ok = (
    result.query != 0 &&
    result.tree  != 0
  );
  return result;
}

function bool
tree_sitter_query_continue(Tree_Sitter_Query_Cursor* cursor, TSQueryMatch* match, u32* capture_index)
{
  if (cursor->ok)
  {
    if (!cursor->query_cursor)
    {
      cursor->query_cursor = ts_query_cursor_new();
      ts_query_cursor_exec(cursor->query_cursor, cursor->query, cursor->first_node);
    }

    cursor->ok = ts_query_cursor_next_capture(cursor->query_cursor, match, capture_index);
  }
  return cursor->ok;
}

function void
tree_sitter_query_end(Tree_Sitter_Query_Cursor* cursor)
{
  if (cursor->query_cursor) ts_query_cursor_delete(cursor->query_cursor);
  ts_tree_delete(cursor->tree);
}

////////////////////////////////////////////////////////////////////
// Tree Parsing
////////////////////////////////////////////////////////////////////

function void
tree_sitter_parse_async__inner(Async_Context* actx, Buffer_ID buffer_id)
{
  Application_Links *app = actx->app;

  Arena arena = make_arena_system(KB(16));

  TSParser *parser = ts_parser_new();
  ts_parser_set_timeout_micros(parser, 5000);

  acquire_global_frame_mutex(app);
    Scratch_Block scratch(app);
    String_Const_u8 buffer_name = push_buffer_unique_name(app, scratch, buffer_id);
    Tree_Sitter_Language_Definition* lang = tree_sitter_language_for_buffer(app, buffer_id);
    String_Const_u8 src = push_whole_buffer(app, &arena, buffer_id);
    Managed_Scope scope = buffer_get_managed_scope(app, buffer_id);
    Buffer_Tree_Sitter_Data* tree_data = scope_attachment(app, scope, buffer_tree_sitter_data_id, Buffer_Tree_Sitter_Data);
    TSTree *old_tree = tree_sitter_buffer_get_tree_copy(tree_data);
    bool lang_set = ts_parser_set_language(parser, lang->language);
  release_global_frame_mutex(app);

  if (!lang_set)
  {
    AssertMessageAlways("Failed to set the language for the parser."
                        "This probably means a language wasn't set"
                        "in the BeginBuffer hook.\n");
  }

  // Iterate until we get a tree or we find that we should cancel the parse
  TSTree *new_tree = 0;
  b32 canceled = false;
  for (;;)
  {
    new_tree = ts_parser_parse_string(parser, old_tree, (char *)src.str, (u32)src.size);
    if (async_check_canceled(actx))
    {
        canceled = true;
        break;
    }
    if (new_tree) break;
  }

  if (!canceled && new_tree)
  {
    TSTree* old_buffer_tree;
    acquire_global_frame_mutex(app);
    {
      // NOTE(jack): Copy the old pointer to delete it outside the mutex.
      system_mutex_acquire(tree_data->tree_mutex);
      old_buffer_tree = tree_data->tree;
      tree_data->tree = new_tree;
      system_mutex_acquire(tree_data->tree_mutex);

      Tree_Sitter_Code_Index_Parse_State parse_state = tree_sitter_code_index_update_single_buffer(app, buffer_id);
      code_index_lock();
      code_index_set_file(parse_state.buffer_id, parse_state.index_arena, parse_state.index);
      code_index_unlock();

      // Force a frame refresh by requesting another frame
      animate_in_n_milliseconds(app, 0);
    }
    release_global_frame_mutex(app);
    ts_tree_delete(old_buffer_tree);
  }

  ts_parser_delete(parser);
  ts_tree_delete(old_tree);
  linalloc_clear(&arena);
}

function void
tree_sitter_parse_async(Async_Context* actx, String_Const_u8 data)
{
  if (data.size != sizeof(Buffer_ID)) return;
  Buffer_ID buffer_id = *(Buffer_ID*)data.str;
  tree_sitter_parse_async__inner(actx, buffer_id);
}

function Range_i64
tree_sitter_node_to_range(TSNode node)
{
  Range_i64 result;
  result.start = ts_node_start_byte(node);
  result.end   = ts_node_end_byte(node);
  return result;
}

function Code_Index_Note*
code_index_new_note(Code_Index_File* index, Arena* arena, Code_Index_Note_Kind kind, Range_i64 range, Code_Index_Nest_Stack* parent)
{
  Code_Index_Note *result = push_array(arena, Code_Index_Note, 1);
  sll_queue_push(index->note_list.first, index->note_list.last, result);
  index->note_list.count += 1;
  result->file = index;
  result->note_kind = kind;
  result->pos = range;
  if (parent != 0) result->parent = parent->nest;
  return result;
}

function Tree_Sitter_Code_Index_Parse_State
tree_sitter_code_index_update_single_buffer(Application_Links* app, Buffer_ID buffer_id)
{
  Scratch_Block scratch(app);

  Tree_Sitter_Code_Index_Parse_State parse_state = {};
  parse_state.ok = false;
  parse_state.buffer_id = buffer_id;
  parse_state.language = tree_sitter_language_for_buffer(app, parse_state.buffer_id);
  if (!parse_state.language) return parse_state;

  parse_state.index_arena = make_arena_system(KB(16));
  parse_state.index = push_array_zero(&parse_state.index_arena, Code_Index_File, 1);
  parse_state.buffer_contents = push_whole_buffer(app, scratch, parse_state.buffer_id);
  parse_state.query = tree_sitter_query_init(
    app, parse_state.buffer_id, parse_state.language->queries.ptr[Tree_Sitter_Language_Query_Tags]
  );
  parse_state.nest_stack_first = 0;
  parse_state.nest_stack_last = 0;
  parse_state.last_note = 0;
  parse_state.last_note_match_id = max_u32;

  TSQueryMatch query_match;
  u32 capture_index;
  while (tree_sitter_query_continue(&parse_state.query, &query_match, &capture_index))
  {
    TSQueryCapture type_capture = query_match.captures[capture_index];

    TSNode type_node = type_capture.node;
    Range_i64 type_range = tree_sitter_node_to_range(type_node);

    u32 length;
    const char* tmp = ts_query_capture_name_for_id(parse_state.query.query, type_capture.index, &length);
    String_Const_u8 capture_name = SCu8((char*)tmp, length);

    if (string_match(capture_name, SCu8("scope_begin")))
    {
      Code_Index_Nest* nest = push_array_zero(&parse_state.index_arena, Code_Index_Nest, 1);
      nest->kind = CodeIndexNest_Scope;
      nest->open = type_range;
      nest->close = Ii64(max_i64);
      nest->file = parse_state.index;
      if (parse_state.nest_stack_last != 0)
      {
        nest->parent = parse_state.nest_stack_last->nest;
        code_index_push_nest(&nest->parent->nest_list, nest);
      }

      Code_Index_Nest_Stack* stack = push_array_zero(scratch, Code_Index_Nest_Stack, 1);
      stack->nest = nest;
      stack->prev = parse_state.nest_stack_last;
      stack->match_id = query_match.id;
      if (parse_state.nest_stack_last != 0) parse_state.nest_stack_last->next = stack;
      else                      parse_state.nest_stack_first      = stack;
      parse_state.nest_stack_last = stack;
    }
    else if (string_match(capture_name, SCu8("scope_end")))
    {
      Assert(parse_state.nest_stack_last != 0);
      Assert(parse_state.nest_stack_last->match_id == query_match.id);

      Code_Index_Nest* nest = parse_state.nest_stack_last->nest;
      nest->close = type_range;
      nest->is_closed = true;
      nest->nest_array = code_index_nest_ptr_array_from_list(&parse_state.index_arena, &nest->nest_list);
      if (nest->parent == 0) code_index_push_nest(&parse_state.index->nest_list, nest);

      parse_state.nest_stack_last = parse_state.nest_stack_last->prev;
      if (parse_state.nest_stack_last != 0) parse_state.nest_stack_last->next = 0;
    }
    else if (string_match(capture_name, SCu8("definition.class")))
    {
      parse_state.last_note = code_index_new_note(parse_state.index, &parse_state.index_arena, CodeIndexNote_Type, type_range, parse_state.nest_stack_last);
      parse_state.last_note_match_id = query_match.id;
    }
    else if (string_match(capture_name, SCu8("definition.function")))
    {
      parse_state.last_note = code_index_new_note(parse_state.index, &parse_state.index_arena, CodeIndexNote_Function, type_range, parse_state.nest_stack_last);
      parse_state.last_note_match_id = query_match.id;
    }
    else if (string_match(capture_name, SCu8("definition.method")))
    {
      parse_state.last_note = code_index_new_note(parse_state.index, &parse_state.index_arena, CodeIndexNote_Function, type_range, parse_state.nest_stack_last);;
      parse_state.last_note_match_id = query_match.id;
    }
    else if (string_match(capture_name, SCu8("definition.type")))
    {
      parse_state.last_note = code_index_new_note(parse_state.index, &parse_state.index_arena, CodeIndexNote_Type, type_range, parse_state.nest_stack_last);
      parse_state.last_note_match_id = query_match.id;
    }
    else if (string_match(capture_name, SCu8("name")))
    {
      if (parse_state.last_note != 0 && parse_state.last_note_match_id == query_match.id)
      {
        parse_state.last_note->pos = Ii64_size(type_range.start, type_range.end - type_range.start);
      }
    }
  }

  while (parse_state.nest_stack_last != 0)
  {
    Code_Index_Nest* nest = parse_state.nest_stack_last->nest;
    if (nest->parent != 0) code_index_push_nest(&nest->parent->nest_list, nest);
    else                   code_index_push_nest(&parse_state.index->nest_list, nest);
    nest->nest_array = code_index_nest_ptr_array_from_list(&parse_state.index_arena, &nest->nest_list);
    parse_state.nest_stack_last = parse_state.nest_stack_last->prev;
  }

  for (Code_Index_Note* note = parse_state.index->note_list.first; note != 0 && note->next != note; note = note->next)
  {
    note->text = push_string_copy(&parse_state.index_arena, string_substring(parse_state.buffer_contents, note->pos));
  }

  // Finish the Index
  parse_state.index->nest_array = code_index_nest_ptr_array_from_list(&parse_state.index_arena, &parse_state.index->nest_list);
  parse_state.index->note_array = code_index_note_ptr_array_from_list(&parse_state.index_arena, &parse_state.index->note_list);

  tree_sitter_query_end(&parse_state.query);

  parse_state.ok = true;
  return parse_state;
}

function void
tree_sitter_code_index_update_tick(Application_Links* app)
{
#define BUFFERED_CODE_INDICES_CAP 8
  Tree_Sitter_Code_Index_Parse_State buffered_code_indices[BUFFERED_CODE_INDICES_CAP];
  u32 buffered_code_indices_count = 0;

  Tree_Sitter_Code_Index_Parse_State parse_state = {};
  for (Buffer_Modified_Node* modified_node = global_buffer_modified_set.first;
       modified_node != 0;
       modified_node = modified_node->next
  ){
    parse_state = tree_sitter_code_index_update_single_buffer(app, modified_node->buffer);
    if (parse_state.ok)
    {
      buffered_code_indices[buffered_code_indices_count] = parse_state;
      buffered_code_indices_count += 1;
    }

    if (buffered_code_indices_count >= BUFFERED_CODE_INDICES_CAP)
    {
      code_index_lock();
      for (int i = 0; i < buffered_code_indices_count; i++)
      {
        parse_state = buffered_code_indices[i];
        code_index_set_file(parse_state.buffer_id, parse_state.index_arena, parse_state.index);
      }
      buffered_code_indices_count = 0;
      code_index_unlock();
    }

    buffer_clear_layout_cache(app, parse_state.buffer_id);
  }

  if (buffered_code_indices_count > 0)
  {
    code_index_lock();
    for (int i = 0; i < buffered_code_indices_count; i++)
    {
      parse_state = buffered_code_indices[i];
      code_index_set_file(parse_state.buffer_id, parse_state.index_arena, parse_state.index);
    }
    code_index_unlock();
  }

  buffer_modified_set_clear();
}

////////////////////////////////////////////////////////////////////
// Async Management
////////////////////////////////////////////////////////////////////

function void
async_task_cancel_nowait(Application_Links* app, Async_System* async_system, Async_Task task)
{
  system_mutex_acquire(async_system->mutex);
  Async_Node *node = async_get_pending_node(async_system, task);
  if (node != 0)
  {
    dll_remove(&node->node);
    async_system->task_count -= 1;
    async_free_node(async_system, node);
  }
  else
  {
    node = async_get_running_node(async_system, task);
    if (node != 0)
    {
      b32 *cancel_signal = &node->thread->cancel_signal;
      atomic_write_b32(cancel_signal, true);
      // async_task_wait__inner(app, async_system, task);
    }
  }
  system_mutex_release(async_system->mutex);
}

////////////////////////////////////////////////////////////////////
// Token Highlighting
////////////////////////////////////////////////////////////////////

function bool
tree_sitter_highlight_node(
  Application_Links* app,
  TSQuery* query,
  TSNode top_node,
  TSQueryCursor* query_cursor,
  Text_Layout_ID text_layout_id
){
  bool highlighted_any_code = false;
  ts_query_cursor_exec(query_cursor, query, top_node);

  TSQueryMatch query_match;
  u32 capture_index;
  while (ts_query_cursor_next_capture(query_cursor, &query_match, &capture_index))
  {
    TSQueryCapture capture = query_match.captures[capture_index];
    TSNode node = capture.node;

    u32 length;
    const char* tmp = ts_query_capture_name_for_id(query, capture.index, &length);
    String_Const_u8 capture_name = SCu8((char*)tmp, length);

    // TODO(PS): let each language provide a custom override
    String_Const_u8 color_name = SCu8("defcolor_text_default");
    if (string_match(capture_name, SCu8("function"))) {
      color_name = SCu8("defcolor_function");
    } else if (string_match(capture_name, SCu8("type"))) {
      color_name = SCu8("defcolor_type");
    } else if (string_match(capture_name, SCu8("constant")) || string_match(capture_name, SCu8("number"))) {
      color_name = SCu8("defcolor_int_constant");
    } else if (string_match(capture_name, SCu8("keyword"))) {
      color_name = SCu8("defcolor_keyword");
    } else if (string_match(capture_name, SCu8("string"))) {
      color_name = SCu8("defcolor_str_constant");
    } else if (string_match(capture_name, SCu8("comment"))) {
      color_name = SCu8("defcolor_comment");
    }

    Range_i64 highlight_range = tree_sitter_node_to_range(node);
    Managed_ID color_id = managed_id_get(app, SCu8("colors"), color_name);
    if (color_id != 0)
    {
      paint_text_color_fcolor(app, text_layout_id, highlight_range, fcolor_id(color_id));
    }

    highlighted_any_code = true;
  }

  return highlighted_any_code;
}

function void
draw_tree_sitter_node_colors(Application_Links* app, Text_Layout_ID text_layout_id, Buffer_ID buffer_id)
{
  Tree_Sitter_Language_Definition* lang = tree_sitter_language_for_buffer(app, buffer_id);
  TSQuery* query = lang->queries.ptr[Tree_Sitter_Language_Query_Highlights];

  Range_i64 visible_range = text_layout_get_visible_range(app, text_layout_id);
  Managed_Scope buffer_scope = buffer_get_managed_scope(app, buffer_id);
  Buffer_Tree_Sitter_Data* tree_data = scope_attachment(app, buffer_scope, buffer_tree_sitter_data_id, Buffer_Tree_Sitter_Data);
  TSTree* tree = tree_sitter_buffer_get_tree_copy(tree_data);
  if (tree)
  {
    TSNode root = ts_tree_root_node(tree);
    // Get the smallest node that fully contains the visible range
    TSNode visible_container = ts_node_descendant_for_byte_range(root, (u32)visible_range.start, (u32)visible_range.end);
    TSQueryCursor* query_cursor = ts_query_cursor_new();
    if (ts_node_eq(root, visible_container))
    {
      TSTreeCursor tree_cursor = ts_tree_cursor_new(visible_container);
      if (ts_tree_cursor_goto_first_child_for_byte(&tree_cursor, (u32)visible_range.start) != -1)
      {
        do {
          TSNode node = ts_tree_cursor_current_node(&tree_cursor);
          Range_i64 child_range = tree_sitter_node_to_range(node);
          if (child_range.start > visible_range.end) break;
          tree_sitter_highlight_node(app, query, node, query_cursor, text_layout_id);
        } while(ts_tree_cursor_goto_next_sibling(&tree_cursor));
      }
      else
      {
        // Pathological case - just highligh the whole document. This is probably bad
        tree_sitter_highlight_node(app, query, root, query_cursor, text_layout_id);
      }
    }
    else
    {
      bool should_ascend = false;
      do {
        should_ascend = !tree_sitter_highlight_node(app, query, visible_container, query_cursor, text_layout_id);
        if (should_ascend) visible_container = ts_node_parent(visible_container);
      } while (should_ascend && !ts_node_is_null(visible_container));
    }
    ts_query_cursor_delete(query_cursor);
  }
  ts_tree_delete(tree);
}

////////////////////////////////////////////////////////////////////
// Lists
////////////////////////////////////////////////////////////////////

function String_Const_u8
convert_to_single_line_in_place(String_Const_u8 str)
{
  String_Const_u8 result = str;
  int dst = 0;
  for (int src = 0; src < str.size; src++)
  {
    if (str.str[src] == '\n')
    {
      while (src < str.size && character_is_whitespace(str.str[src])) { src += 1; }
      if (src >= str.size) break;
      else {
        result.str[dst] = ' ';
        dst += 1;
      }
    }
    result.str[dst] = str.str[src];
    dst += 1;
  }
  result.size = dst;
  return result;
}

function void
print_position(
  Application_Links* app,
  Buffer_Insertion* out,
  Buffer_ID buffer,
  String_Const_u8 buffer_name,
  Range_i64 buffer_range,
  String_Const_u8 prefix,
  Arena* arena,
  bool newlines_to_spaces
){
  i64 line_number = get_line_number_from_pos(app, buffer, buffer_range.start);
  insertf(out, "%.*s:%lld: ", string_expand(buffer_name), line_number);

  if (prefix.size > 0) insertf(out, "%.*s ", string_expand(prefix));

  Temp_Memory token_temp = begin_temp(arena);
    String_Const_u8 line = push_buffer_range(app, arena, buffer, buffer_range);
    if (newlines_to_spaces) line = convert_to_single_line_in_place(line);
    insert_string(out, line);
  end_temp(token_temp);

  insertc(out, '\n');
}

function void
tree_sitter_list_all_query_results(
  Application_Links *app,
  Buffer_ID optional_target_buffer,
  Code_Index_Note_Kind note_kind
){
  String_Const_u8 decls_name = string_u8_litexpr("*decls*");
  Buffer_ID decls_buffer = get_buffer_by_name(app, decls_name, Access_Always);
  if (!buffer_exists(app, decls_buffer))
  {
    decls_buffer = create_buffer(app, decls_name, BufferCreate_AlwaysNew);
    buffer_set_setting(app, decls_buffer, BufferSetting_Unimportant, true);
    buffer_set_setting(app, decls_buffer, BufferSetting_ReadOnly, true);
  }
  else
  {
    clear_buffer(app, decls_buffer);
    buffer_send_end_signal(app, decls_buffer);
  }

  Scratch_Block scratch(app);

  Cursor insertion_cursor = make_cursor(push_array(scratch, u8, KB(256)), KB(256));
  Buffer_Insertion out = begin_buffer_insertion_at_buffered(app, decls_buffer, 0, &insertion_cursor);

  code_index_lock();
  for (Buffer_ID buffer_it = get_buffer_next(app, 0, Access_Always);
      buffer_it != 0;
      buffer_it = get_buffer_next(app, buffer_it, Access_Always))
  {
    Buffer_ID buffer = buffer_it;
    if (optional_target_buffer != 0) buffer = optional_target_buffer;
    String_Const_u8 buffer_name = push_buffer_unique_name(app, scratch, buffer);
    Code_Index_File* file = code_index_get_file(buffer);
    if (file != 0)
    {
      for (i32 i = 0; i < file->note_array.count; i += 1)
      {
        Code_Index_Note *note = file->note_array.ptrs[i];
        if (note->note_kind == note_kind)
        {
          print_position(
            app, &out, buffer, buffer_name, note->pos, {}, scratch, true
          );
        }
      }
    }

    if (optional_target_buffer != 0) break;
  }
  code_index_unlock();

  end_buffer_insertion(&out);

  View_ID view = get_active_view(app, Access_Always);
  view_set_buffer(app, view, decls_buffer, 0);

  lock_jump_buffer(app, decls_name);
}

CUSTOM_COMMAND_SIG(tree_sitter_list_all_functions_current_buffer)
CUSTOM_DOC("Creates a jump list of lines of the current buffer that appear to define or declare functions. Uses tree sitter")
{
  View_ID view = get_active_view(app, Access_ReadVisible);
  Buffer_ID buffer = view_get_buffer(app, view, Access_ReadVisible);
  if (buffer != 0) tree_sitter_list_all_query_results(app, buffer, CodeIndexNote_Function);
}

CUSTOM_UI_COMMAND_SIG(tree_sitter_list_all_functions_current_buffer_lister)
CUSTOM_DOC("Creates a lister of locations that look like function definitions and declarations in the buffer. Uses tree sitter")
{
  Heap *heap = &global_heap;
  View_ID view = get_active_view(app, Access_ReadVisible);
  Buffer_ID buffer = view_get_buffer(app, view, Access_ReadVisible);
  if (buffer != 0)
  {
    tree_sitter_list_all_query_results(app, buffer, CodeIndexNote_Function);
    view = get_active_view(app, Access_Always);
    buffer = view_get_buffer(app, view, Access_Always);
    Marker_List *list = get_or_make_list_for_buffer(app, heap, buffer);
    if (list != 0)
    {
      Jump_Lister_Result jump = get_jump_index_from_user(app, list, "Function:");
      jump_to_jump_lister_result(app, view, list, &jump);
    }
  }
}

CUSTOM_COMMAND_SIG(tree_sitter_list_all_functions_all_buffers)
CUSTOM_DOC("Creates a jump list of lines from all buffers that appear to define or declare functions. Uses tree sitter")
{
  tree_sitter_list_all_query_results(app, 0, CodeIndexNote_Function);
}

CUSTOM_UI_COMMAND_SIG(tree_sitter_list_all_functions_all_buffers_lister)
CUSTOM_DOC("Creates a lister of locations that look like function definitions and declarations all buffers. Uses tree sitter")
{
  Heap *heap = &global_heap;
  tree_sitter_list_all_query_results(app, 0, CodeIndexNote_Function);
  View_ID view = get_active_view(app, Access_Always);
  Buffer_ID buffer = view_get_buffer(app, view, Access_Always);
  Marker_List *list = get_or_make_list_for_buffer(app, heap, buffer);
  if (list != 0)
  {
    Jump_Lister_Result jump = get_jump_index_from_user(app, list, "Function:");
    jump_to_jump_lister_result(app, view, list, &jump);
  }
}

CUSTOM_COMMAND_SIG(tree_sitter_list_all_types_current_buffer)
CUSTOM_DOC("Creates a jump list of lines of the current buffer that appear to define or declare types. Uses tree sitter")
{
  View_ID view = get_active_view(app, Access_ReadVisible);
  Buffer_ID buffer = view_get_buffer(app, view, Access_ReadVisible);
  if (buffer != 0) tree_sitter_list_all_query_results(app, buffer, CodeIndexNote_Type);
}

CUSTOM_UI_COMMAND_SIG(tree_sitter_list_all_types_current_buffer_lister)
CUSTOM_DOC("Creates a lister of locations that look like function definitions and declarations in the buffer. Uses tree sitter")
{
  Heap *heap = &global_heap;
  View_ID view = get_active_view(app, Access_ReadVisible);
  Buffer_ID buffer = view_get_buffer(app, view, Access_ReadVisible);
  if (buffer != 0)
  {
    tree_sitter_list_all_query_results(app, buffer, CodeIndexNote_Type);
    view = get_active_view(app, Access_Always);
    buffer = view_get_buffer(app, view, Access_Always);
    Marker_List *list = get_or_make_list_for_buffer(app, heap, buffer);
    if (list != 0)
    {
      Jump_Lister_Result jump = get_jump_index_from_user(app, list, "Type:");
      jump_to_jump_lister_result(app, view, list, &jump);
    }
  }
}

CUSTOM_COMMAND_SIG(tree_sitter_list_all_types_all_buffers)
CUSTOM_DOC("Creates a jump list of lines from all buffers that appear to define or declare types. Uses tree sitter")
{
  tree_sitter_list_all_query_results(app, 0, CodeIndexNote_Type);
}

CUSTOM_UI_COMMAND_SIG(tree_sitter_list_all_types_all_buffers_lister)
CUSTOM_DOC("Creates a lister of locations that look like type definitions and declarations all buffers. Uses tree sitter")
{
  Heap *heap = &global_heap;
  tree_sitter_list_all_query_results(app, 0, CodeIndexNote_Type);
  View_ID view = get_active_view(app, Access_Always);
  Buffer_ID buffer = view_get_buffer(app, view, Access_Always);
  Marker_List *list = get_or_make_list_for_buffer(app, heap, buffer);
  if (list != 0)
  {
    Jump_Lister_Result jump = get_jump_index_from_user(app, list, "Type:");
    jump_to_jump_lister_result(app, view, list, &jump);
  }
}

////////////////////////////////////////////////////////////////////
// DEBUG
////////////////////////////////////////////////////////////////////

char* prefix_buffer = "                                                                                                                                                          ";

function void
write_tree_sitter_tree_to_buffer__inner(Application_Links *app, Arena *arena, Buffer_ID buffer_id,
                                        TSNode cur_node, i32 level = 0, const char *field="")
{
  TSPoint start = ts_node_start_point(cur_node);
  TSPoint end = ts_node_end_point(cur_node);
  // + 1 on ts positions becuase the first line/column are zero in treesitter,
  // but 4coder displays as 1 indexed in the filebar.
  String_Const_u8 string = push_stringf(arena, "%.*s%s: %s [%d, %d] - [%d, %d]\n",
                                        level*2, prefix_buffer, field, ts_node_type(cur_node),
                                        start.row + 1, start.column + 1,
                                        end.row + 1, end.column + 1);

  buffer_replace_range(app, buffer_id, Ii64(buffer_get_size(app, buffer_id)), string);

  u32 child_count = ts_node_child_count(cur_node);
  for (u32 i = 0; i < child_count; ++i)
  {
    TSNode child = ts_node_child(cur_node, i);
    if (ts_node_is_named(child))
    {
      field = ts_node_field_name_for_child(cur_node, i);
      if (!field) field = "";
      write_tree_sitter_tree_to_buffer__inner(app, arena, buffer_id, child, level + 1, field);
    }
  }
}

CUSTOM_COMMAND_SIG(tree_sitter_write_tree)
CUSTOM_DOC("Write the current buffer's tree sitter tree to *tree*")
{
  Scratch_Block scratch(app);
  Buffer_ID out_buffer = get_buffer_by_name(app, string_u8_litexpr("*tree*"), Access_Always);

  View_ID view = get_active_view(app, Access_Always);
  Buffer_ID buffer = view_get_buffer(app, view, Access_Visible);

  Managed_Scope scope = buffer_get_managed_scope(app, buffer);
  Buffer_Tree_Sitter_Data *tree_data = scope_attachment(app, scope, buffer_tree_sitter_data_id, Buffer_Tree_Sitter_Data);

  if (tree_data->tree)
  {
    TSNode root = ts_tree_root_node(tree_data->tree);
    write_tree_sitter_tree_to_buffer__inner(app, scratch, out_buffer, root);
  }
}