module main

import os
import net.http
import v.vmod

struct Module {
mut:
    name               string
    url                string
    version            string // specifies the requested version.
    tmp_path           string
    install_path       string
    install_path_fmted string
    installed_version  string
    is_installed       bool
    is_external        bool
    vcs                ?VCS
    manifest           vmod.Manifest
}

struct Parser {
mut:
    modules              map[string]Module
    checked_settings_vcs bool
    search_modules       []string
    search_loaded        bool
    errors               int
}

enum ModuleKind {
    registered
    https
    http
    ssh
    local
}

fn parse_query(query []string, mut selector VpmInstallServerSelector) []Module {
    mut p := Parser{}
    for m in query {
        p.parse_module(m, mut selector)
    }
    if p.errors > 0 && p.errors == query.len {
        exit(1)
    }
    return p.modules.values()
}

fn (mut p Parser) lookup_registered_name_for_url(manifest_name string, ident string, mut selector VpmInstallServerSelector) ?string {
    if manifest_name == '' || manifest_name.contains('.') {
        return none
    }
    expected_url := normalize_repo_lookup_url(ident) or { return none }
    if !p.search_loaded {
        p.search_modules = get_all_modules_for_search_with_selector(mut selector) or {
            vpm_log(@FILE_LINE, @FN, 'failed to load the VPM search index for `${ident}`: ${err}')
            p.search_loaded = true
            return none
        }
        p.search_loaded = true
    }
    target_name := normalize_mod_path(manifest_name)
    for registered_name in p.search_modules {
        if normalize_mod_path(registered_name.all_after_last('.')) != target_name {
            continue
        }
        info := get_mod_vpm_info_with_selector(registered_name, mut selector) or {
            vpm_log(@FILE_LINE, @FN, 'failed to retrieve metadata for `${registered_name}`: ${err}')
            continue
        }
        registered_url := normalize_repo_lookup_url(info.url) or { continue }
        if registered_url == expected_url {
            return info.name
        }
    }
    return none
}

fn (mut p Parser) parse_module(m string, mut selector VpmInstallServerSelector) {
    kind := match true {
        m.starts_with('https://') { ModuleKind.https }
        m.starts_with('git@') { ModuleKind.ssh }
        m.starts_with('http://') { ModuleKind.http }
        is_local_repository(m) { ModuleKind.local }
        else { ModuleKind.registered }
    }

    ident, version := if kind == .ssh {
        if m.count('@') > 1 {
            m.all_before_last('@'), m.all_after_last('@')
        } else {
            m, ''
        }
    } else {
        m.rsplit_once('@') or { m, '' }
    }
    key := match kind {
        .registered { m }
        .ssh { ident.replace(':', '/') + at_version(version) }
        else { ident.all_after('//').trim_string_right('.git') + at_version(version) }
    }

    if key in p.modules {
        return
    }
    println('Scanning `${m}`...')
    mut mod := if kind != ModuleKind.registered {
        // External module. The identifier is an URL.
        if kind == .http {
            vpm_warn('installing `${ident}` via http.',
                details: 'Support for `http` is deprecated, use `https` to ensure future compatibility.'
            )
        }
        publisher, name := get_ident_from_url(if kind == .ssh {
            'https://' + ident['git@'.len..].replace(':', '/')
        } else {
            ident
        }) or {
            vpm_error(err.msg())
            p.errors++
            return
        }
        // Verify VCS. Only needed once for external modules.
        if !p.checked_settings_vcs {
            p.checked_settings_vcs = true
            settings.vcs.is_executable() or {
                vpm_error(err.msg())
                exit(1)
            }
        }
        tmp_path := get_tmp_path(os.join_path(publisher, name, version)) or {
            vpm_error('failed to get temporary directory for `${ident}`.', details: err.msg())
            p.errors++
            return
        }
        settings.vcs.clone(ident, version, tmp_path) or {
            vpm_error('failed to install `${ident}`.', details: err.msg())
            p.errors++
            return
        }
        manifest := get_manifest(tmp_path) or {
            vpm_error('failed to find `v.mod` for `${ident}${at_version(version)}`.',
                details: err.msg()
            )
            rmdir_all(tmp_path) or {}
            p.errors++
            return
        }
        // Reuse the registered VPM name when a direct VCS URL points to the same repository.
        registered_name := if kind in [.https, .ssh] {
            p.lookup_registered_name_for_url(manifest.name, ident, mut selector) or { '' }
        } else {
            ''
        }
        final_name := if registered_name != '' { registered_name } else { manifest.name }
        mod_path := if registered_name != '' {
            normalize_mod_path(final_name.replace('.', os.path_separator))
        } else {
            normalize_mod_path(os.join_path(if kind == .http { publisher } else { '' },
                manifest.name))
        }
        Module{
            name:         final_name
            url:          ident
            version:      version
            install_path: os.real_path(os.join_path(settings.vmodules_path, mod_path))
            is_external:  true
            tmp_path:     tmp_path
            manifest:     manifest
        }
    } else {
        // VPM registered module.
        info := get_mod_vpm_info_with_selector(ident, mut selector) or {
            vpm_error('failed to retrieve metadata for `${ident}`.', details: err.msg())
            p.errors++
            return
        }
        // Verify VCS.
        vcs := if info.vcs != '' {
            info_vcs := vcs_from_str(info.vcs) or {
                vpm_error('skipping `${info.name}`, since it uses an unsupported version control system `${info.vcs}`.')
                p.errors++
                return
            }
            info_vcs
        } else {
            VCS.git
        }
        vcs.is_executable() or {
            vpm_error(err.msg())
            p.errors++
            return
        }
        mod_path := normalize_mod_path(info.name.replace('.', os.path_separator))
        tmp_path := get_tmp_path(os.join_path(mod_path, version)) or {
            vpm_error('failed to get temporary directory for `${ident}`.', details: err.msg())
            p.errors++
            return
        }
        vcs.clone(info.url, version, tmp_path) or {
            vpm_error('failed to install `${ident}`.', details: err.msg())
            p.errors++
            return
        }
        manifest := get_manifest(tmp_path) or {
            // Add link with issue template requesting to add a manifest.
            mut details := ''
            new_issue_url := '${info.url}/issues/new'
            verbose_println_more(@FILE_LINE, @FN, 'making a HEAD request to: ${new_issue_url} ...')
            if resp := http.head(new_issue_url) {
                if resp.status_code == 200 {
                    issue_tmpl_url := '${info.url}/issues/new?title=Missing%20Manifest&body=${info.name}%20is%20missing%20a%20manifest,%20please%20consider%20adding%20a%20v.mod%20file%20with%20the%20modules%20metadata.'
                    details = 'Please help us ensure future-compatibility, by adding a `v.mod` file or opening an issue at:\n`${issue_tmpl_url}`'
                }
            }
            vpm_warn('`${info.name}` is missing a manifest file.', details: details)
            vpm_log(@FILE_LINE, @FN, 'vpm manifest detection error: ${err}')
            vmod.Manifest{}
        }
        Module{
            name:         info.name
            url:          info.url
            version:      version
            vcs:          vcs
            install_path: os.real_path(os.join_path(settings.vmodules_path, mod_path))
            tmp_path:     tmp_path
            manifest:     manifest
        }
    }
    mod.install_path_fmted = fmt_mod_path(mod.install_path)
    mod.get_installed()
    p.modules[key] = mod
    if mod.manifest.dependencies.len > 0 {
        verbose_println('Found ${mod.manifest.dependencies.len} dependencies for `${mod.name}`: ${mod.manifest.dependencies}.')
        for d in mod.manifest.dependencies {
            p.parse_module(d, mut selector)
        }
    }
}

fn is_local_repository(query string) bool {
    if query.starts_with('file://') {
        return true
    }
    mut path_candidates := [query]
    if !query.starts_with('git@') {
        ident, _ := query.rsplit_once('@') or { query, '' }
        if ident != query {
            path_candidates << ident
        }
    }
    for candidate in path_candidates {
        path := os.expand_tilde_to_home(candidate)
        if os.is_abs_path(path) || path.starts_with('./') || path.starts_with('../')
            || path.starts_with('~/') {
            return true
        }
        if os.exists(path) {
            return true
        }
    }
    return false
}

fn (mut m Module) get_installed() {
    refs := os.execute_opt('git ls-remote --refs ${m.install_path}') or { return }
    vpm_log(@FILE_LINE, @FN, 'refs: ${refs}')
    m.is_installed = true
    // In case the head just temporarily matches a tag, make sure that there
    // really is a version installation before adding it as `installed_version`.
    // NOTE: can be refined for branch installations. E.g., for `sdl`.
    if refs.output.contains('refs/tags/') {
        tag := refs.output.all_after_last('refs/tags/').all_before('\n').trim_space()
        head := if refs.output.contains('refs/heads/') {
            refs.output.all_after_last('refs/heads/').all_before('\n').trim_space()
        } else {
            tag
        }
        vpm_log(@FILE_LINE, @FN, 'head: ${head}, tag: ${tag}')
        if tag == head {
            m.installed_version = tag
        }
    }
}

fn get_tmp_path(relative_path string) !string {
    tmp_path := os.real_path(os.join_path(settings.tmp_path, relative_path))
    if os.exists(tmp_path) {
        // It's unlikely that the tmp_path already exists, but it might
        // occur if vpm was canceled during an installation or update.
        rmdir_all(tmp_path)!
    }
    return tmp_path
}