// Copyright (c) 2020 Lars Pontoppidan. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
import os
import flag

const (
    tool_name        = 'v missdoc'
    tool_version     = '0.1.0'
    tool_description = 'Prints all V functions in .v files under PATH/, that do not yet have documentation comments.'
    work_dir_prefix  = normalise_path(os.real_path(os.wd_at_startup) + os.path_separator)
)

struct UndocumentedFN {
    file      string
    line      int
    signature string
    tags      []string
}

struct Options {
    show_help       bool
    collect_tags    bool
    deprecated      bool
    private         bool
    js              bool
    no_line_numbers bool
    exclude         []string
    relative_paths  bool
mut:
    verify          bool
    diff            bool
    additional_args []string
}

fn (opt Options) collect_undocumented_functions_in_dir(directory string) []UndocumentedFN {
    mut files := []string{}
    collect(directory, mut files, fn (npath string, mut accumulated_paths []string) {
        if !npath.ends_with('.v') {
            return
        }
        if npath.ends_with('_test.v') {
            return
        }
        accumulated_paths << npath
    })
    mut undocumented_fns := []UndocumentedFN{}
    for file in files {
        if !opt.js && file.ends_with('.js.v') {
            continue
        }
        if opt.exclude.len > 0 && opt.exclude.any(file.contains(it)) {
            continue
        }
        undocumented_fns << opt.collect_undocumented_functions_in_file(file)
    }
    return undocumented_fns
}

fn (opt &Options) collect_undocumented_functions_in_file(nfile string) []UndocumentedFN {
    file := os.real_path(nfile)
    contents := os.read_file(file) or { panic(err) }
    lines := contents.split('\n')
    mut list := []UndocumentedFN{}
    mut comments := []string{}
    mut tags := []string{}
    for i, line in lines {
        if line.starts_with('//') {
            comments << line
        } else if line.trim_space().starts_with('[') {
            tags << collect_tags(line)
        } else if line.starts_with('pub fn')
            || (opt.private && (line.starts_with('fn ') && !(line.starts_with('fn C.')
            || line.starts_with('fn main')))) {
            if comments.len == 0 {
                clean_line := line.all_before_last(' {')
                list << UndocumentedFN{
                    line: i + 1
                    signature: clean_line
                    tags: tags
                    file: file
                }
            }
            tags = []
            comments = []
        } else {
            tags = []
            comments = []
        }
    }
    return list
}

fn (opt &Options) collect_undocumented_functions_in_path(path string) []UndocumentedFN {
    mut undocumented_functions := []UndocumentedFN{}
    if os.is_file(path) {
        undocumented_functions << opt.collect_undocumented_functions_in_file(path)
    } else {
        undocumented_functions << opt.collect_undocumented_functions_in_dir(path)
    }
    return undocumented_functions
}

fn (opt &Options) report_undocumented_functions_in_path(path string) int {
    mut list := opt.collect_undocumented_functions_in_path(path)
    opt.report_undocumented_functions(list)
    return list.len
}

fn (opt &Options) report_undocumented_functions(list []UndocumentedFN) {
    if list.len > 0 {
        for undocumented_fn in list {
            mut line_numbers := '${undocumented_fn.line}:0:'
            if opt.no_line_numbers {
                line_numbers = ''
            }
            tags_str := if opt.collect_tags && undocumented_fn.tags.len > 0 {
                '${undocumented_fn.tags}'
            } else {
                ''
            }
            file := undocumented_fn.file
            ofile := if opt.relative_paths {
                file.replace(work_dir_prefix, '')
            } else {
                os.real_path(file)
            }
            if opt.deprecated {
                println('${ofile}:${line_numbers}${undocumented_fn.signature} ${tags_str}')
            } else {
                mut has_deprecation_tag := false
                for tag in undocumented_fn.tags {
                    if tag.starts_with('deprecated') {
                        has_deprecation_tag = true
                        break
                    }
                }
                if !has_deprecation_tag {
                    println('${ofile}:${line_numbers}${undocumented_fn.signature} ${tags_str}')
                }
            }
        }
    }
}

fn (opt &Options) diff_undocumented_functions_in_paths(path_old string, path_new string) []UndocumentedFN {
    old := os.real_path(path_old)
    new := os.real_path(path_new)

    mut old_undocumented_functions := opt.collect_undocumented_functions_in_path(old)
    mut new_undocumented_functions := opt.collect_undocumented_functions_in_path(new)

    mut differs := []UndocumentedFN{}
    if new_undocumented_functions.len > old_undocumented_functions.len {
        for new_undoc_fn in new_undocumented_functions {
            new_relative_file := new_undoc_fn.file.replace(new, '').trim_string_left(os.path_separator)
            mut found := false
            for old_undoc_fn in old_undocumented_functions {
                old_relative_file := old_undoc_fn.file.replace(old, '').trim_string_left(os.path_separator)
                if new_relative_file == old_relative_file
                    && new_undoc_fn.signature == old_undoc_fn.signature {
                    found = true
                    break
                }
            }
            if !found {
                differs << new_undoc_fn
            }
        }
    }
    differs.sort_with_compare(sort_undoc_fns)
    return differs
}

fn sort_undoc_fns(a &UndocumentedFN, b &UndocumentedFN) int {
    if a.file < b.file {
        return -1
    }
    if a.file > b.file {
        return 1
    }
    // same file sort by signature
    else {
        if a.signature < b.signature {
            return -1
        }
        if a.signature > b.signature {
            return 1
        }
        return 0
    }
}

fn normalise_path(path string) string {
    return path.replace('\\', '/')
}

fn collect(path string, mut l []string, f fn (string, mut []string)) {
    if !os.is_dir(path) {
        return
    }
    mut files := os.ls(path) or { return }
    for file in files {
        p := normalise_path(os.join_path_single(path, file))
        if os.is_dir(p) && !os.is_link(p) {
            collect(p, mut l, f)
        } else if os.exists(p) {
            f(p, mut l)
        }
    }
    return
}

fn collect_tags(line string) []string {
    mut cleaned := line.all_before('/')
    cleaned = cleaned.replace_each(['[', '', ']', '', ' ', ''])
    return cleaned.split(',')
}

fn main() {
    mut fp := flag.new_flag_parser(os.args[1..]) // skip the "v" command.
    fp.application(tool_name)
    fp.version(tool_version)
    fp.description(tool_description)
    fp.arguments_description('PATH [PATH]...')
    fp.skip_executable() // skip the "missdoc" command.

    // Collect tool options
    mut opt := Options{
        show_help: fp.bool('help', `h`, false, 'Show this help text.')
        deprecated: fp.bool('deprecated', `d`, false, 'Include deprecated functions in output.')
        private: fp.bool('private', `p`, false, 'Include private functions in output.')
        js: fp.bool('js', 0, false, 'Include JavaScript functions in output.')
        no_line_numbers: fp.bool('no-line-numbers', `n`, false, 'Exclude line numbers in output.')
        collect_tags: fp.bool('tags', `t`, false, 'Also print function tags if any is found.')
        exclude: fp.string_multi('exclude', `e`, '')
        relative_paths: fp.bool('relative-paths', `r`, false, 'Use relative paths in output.')
        diff: fp.bool('diff', 0, false, 'exit(1) and show difference between two PATH inputs, return 0 otherwise.')
        verify: fp.bool('verify', 0, false, 'exit(1) if documentation is missing, 0 otherwise.')
    }

    opt.additional_args = fp.finalize() or { panic(err) }

    if opt.show_help {
        println(fp.usage())
        exit(0)
    }
    if opt.additional_args.len == 0 {
        println(fp.usage())
        eprintln('Error: ${tool_name} is missing PATH input')
        exit(1)
    }
    // Allow short-long versions to prevent false positive situations, should
    // the user miss a `-`. E.g.: the `-verify` flag would be ignored and missdoc
    // will return 0 for success plus a list of any undocumented functions.
    if '-verify' in opt.additional_args {
        opt.verify = true
    }
    if '-diff' in opt.additional_args {
        opt.diff = true
    }
    if opt.diff {
        if opt.additional_args.len < 2 {
            println(fp.usage())
            eprintln('Error: ${tool_name} --diff needs two valid PATH inputs')
            exit(1)
        }
        path_old := opt.additional_args[0]
        path_new := opt.additional_args[1]
        if !(os.is_file(path_old) || os.is_dir(path_old)) || !(os.is_file(path_new)
            || os.is_dir(path_new)) {
            println(fp.usage())
            eprintln('Error: ${tool_name} --diff needs two valid PATH inputs')
            exit(1)
        }
        list := opt.diff_undocumented_functions_in_paths(path_old, path_new)
        if list.len > 0 {
            opt.report_undocumented_functions(list)
            exit(1)
        }
        exit(0)
    }
    mut total := 0
    for path in opt.additional_args {
        if os.is_file(path) || os.is_dir(path) {
            total += opt.report_undocumented_functions_in_path(path)
        }
    }
    if opt.verify && total > 0 {
        exit(1)
    }
}