module main

import os
import net.http
import net.urllib
import v.vmod
import json
import term

struct ModuleVpmInfo {
    // id           int
    name         string
    url          string
    vcs          string
    nr_downloads int
}

struct VpmInstallServerSelector {
mut:
    selected_url   string
    candidate_urls []string
}

@[params]
struct ErrorOptions {
    details string
    verbose bool // is used to only output the error message if the verbose setting is enabled.
}

const vexe = os.quoted_path(os.getenv('VEXE'))
const home_dir = os.home_dir()
const selected_server_url_env = 'VPM_SELECTED_SERVER_URL'

fn merge_server_urls(default_urls []string, custom_urls []string) []string {
    mut server_urls := default_urls.clone()
    for url in custom_urls {
        if url in server_urls {
            continue
        }
        server_urls << url
    }
    return server_urls
}

fn get_server_urls() []string {
    return merge_server_urls(vpm_server_urls, settings.server_urls)
}

fn selected_server_url(set bool, url string) string {
    if set {
        os.setenv(selected_server_url_env, url, true)
    }
    return os.getenv(selected_server_url_env)
}

fn active_server_urls() []string {
    selected_url := selected_server_url(false, '')
    if selected_url != '' {
        return [selected_url]
    }
    return get_server_urls()
}

fn get_mod_vpm_info(name string) !ModuleVpmInfo {
    mut selector := VpmInstallServerSelector{
        candidate_urls: if settings.server_urls.len > 0 {
            settings.server_urls
        } else {
            vpm_server_urls
        }
    }
    return get_mod_vpm_info_with_selector(name, mut selector)
}

fn get_mod_vpm_info_with_selector(name string, mut selector VpmInstallServerSelector) !ModuleVpmInfo {
    if name.len < 2 || (!name[0].is_digit() && !name[0].is_letter()) {
        return error('invalid module name `${name}`.')
    }
    if selector.candidate_urls.len == 0 {
        return error('no vpm server urls configured.')
    }
    mut errors := []string{}
    is_initial_selection := selected_server_url(false, '') == ''
    for url in selector.metadata_server_urls() {
        modurl := url + '/api/packages/${name}'
        verbose_println_more(@FILE_LINE, @FN,
            'Retrieving metadata for `${name}` from `${modurl}` by making a GET request ...')
        r := http.get(modurl) or {
            errors << 'Http server did not respond to our request for `${modurl}`.'
            errors << 'Error details: ${err}'
            continue
        }
        if r.status_code == 404 || r.body.trim_space() == '404' {
            errors << 'Skipping module `${name}`, since `${url}` reported that `${name}` does not exist.'
            continue
        }
        if r.status_code != 200 {
            errors << 'Skipping module `${name}`, since `${url}` responded with ${r.status_code} http status code. Please try again later.'
            continue
        }
        s := r.body
        if s.len > 0 && s[0] != `{` {
            errors << 'Invalid json data'
            errors << s.trim_space().limit(100) + '...'
            continue
        }
        mod := json.decode(ModuleVpmInfo, s) or {
            errors << 'Skipping module `${name}`, since its information is not in json format.'
            continue
        }
        if '' == mod.url || '' == mod.name {
            errors << 'Skipping module `${name}`, since it is missing name or url information.'
            continue
        }
        if selector.selected_url == '' {
            selector.selected_url = url
            verbose_println_more(@FILE_LINE, @FN, 'Using `${url}` for this installation.')
        }
        if is_initial_selection {
            selected_server_url(true, url)
        }
        verbose_println_more(@FILE_LINE, @FN, 'name: ${name}; mod: ${mod}')
        return mod
    }
    final_error := errors.join_lines()
    verbose_println_more(@FILE_LINE, @FN, 'failed due to these errors: ${final_error}')
    return error(final_error)
}

fn new_install_server_selector() VpmInstallServerSelector {
    return VpmInstallServerSelector{
        candidate_urls: if settings.server_urls.len > 0 {
            settings.server_urls
        } else {
            build_install_server_urls(vpm_server_urls, settings.mirror_urls)
        }
    }
}

fn build_install_server_urls(default_urls []string, mirror_urls []string) []string {
    mut urls := []string{}
    urls << default_urls
    urls << mirror_urls
    return unique_server_urls(urls)
}

fn (selector VpmInstallServerSelector) metadata_server_urls() []string {
    return if selector.selected_url != '' {
        [selector.selected_url]
    } else {
        selector.candidate_urls
    }
}

fn get_ident_from_url(raw_url string) !(string, string) {
    verbose_println_more(@FILE_LINE, @FN, 'raw_url: ${raw_url}')
    // On Windows, absolute paths like `C:\...` are misinterpreted by urllib.parse
    // (the drive letter `C:` is treated as a URL scheme). Handle local paths first.
    if os.is_abs_path(raw_url) || raw_url.starts_with('./') || raw_url.starts_with('../')
        || raw_url.starts_with('~/') || raw_url.starts_with('.\\') || raw_url.starts_with('..\\')
        || raw_url.starts_with('file://') {
        normalized := raw_url.trim_string_left('file://').replace('\\', '/').trim_left('/')
        _, name := normalized.rsplit_once('/') or {
            return '', normalized.trim_string_right('.git')
        }
        return '', name.trim_string_right('.git')
    }
    url := urllib.parse(raw_url) or { return error('failed to parse module URL `${raw_url}`.') }
    normalized_path := url.path.trim_left('/').trim_space()
    publisher, mut name := normalized_path.rsplit_once('/') or {
        if settings.vcs == .hg && raw_url.count(':') > 1 {
            verbose_println_more(@FILE_LINE, @FN, 'ok, publisher: "", name: "test_module"')
            return '', 'test_module'
        }
        if url.scheme in ['file', ''] && normalized_path.len > 0 {
            return '', normalized_path
        }
        final_error := 'failed to retrieve module name for `${url}`.'
        verbose_println_more(@FILE_LINE, @FN, 'failed error: `${final_error}`')
        return error(final_error)
    }
    name = name.trim_string_right('.git')
    verbose_println_more(@FILE_LINE, @FN,
        'raw_url: ${raw_url}; publisher: ${publisher}; name: ${name}')
    return publisher, name
}

fn get_name_from_url(raw_url string) !string {
    _, name := get_ident_from_url(raw_url)!
    return name
}

fn normalize_mod_path(path string) string {
    return path.replace('-', '_').to_lower()
}

fn get_all_modules_for_search() []string {
    working_server_url := get_working_server_url()
    verbose_println_more(@FILE_LINE, @FN, 'working_server_url: ${working_server_url}')
    println('Search server: ${working_server_url} .')
    return get_all_modules_for_search_from_server(working_server_url) or {
        vpm_error(err.msg())
        exit(1)
    }
}

fn get_all_modules_for_search_with_selector(mut selector VpmInstallServerSelector) ![]string {
    if selector.candidate_urls.len == 0 {
        return error('no vpm server urls configured.')
    }
    mut errors := []string{}
    is_initial_selection := selected_server_url(false, '') == ''
    for url in selector.metadata_server_urls() {
        modules := get_all_modules_for_search_from_server(url) or {
            errors << err.msg()
            continue
        }
        if selector.selected_url == '' {
            selector.selected_url = url
        }
        if is_initial_selection {
            selected_server_url(true, url)
        }
        return modules
    }
    return error(errors.join_lines())
}

fn get_all_modules_for_search_from_server(server_url string) ![]string {
    search_url := '${server_url}/search'
    verbose_println_more(@FILE_LINE, @FN, 'making a GET request to search_url: ${search_url} ...')
    r := http.get(search_url) or {
        return error('Http server did not respond to our request for `${search_url}`.\nError details: ${err}')
    }
    if r.status_code != 200 {
        return error('failed to search through ${search_url}\nStatus code: ${r.status_code}')
    }
    modules := extract_modules_from_search_response(r.body)
    verbose_println_more(@FILE_LINE, @FN, 'found modules: ${modules}')
    return modules
}

fn extract_modules_from_search_response(s string) []string {
    mut read_len := 0
    mut modules := []string{}
    for read_len < s.len {
        mut start_token := '<a class="package-card__title hover:underline cursor-pointer" href="/packages/'
        end_token := '">'
        // get the start index of the module entry
        mut start_index := s.index_after(start_token, read_len) or { -1 }
        if start_index == -1 {
            break
        }
        start_index += start_token.len

        // get the index of the end of module entry
        end_index := s.index_after(end_token, start_index) or { break }
        m := s[start_index..end_index]
        modules << m
        read_len = end_index
        if read_len >= s.len {
            break
        }
    }
    return modules
}

fn normalize_repo_lookup_url(raw_url string) !string {
    normalized_url := if raw_url.starts_with('git@') {
        'https://' + raw_url['git@'.len..].replace(':', '/')
    } else {
        raw_url
    }
    url := urllib.parse(normalized_url) or {
        return error('failed to parse module URL `${raw_url}`.')
    }
    host := url.hostname().trim_space().to_lower()
    path :=
        url.path.trim_space().trim_right('/').trim_left('/').trim_string_right('.git').to_lower()
    if host == '' || path == '' {
        return error('failed to normalize module URL `${raw_url}`.')
    }
    return '${host}/${path}'
}

fn get_installed_modules() []string {
    dirs := os.ls(settings.vmodules_path) or { return [] }
    mut modules := []string{}
    for dir in dirs {
        adir := os.join_path(settings.vmodules_path, dir)
        if dir in excluded_dirs || !os.is_dir(adir) {
            continue
        }
        if os.exists(os.join_path(adir, 'v.mod')) && os.exists(os.join_path(adir, '.git', 'config')) {
            // an official vlang module with a short module name, like `vsl`, `ui` or `markdown`
            modules << dir
            continue
        }
        author := dir
        mods := os.ls(adir) or { continue }
        for m in mods {
            vcs_used_in_dir(os.join_path(adir, m)) or { continue }
            modules << '${author}.${m}'
        }
    }
    verbose_println_more(@FILE_LINE, @FN, 'found modules: ${modules}')
    return modules
}

fn get_path_of_existing_module(mod_name string) ?string {
    name := get_name_from_url(mod_name) or { mod_name.replace('-', '_').to_lower() }
    path := os.real_path(os.join_path(settings.vmodules_path, name.replace('.', os.path_separator)))
    if !os.exists(path) {
        vpm_error('failed to find `${name}` at `${path}`.')
        return none
    }
    if !os.is_dir(path) {
        vpm_error('skipping `${path}`, since it is not a directory.')
        return none
    }
    verbose_println_more(@FILE_LINE, @FN, 'mod_name: ${mod_name}, found path: ${path}')
    return path
}

fn get_working_server_url() string {
    is_initial_selection := selected_server_url(false, '') == ''
    for url in active_server_urls() {
        verbose_println('Trying server url: ${url}')
        http.head(url) or {
            vpm_error('failed to connect to server url `${url}`.', details: err.msg())
            continue
        }
        if is_initial_selection {
            selected_server_url(true, url)
        }
        verbose_println_more(@FILE_LINE, @FN, 'found url: ${url}')
        return url
    }
    vpm_error('No responding vpm server found. Please check your network connectivity and try again later.')
    exit(1)
}

fn ensure_vmodules_dir_exist() {
    if !os.is_dir(settings.vmodules_path) {
        println('Creating `${settings.vmodules_path}`...')
        os.mkdir(settings.vmodules_path) or {
            vpm_error(err.msg(), verbose: true)
            exit(1)
        }
    }
    verbose_println_more(@FILE_LINE, @FN, 'settings.vmodules_path: ${settings.vmodules_path}')
}

fn increment_module_download_count(name string, preferred_server_url string) ! {
    if settings.no_dl_count_increment {
        println('Skipping download count increment for `${name}`.')
        return
    }
    server_urls := if preferred_server_url != '' {
        unique_server_urls([preferred_server_url])
    } else if settings.server_urls.len > 0 {
        settings.server_urls
    } else {
        vpm_server_urls
    }
    if server_urls.len == 0 {
        return error('no vpm server urls configured.')
    }
    mut errors := []string{}
    is_initial_selection := selected_server_url(false, '') == ''
    for url in server_urls {
        modurl := url + '/api/packages/${name}/incr_downloads'
        verbose_println_more(@FILE_LINE, @FN, 'making a POST request to modurl: ${modurl} ...')
        r := http.post(modurl, '') or {
            errors << 'Http server did not respond to our request for `${modurl}`.'
            errors << 'Error details: ${err}'
            continue
        }
        if r.status_code != 200 {
            errors << 'Failed to increment the download count for module `${name}`, since `${url}` responded with ${r.status_code} http status code. Please try again later.'
            continue
        }
        if is_initial_selection {
            selected_server_url(true, url)
        }
        return
    }
    final_error := errors.join_lines()
    verbose_println_more(@FILE_LINE, @FN, 'final_error: ${final_error}')
    return error(final_error)
}

fn get_manifest(path string) ?vmod.Manifest {
    return vmod.from_file(os.join_path(path, 'v.mod')) or { return none }
}

fn resolve_dependencies(manifest ?vmod.Manifest, modules []string) {
    mod := manifest or { return }
    // Filter out modules that are both contained in the input query and listed as
    // dependencies in the mod file of the module that is supposed to be installed.
    deps := mod.dependencies.filter(it !in modules)
    verbose_println_more(@FILE_LINE, @FN, 'deps: ${deps}')
    if deps.len > 0 {
        println('Resolving ${deps.len} dependencies for module `${mod.name}`...')
        verbose_println('Found dependencies: ${deps}')
        vpm_install(deps)
    }
}

fn verbose_println(msg string) {
    if settings.is_verbose {
        println(msg)
    }
}

fn verbose_println_more(fline string, fname string, msg string) {
    vpm_log(fline, fname, msg)
    verbose_println(msg)
}

fn vpm_log_header(txt string) {
    divider := '='.repeat(40 - txt.len / 2)
    settings.logger.debug('\n${divider} ${txt} ${divider}\n')
}

fn vpm_log(line string, func string, msg string) {
    settings.logger.debug('${line:-15s} fn: ${func:-30s} msg: ${msg}')
}

fn vpm_error(msg string, opts ErrorOptions) {
    if opts.verbose && !settings.is_verbose {
        return
    }
    eprintln(term.ecolorize(term.red, 'error: ') + msg)
    if opts.details.len > 0 && settings.is_verbose {
        eprint(term.ecolorize(term.cyan, 'details: '))
        padding := ' '.repeat('details: '.len)
        for i, line in opts.details.split_into_lines() {
            if i > 0 {
                eprint(padding)
            }
            eprintln(term.ecolorize(term.cyan, line))
        }
    }
}

fn vpm_warn(msg string, opts ErrorOptions) {
    eprintln(term.ecolorize(term.yellow, 'warning: ') + msg)
    if opts.details.len > 0 {
        eprint(term.ecolorize(term.cyan, 'details: '))
        padding := ' '.repeat('details: '.len)
        for i, line in opts.details.split_into_lines() {
            if i > 0 {
                eprint(padding)
            }
            eprintln(term.ecolorize(term.cyan, line))
        }
    }
}

// Formatted version of the vmodules install path. E.g. `/home/user/.vmodules` -> `~/.vmodules`
fn fmt_mod_path(path string) string {
    if !path.contains(home_dir) {
        return path
    }
    return $if windows {
        path.replace(home_dir, '%USERPROFILE%')
    } $else {
        path.replace(home_dir, '~')
    }
}

fn at_version(version string) string {
    return if version != '' { '@${version}' } else { '' }
}

// FIXME: Workaround for failing `rmdir` commands on Windows.
fn rmdir_all(path string) ! {
    $if windows {
        os.execute_opt('rd /s /q ${path}')!
    } $else {
        os.rmdir_all(path)!
    }
}