module c

import os
import v.pref
import v.util

fn live_runtime_quoted_path(target_os pref.OS, path string) string {
    return match target_os {
        .windows { '"${path.replace('"', '\\"')}"' }
        else { "'" + path.replace("'", "'\\''") + "'" }
    }
}

fn live_runtime_quoted_path_for_c_string(target_os pref.OS, path string) string {
    return live_runtime_quoted_path(target_os, path).replace('\\', '\\\\').replace('"', '\\"')
}

fn (mut g Gen) generate_hotcode_reloading_declarations() {
    if g.pref.os == .windows {
        g.hotcode_definitions.writeln('HANDLE live_fn_mutex = 0;')
        g.hotcode_definitions.writeln('
HANDLE* v_live_fn_mutex_ptr(void) {
    if (g_live_reload_info) {
        v__live__LiveReloadInfo* live_info = (v__live__LiveReloadInfo*)g_live_reload_info;
        if (live_info->live_fn_mutex) {
            return (HANDLE*)live_info->live_fn_mutex;
        }
    }
    if (!live_fn_mutex) {
        live_fn_mutex = CreateMutexA(0, 0, 0);
    }
    return &live_fn_mutex;
}
void pthread_mutex_lock(HANDLE *m) {
    WaitForSingleObject(*m, INFINITE);
}
void pthread_mutex_unlock(HANDLE *m) {
    ReleaseMutex(*m);
}
')
    } else {
        g.hotcode_definitions.writeln('pthread_mutex_t live_fn_mutex;')
        g.hotcode_definitions.writeln('pthread_once_t live_fn_mutex_once = PTHREAD_ONCE_INIT;')
        g.hotcode_definitions.writeln('
void v_init_live_mutex(void) {
    pthread_mutexattr_t live_fn_mutex_attr;
    pthread_mutexattr_init(&live_fn_mutex_attr);
    pthread_mutexattr_settype(&live_fn_mutex_attr, PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&live_fn_mutex, &live_fn_mutex_attr);
    pthread_mutexattr_destroy(&live_fn_mutex_attr);
}

pthread_mutex_t* v_live_fn_mutex_ptr(void) {
    if (g_live_reload_info) {
        v__live__LiveReloadInfo* live_info = (v__live__LiveReloadInfo*)g_live_reload_info;
        if (live_info->live_fn_mutex) {
            return (pthread_mutex_t*)live_info->live_fn_mutex;
        }
    }
    pthread_once(&live_fn_mutex_once, v_init_live_mutex);
    return &live_fn_mutex;
}
')
    }
}

fn (mut g Gen) generate_hotcode_reloader_code() {
    if g.pref.is_liveshared {
        g.hotcode_definitions.writeln('')
        return
    }
    // Hot code reloading
    if g.pref.is_livemain {
        mut phd := ''
        mut load_code := []string{}
        if g.pref.os != .windows {
            for so_fn in g.hotcode_fn_names {
                load_code << '\tvoid* live_sym_${so_fn} = dlsym(live_lib, "impl_live_${so_fn}");'
                load_code << '\tif (live_sym_${so_fn}) {'
                load_code << '\t\timpl_live_${so_fn} = live_sym_${so_fn};'
                load_code << '\t} else {'
                load_code << '\t\timpl_live_${so_fn} = no_impl_${so_fn};'
                load_code << '\t}'
            }
            load_code << 'void (* fn_set_live_reload_pointer)(void *) = (void *)dlsym(live_lib, "set_live_reload_pointer");'
            phd = posix_hotcode_definitions_1
        } else {
            for so_fn in g.hotcode_fn_names {
                load_code << '\tvoid* live_sym_${so_fn} = (void *)GetProcAddress(live_lib, "impl_live_${so_fn}");'
                load_code << '\tif (live_sym_${so_fn}) {'
                load_code << '\t\timpl_live_${so_fn} = live_sym_${so_fn};'
                load_code << '\t} else {'
                load_code << '\t\timpl_live_${so_fn} = no_impl_${so_fn};'
                load_code << '\t}'
            }
            load_code << 'void (* fn_set_live_reload_pointer)(void *) = (void *)GetProcAddress(live_lib, "set_live_reload_pointer");'
            phd = windows_hotcode_definitions_1
        }
        // Ensure that g_live_reload_info from the executable is passed to the DLL .
        // See also vlib/v/live/sharedlib/live_sharedlib.v .
        load_code << 'if(fn_set_live_reload_pointer){ fn_set_live_reload_pointer( g_live_reload_info ); }'

        g.hotcode_definitions.writeln(phd.replace('@LOAD_FNS@', load_code.join('\n')))
    }
}

const posix_hotcode_definitions_1 = '
void v_bind_live_symbols(void* live_lib){
    @LOAD_FNS@
}
'

const windows_hotcode_definitions_1 = '
void v_bind_live_symbols(void* live_lib){
    @LOAD_FNS@
}
'

fn (mut g Gen) generate_hotcode_reloading_main_caller() {
    if !g.pref.is_livemain {
        return
    }
    g.writeln('')
    // We are in live code reload mode, so start the .so loader in the background
    g.writeln2('\t// live code initialization section:', '\t{')
    g.writeln('\t\t// initialization of live function pointers')
    for fname in g.hotcode_fn_names {
        g.writeln('\t\timpl_live_${fname} = no_impl_${fname};')
    }
    vexe := util.cescaped_path(pref.vexe_path())
    file := util.cescaped_path(g.pref.path)
    ccpath := live_runtime_quoted_path_for_c_string(g.pref.os, g.pref.ccompiler)
    ccompiler := '-cc ${ccpath}'
    so_debug_flag := if g.pref.is_debug { '-cg' } else { '' }
    mut vopts := '${ccompiler} ${so_debug_flag} -sharedlive -shared'
    if g.pref.os == .windows && g.is_cc_msvc && 'sokol' in g.table.imports {
        mut import_lib_path := g.pref.out_name
        ext := os.file_ext(import_lib_path)
        if ext != '' {
            import_lib_path = import_lib_path[..import_lib_path.len - ext.len] + '.lib'
        } else {
            import_lib_path += '.lib'
        }
        escaped_import_lib_path := util.cescaped_path(os.abs_path(import_lib_path))
        vopts += " -ldflags \\\"${escaped_import_lib_path}\\\""
    }

    g.writeln('\t\t// start background reloading thread')
    g.writeln('\t\tvoid* live_fn_mutex_addr = v_live_fn_mutex_ptr();')
    g.writeln('\t\tv__live__LiveReloadInfo* live_info = v__live__executable__new_live_reload_info(')
    g.writeln('\t\t\t\t\t builtin__tos2("${file}"),')
    g.writeln('\t\t\t\t\t builtin__tos2("${vexe}"),')
    g.writeln('\t\t\t\t\t builtin__tos2("${vopts}"),')
    g.writeln('\t\t\t\t\t live_fn_mutex_addr,')
    g.writeln('\t\t\t\t\t v_bind_live_symbols')
    g.writeln('\t\t);')
    mut already_added := map[string]bool{}
    for f in g.hotcode_fpaths {
        already_added[f] = true
    }
    mut idx := 0
    for f, _ in already_added {
        fpath := os.real_path(f)
        g.writeln('\t\tv__live__executable__add_live_monitored_file(live_info, ${ctoslit(fpath)}); // source V file with @[live] ${
            idx + 1}/${already_added.len}')
        idx++
    }
    g.writeln('')
    // g_live_reload_info gives access to the LiveReloadInfo methods,
    // to the custom user code, through calling v_live_info()
    g.writeln('\t\tg_live_reload_info = (void*)live_info;')
    g.writeln('\t\tv__live__executable__start_reloader(live_info);')
    g.writeln('\t}\t// end of live code initialization section')
    g.writeln('')
}