CUSTOM_COMMAND_SIG(repro_cd) {
    char hot_dir_space[1024];
    String hot_dir = make_fixed_width_string(hot_dir_space);
    hot_dir.size = directory_get_hot(app, hot_dir.str, hot_dir.memory_size);
    
    File_List hot_files = get_file_list(app, expand_str(hot_dir));
    for (uint32_t i = 0; i < hot_files.count; ++i) {
        if (hot_files.infos[i].folder) {
            int32_t old_size = hot_dir.size;
            
            directory_cd(app, hot_dir.str, &hot_dir.size, hot_dir.memory_size, hot_files.infos[i].filename, hot_files.infos[i].filename_len);
            
            // This should crash also
            Assert(old_size != hot_dir.size);
            
            break;
        }
    }
}

CUSTOM_COMMAND_SIG(repro_mouse_input_weirdness) {
    View_Summary active_view = get_active_view(app, AccessAll);
    View_Summary test_view = open_view(app, &active_view, ViewSplit_Bottom);
    
    while (true) {
        User_Input in = get_user_input(app, EventOnLeftButton, 0);
        
        if (in.abort) {
            // NOTE: This will be reached in the iteration after the mouse
            // button release event, even if we don't produce any more input,
            // though this seems to depend on which view you click in?
            Assert(false);
        } else if (in.type == UserInputMouse) {
            // Pretend we actually do something here
            continue;
        }
    }
    
    close_view(app, &test_view);
}

static void
buffer_seek_string_forward(Application_Links *app, Buffer_Summary *buffer, int32_t pos, int32_t end, char *str, int32_t size, int32_t *result){
    char read_buffer[512];
    
    if (buffer->size > end){
        *result = buffer->size;
    }
    else{
        *result = end;
    }
    
    if (size > 0 && size <= sizeof(read_buffer)){
        if (buffer->exists){
            String read_str = make_fixed_width_string(read_buffer);
            String needle_str = make_string(str, size);
            char first_char = str[0];
            
            read_str.size = size;
            
            char chunk[1024];
            Stream_Chunk stream = {0};
            stream.max_end = end;
            
            if (init_stream_chunk(&stream, app, buffer, pos, chunk, sizeof(chunk))){
                int32_t still_looping = 1;
                do{
                    for(; pos < stream.end; ++pos){
                        char at_pos = stream.data[pos];
                        if (at_pos == first_char){
                            buffer_read_range(app, buffer, pos, pos+size, read_buffer);
                            if (match_ss(needle_str, read_str)){
                                *result = pos;
                                goto finished;
                            }
                        }
                    }
                    still_looping = forward_stream_chunk(&stream);
                }while (still_looping);
            }
        }
        
        if (end == 0){
            *result = buffer->size;
        }
        else{
            *result = end;
        }
        
        finished:;
    }
}

if (pos > end - size) {
    *result = end;
    return;
}

/******************************************************************************
Author: Tristan Dannenberg
Notice: No warranty is offered or implied; use this code at your own risk.
*******************************************************************************
LICENSE

This software is dual-licensed to the public domain and under the following
license: you are granted a perpetual, irrevocable license to copy, modify,
publish, and distribute this file as you see fit.
*******************************************************************************
This file provides a parse context for golang syntax highlighting.
******************************************************************************/

#if !defined(FTLD_LANGUAGE_GO_HPP)
#define FTLD_LANGUAGE_GO_HPP

static Parse_Context_ID tld_parse_context_language_golang;

#define PSAT(s, t) {s, sizeof(s)-1, t}
static void
tld_init_language_golang(Application_Links *app){
    if (tld_parse_context_language_golang != 0) return;
    
    Parser_String_And_Type kw[] = {
        PSAT("true",  CPP_TOKEN_BOOLEAN_CONSTANT),
        PSAT("false", CPP_TOKEN_BOOLEAN_CONSTANT),
        
        PSAT("chan",      CPP_TOKEN_KEY_OTHER),
        PSAT("const",     CPP_TOKEN_KEY_OTHER),
        PSAT("default",   CPP_TOKEN_KEY_OTHER),
        PSAT("func",      CPP_TOKEN_KEY_OTHER),
        PSAT("import",    CPP_TOKEN_KEY_OTHER),
        PSAT("interface", CPP_TOKEN_KEY_OTHER),
        PSAT("map",       CPP_TOKEN_KEY_OTHER),
        PSAT("nil",       CPP_TOKEN_KEY_OTHER),
        PSAT("package",   CPP_TOKEN_KEY_OTHER),
        PSAT("range",     CPP_TOKEN_KEY_OTHER),
        PSAT("return",    CPP_TOKEN_KEY_OTHER),
        PSAT("struct",    CPP_TOKEN_KEY_OTHER),
        PSAT("type",      CPP_TOKEN_KEY_OTHER),
        PSAT("var",       CPP_TOKEN_KEY_OTHER),
        
        PSAT("break",       CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("continue",    CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("case",        CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("defer",       CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("else",        CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("fallthrough", CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("for",         CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("go",          CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("goto",        CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("if",          CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("select",      CPP_TOKEN_KEY_CONTROL_FLOW),
        PSAT("switch",      CPP_TOKEN_KEY_CONTROL_FLOW),
    };
    
    tld_parse_context_language_golang = create_parse_context(app, kw, ArrayCount(kw), 0, 0);
}
#undef PSAT

#endif

// NOTE: This goes at the top of the function, with other initialization code
bool tld_golang_indentation = false;
Parse_Context_ID parse_context_id = 0;
buffer_get_setting(app, buffer, BufferSetting_ParserContext, (int32_t *) &parse_context_id);

if (parse_context_id == tld_parse_context_language_golang) {
    tld_golang_indentation = true;
}

// NOTE: This goes in the middle of the function, where `statement_complete` is determined
if (!has_prev_usable_token){
    statement_complete = true;
}
else{
    if (prev_usable_token.type == CPP_TOKEN_BRACKET_OPEN ||
        prev_usable_token.type == CPP_TOKEN_BRACE_OPEN ||
        prev_usable_token.type == CPP_TOKEN_BRACE_CLOSE ||
        prev_usable_token.type == CPP_TOKEN_SEMICOLON ||
        prev_usable_token.type == CPP_TOKEN_COLON ||
        prev_usable_token.type == CPP_TOKEN_COMMA ||
        // NOTE: TLD modifications begin here:
        (tld_golang_indentation && (
            prev_usable_token.type == CPP_TOKEN_BOOLEAN_CONSTANT ||
            prev_usable_token.type == CPP_TOKEN_STRING_CONSTANT ||
            prev_usable_token.type == CPP_TOKEN_IDENTIFIER ||
            prev_usable_token.type == CPP_TOKEN_INTEGER_CONSTANT ||
            prev_usable_token.type == CPP_TOKEN_FLOATING_CONSTANT ||
            prev_usable_token.type == CPP_TOKEN_CHARACTER_CONSTANT ||
            prev_usable_token.type == CPP_TOKEN_PARENTHESE_CLOSE ||
            prev_usable_token.type == CPP_TOKEN_BRACKET_CLOSE)))
            // NOTE: TLD modifications end here
    {
        statement_complete = true;
    }
}

CUSTOM_COMMAND_SIG(repro_bfss_uninit_stack_mem_read)
CUSTOM_DOC("Reproduces a bug in buffer_seek_string_forward.")
{
    View_Summary view = get_active_view(app, AccessAll);
    Buffer_Summary buffer = get_buffer_by_name(app, literal("*test*"), AccessAll);
    if (!buffer.exists){
        buffer = create_buffer(app, literal("*test*"), BufferCreate_AlwaysNew);
        buffer_set_setting(app, &buffer, BufferSetting_Unimportant, true);
        buffer_set_setting(app, &buffer, BufferSetting_WrapLine, false);
    }
    else{
        buffer_send_end_signal(app, &buffer);
        buffer_replace_range(app, &buffer, 0, buffer.size, 0, 0);
    }
    
    buffer_replace_range(app, &buffer, 0, buffer.size, literal("ABCDEFD"));
    
    int32_t search_pos = 0;
    buffer_seek_string_forward(app, &buffer, search_pos, buffer.size, literal("DEF"), &search_pos);
    
    Assert(search_pos == 3);
    search_pos += 1; // Increment position so that we don't get the same match twice
    
    buffer_seek_string_forward(app, &buffer, search_pos, buffer.size, literal("DEF"), &search_pos);
    
    // No second match in the buffer, so this should not fire
    // ... but it does!
    Assert(search_pos >= buffer.size);
}