// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module main

import os
import os.cmdline
import rand
import term
import v.ast
import v.pref
import v.fmt
import v.util
import v.util.diff
import v.parser
import v.help

struct FormatOptions {
    is_l       bool
    is_c       bool // Note: This refers to the '-c' fmt flag, NOT the C backend
    is_w       bool
    is_diff    bool
    is_verbose bool
    is_debug   bool
    is_noerror bool
    is_verify  bool // exit(1) if the file is not vfmt'ed
    is_worker  bool // true *only* in the worker processes. Note: workers can crash.
    is_backup  bool // make a `file.v.bak` copy *before* overwriting a `file.v` in place with `-w`
    in_process bool // do not fork a worker process; potentially faster, but more prone to crashes for invalid files
    is_new_int bool // Forcefully cast the `int` type in @[translated] modules or in the definition of `C.func` to the `i32` type.
mut:
    diff_cmd string // filled in when -diff or -verify is passed
}

const formatted_file_token = '\@\@\@' + 'FORMATTED_FILE: '
const vtmp_folder = os.vtmp_dir()
const term_colors = term.can_show_color_on_stderr()
const vfmt_only_flags = ['-backup', '-c', '-diff', '-inprocess', '-l', '-new_int', '-noerror',
    '-verbose', '--verbose', '-verify', '-w']

fn main() {
    // if os.getenv('VFMT_ENABLE') == '' {
    // eprintln('v fmt is disabled for now')
    // exit(1)
    // }
    toolexe := os.executable()
    util.set_vroot_folder(os.dir(os.dir(os.dir(toolexe))))
    args := util.join_env_vflags_and_os_args()
    mut foptions := FormatOptions{
        is_c:       '-c' in args
        is_l:       '-l' in args
        is_w:       '-w' in args
        is_diff:    '-diff' in args
        is_verbose: '-verbose' in args || '--verbose' in args
        is_worker:  '-worker' in args
        is_debug:   '-debug' in args
        is_noerror: '-noerror' in args
        is_verify:  '-verify' in args
        is_backup:  '-backup' in args
        in_process: '-inprocess' in args
        is_new_int: '-new_int' in args
    }
    if term_colors {
        os.setenv('VCOLORS', 'always', true)
    }
    foptions.vlog('vfmt foptions: ${foptions}')
    if foptions.is_worker {
        // -worker should be added by a parent vfmt process.
        // We launch a sub process for each file because
        // the v compiler can do an early exit if it detects
        // a syntax error, but we want to process ALL passed
        // files if possible.
        foptions.format_file(cmdline.option(args, '-worker', ''))
        exit(0)
    }
    // we are NOT a worker at this stage, i.e. we are a parent vfmt process
    possible_files := cmdline.only_non_options(cmdline.options_after(args, ['fmt']))
    if foptions.is_verbose {
        eprintln('vfmt toolexe: ${toolexe}')
        eprintln('vfmt args: ' + os.args.str())
        eprintln('vfmt env_vflags_and_os_args: ' + args.str())
        eprintln('vfmt possible_files: ' + possible_files.str())
    }
    if '-help' in args || '--help' in args {
        help.print_and_exit('fmt')
    }
    files := util.find_all_v_files(possible_files) or {
        verror(err.msg())
        return
    }
    if os.is_atty(0) == 0 && files.len == 0 {
        foptions.format_pipe()
        exit(0)
    }
    if files.len == 0 {
        help.print_and_exit('fmt')
    }
    mut cli_args_no_files := []string{}
    for idx, a in os.args {
        if idx == 0 {
            cli_args_no_files << os.quoted_path(a)
            continue
        }
        if a !in files {
            cli_args_no_files << a
        }
    }
    mut errors := 0
    mut has_internal_error := false
    mut prefs := setup_preferences(args)
    for file in files {
        fpath := os.real_path(file)
        if foptions.is_verify && foptions.in_process {
            // For a small amount of files, it is faster to process
            // everything directly in the same process, single threaded,
            // when vfmt is compiled with `-gc none`:
            if !foptions.verify_file(prefs, fpath) {
                println("${file} is not vfmt'ed")
                errors++
            }
            continue
        }
        mut worker_command_array := cli_args_no_files.clone()
        worker_command_array << ['-worker', util.quote_path(fpath)]
        worker_cmd := worker_command_array.join(' ')
        foptions.vlog('vfmt worker_cmd: ${worker_cmd}')
        worker_result := os.execute(worker_cmd)
        // Guard against a possibly crashing worker process.
        if worker_result.exit_code != 0 {
            eprintln(worker_result.output)
            if worker_result.exit_code == 1 {
                eprintln('Internal vfmt error while formatting file: ${file}.')
                has_internal_error = true
                continue
            }
            errors++
            continue
        }
        if worker_result.output.len > 0 {
            if worker_result.output.contains(formatted_file_token) {
                wresult := worker_result.output.split(formatted_file_token)
                formatted_warn_errs := wresult[0]
                formatted_file_path := wresult[1].trim_right('\n\r')
                foptions.post_process_file(fpath, formatted_file_path) or { errors = errors + 1 }
                if formatted_warn_errs.len > 0 {
                    eprintln(formatted_warn_errs)
                }
                continue
            }
        }
        errors++
    }
    if has_internal_error {
        // When some files could not be processed due to internal vfmt errors,
        // exit with code 5 regardless of format-diff errors in other files.
        // This prevents exit codes like 7 (2+5) that confuse downstream CI checks.
        exit(5)
    }
    if errors > 0 {
        if !foptions.is_diff {
            eprintln('Encountered a total of: ${errors} formatting errors.')
        }
        match true {
            foptions.is_noerror { exit(0) }
            foptions.is_verify { exit(1) }
            foptions.is_c { exit(2) }
            else { exit(1) }
        }
    }
    exit(0)
}

fn (foptions &FormatOptions) verify_file(prefs &pref.Preferences, fpath string) bool {
    fcontent := foptions.formated_content_from_file(prefs, fpath) or { return false }
    content := os.read_file(fpath) or { return false }
    return fcontent == content
}

fn setup_preferences(args []string) &pref.Preferences {
    mut prefs, _ := pref.parse_args_and_show_errors(['fmt'], vfmt_args_for_preferences(args), false)
    prefs.is_fmt = true
    prefs.skip_warnings = true
    return prefs
}

fn vfmt_args_for_preferences(args []string) []string {
    mut res := []string{}
    for i := 1; i < args.len; i++ {
        arg := args[i]
        if arg == '-worker' {
            i++
            continue
        }
        if arg in vfmt_only_flags {
            continue
        }
        res << arg
    }
    return res
}

fn setup_preferences_and_table(args []string) (&pref.Preferences, &ast.Table) {
    return setup_preferences(args), ast.new_table()
}

fn (foptions &FormatOptions) vlog(msg string) {
    if foptions.is_verbose {
        eprintln(msg)
    }
}

fn (foptions &FormatOptions) formated_content_from_file(prefs &pref.Preferences, file string) !string {
    mut table := ast.new_table()
    file_ast := parser.parse_file(file, mut table, .parse_comments, prefs)
    if file_ast.errors.len > 0 {
        return error('the file contains parser errors')
    }
    table.new_int = foptions.is_new_int
    formated_content := fmt.fmt(file_ast, mut table, prefs, foptions.is_debug)
    return formated_content
}

fn (foptions &FormatOptions) format_file(file string) {
    file_name := os.file_name(file)
    ulid := rand.ulid()
    vfmt_output_path := os.join_path(vtmp_folder, 'vfmt_${ulid}_${file_name}')
    if file.contains('_vfmt_off') {
        os.cp(file, vfmt_output_path) or { panic(err) }
        foptions.vlog('format_file copied the file ${file} as it was, 1:1, since its name contains `_vfmt_off`.')
        eprintln('${formatted_file_token}${vfmt_output_path}')
        return
    }
    foptions.vlog('vfmt2 running fmt.fmt over file: ${file}')
    args := util.join_env_vflags_and_os_args()
    prefs, mut table := setup_preferences_and_table(args)
    file_ast := parser.parse_file(file, mut table, .parse_comments, prefs)
    if file_ast.errors.len > 0 {
        exit(2)
    }
    // checker.new_checker(table, prefs).check(file_ast)
    table.new_int = foptions.is_new_int
    formatted_content := fmt.fmt(file_ast, mut table, prefs, foptions.is_debug)
    os.write_file(vfmt_output_path, formatted_content) or { panic(err) }
    foptions.vlog('fmt.fmt worked and ${formatted_content.len} bytes were written to ${vfmt_output_path} .')
    eprintln('${formatted_file_token}${vfmt_output_path}')
}

fn (foptions &FormatOptions) format_pipe() {
    foptions.vlog('vfmt2 running fmt.fmt over stdin')
    args := util.join_env_vflags_and_os_args()
    prefs, mut table := setup_preferences_and_table(args)
    input_text := os.get_raw_lines_joined()
    file_ast := parser.parse_text(input_text, '', mut table, .parse_comments, prefs)
    if file_ast.errors.len > 0 {
        exit(1)
    }
    // checker.new_checker(table, prefs).check(file_ast)
    table.new_int = foptions.is_new_int
    formatted_content := fmt.fmt(file_ast, mut table, prefs, foptions.is_debug,
        source_text: input_text
    )
    print(formatted_content)
    flush_stdout()
    foptions.vlog('fmt.fmt worked and ${formatted_content.len} bytes were written to stdout.')
}

fn (mut foptions FormatOptions) post_process_file(file string, formatted_file_path string) ! {
    if formatted_file_path == '' {
        return
    }
    fc := os.read_file(file) or {
        eprintln('File ${file} could not be read')
        return
    }
    formatted_fc := os.read_file(formatted_file_path) or {
        eprintln('File ${formatted_file_path} could not be read')
        return
    }
    is_formatted_different := fc != formatted_fc
    if foptions.is_diff {
        if !is_formatted_different {
            return
        }
        println(diff.compare_files(file, formatted_file_path)!)
        return error('')
    }
    if foptions.is_verify {
        if !is_formatted_different {
            return
        }
        println("${file} is not vfmt'ed")
        return error('')
    }
    if foptions.is_c {
        if is_formatted_different {
            eprintln('File is not formatted: ${file}')
            return error('')
        }
        return
    }
    if foptions.is_l {
        if is_formatted_different {
            eprintln('File needs formatting: ${file}')
        }
        return
    }
    if foptions.is_w {
        if is_formatted_different {
            if foptions.is_backup {
                file_bak := '${file}.bak'
                os.cp(file, file_bak) or {}
            }
            mut perms_to_restore := u32(0)
            $if !windows {
                fm := os.inode(file)
                perms_to_restore = fm.bitmask()
            }
            os.mv_by_cp(formatted_file_path, file) or { panic(err) }
            $if !windows {
                os.chmod(file, int(perms_to_restore)) or { panic(err) }
            }
            eprintln('Reformatted file: ${file}')
        } else {
            eprintln('Already formatted file: ${file}')
        }
        return
    }
    print(formatted_fc)
    flush_stdout()
}

@[noreturn]
fn verror(s string) {
    util.verror('vfmt error', s)
}

fn (f FormatOptions) str() string {
    return
        'FormatOptions{ is_l: ${f.is_l}, is_w: ${f.is_w}, is_diff: ${f.is_diff}, is_verbose: ${f.is_verbose},' +
        ' is_worker: ${f.is_worker}, is_debug: ${f.is_debug}, is_noerror: ${f.is_noerror},' +
        ' is_verify: ${f.is_verify}" }'
}