module cli

import term
import strings

const base_indent_len = 2
const min_description_indent_len = 20
const spacing = 2

fn help_flag(with_abbrev bool) Flag {
    sabbrev := if with_abbrev { 'h' } else { '' }
    return Flag{
        flag:        .bool
        name:        'help'
        abbrev:      sabbrev
        description: 'Print help information'
    }
}

fn help_cmd() Command {
    return Command{
        name:        'help'
        usage:       '<command>'
        description: 'Print help information'
        execute:     print_help_for_command
    }
}

// print_help_for_command outputs the help message of `help_cmd`.
pub fn print_help_for_command(cmd Command) ! {
    if cmd.args.len > 0 {
        for sub_cmd in cmd.commands {
            if sub_cmd.matches(cmd.args[0]) {
                cmd_ := unsafe { &sub_cmd }
                print(cmd_.help_message())
                return
            }
        }
        print('Invalid command: ${cmd.args.join(' ')}')
    } else if cmd.parent != unsafe { nil } {
        print(cmd.parent.help_message())
    }
}

// help_message returns a generated help message as a `string` for the `Command`.
//
// The output is composed of (each section is omitted when empty):
//
//   1. `Usage:` line
//   2. The description, if any
//   3. `Flags:` — flags defined on this command
//   4. `Inherited flags:` — flags propagated from any ancestor via `Flag.global`
//   5. One section per sub-command group; the group name is rendered as the
//      user wrote it followed by `:`. Sub-commands without a group go under
//      the default `Commands:` section.
//   6. `Examples:` — `Command.examples` entries, one per line
//   7. `Learn more:` — the multi-line `Command.learn_more` field
pub fn (cmd &Command) help_message() string {
    mut help := ''
    help += 'Usage: ${cmd.full_name()}'
    if cmd.flags.len > 0 {
        help += ' [flags]'
    }
    if cmd.commands.len > 0 {
        help += ' [commands]'
    }
    if cmd.usage.len > 0 {
        help += ' ${cmd.usage}'
    } else {
        for i in 0 .. cmd.required_args {
            help += ' <arg${i}>'
        }
    }
    help += '\n'
    if cmd.description != '' {
        help += '\n${cmd.description}\n'
    }
    abbrev_len, name_len := cmd.help_columns()
    local_flags, inherited_flags := cmd.partition_flags()
    if local_flags.len > 0 {
        help += render_flag_section('Flags', local_flags, abbrev_len, name_len, cmd.posix_mode)
    }
    if inherited_flags.len > 0 {
        help += render_flag_section('Inherited flags', inherited_flags, abbrev_len, name_len,
            cmd.posix_mode)
    }
    if cmd.commands.len > 0 {
        groups, order := group_commands(cmd.commands)
        for idx, key in order {
            title := if key == '' { 'Commands' } else { key }
            help += render_command_section(title, groups[idx], name_len)
        }
    }
    if cmd.examples.len > 0 {
        help += '\nExamples:\n'
        base_indent := ' '.repeat(base_indent_len)
        for line in cmd.examples {
            help += '${base_indent}${line}\n'
        }
    }
    if cmd.learn_more != '' {
        help += '\nLearn more:\n'
        base_indent := ' '.repeat(base_indent_len)
        for line in cmd.learn_more.split_into_lines() {
            help += '${base_indent}${line}\n'
        }
    }
    return help
}

// help_columns computes the abbreviation column width and the name column
// width used by `Flags:`, `Inherited Flags:` and command sections so all
// rows align vertically.
fn (cmd &Command) help_columns() (int, int) {
    mut abbrev_len := 0
    mut name_len := min_description_indent_len
    if cmd.posix_mode {
        for flag in cmd.flags {
            if flag.abbrev != '' {
                abbrev_len = max(abbrev_len, flag.abbrev.len + spacing + 1) // + 1 for '-' in front
            }
            name_len =
                max(name_len, abbrev_len + flag.name.len + spacing + 2) // + 2 for '--' in front
        }
    } else {
        for flag in cmd.flags {
            if flag.abbrev != '' {
                abbrev_len = max(abbrev_len, flag.abbrev.len + spacing + 1) // + 1 for '-' in front
            }
            name_len =
                max(name_len, abbrev_len + flag.name.len + spacing + 1) // + 1 for '-' in front
        }
    }
    for command in cmd.commands {
        name_len = max(name_len, command.display_name().len + spacing)
    }
    return abbrev_len, name_len
}

// partition_flags splits this command's `flags` into two arrays preserving
// declaration order: locally-defined flags first, then flags inherited from
// any ancestor via `Flag.global`.
fn (cmd &Command) partition_flags() ([]Flag, []Flag) {
    inherited_names := cmd.inherited_global_flag_names()
    mut local := []Flag{}
    mut inherited := []Flag{}
    for flag in cmd.flags {
        if flag.name in inherited_names {
            inherited << flag
        } else {
            local << flag
        }
    }
    return local, inherited
}

// inherited_global_flag_names returns the names of flags that any ancestor
// declared with `global = true`. A flag is "inherited" only when an ancestor
// declared it global, never when this command itself defines it.
fn (cmd &Command) inherited_global_flag_names() []string {
    mut names := []string{}
    mut walker := cmd.parent
    for unsafe { walker != nil } {
        for flag in walker.flags {
            if flag.global && flag.name !in names {
                names << flag.name
            }
        }
        walker = walker.parent
    }
    return names
}

// group_commands buckets `commands` by their `group` field, preserving the
// declaration order of both groups and members.
fn group_commands(commands []Command) ([][]Command, []string) {
    mut order := []string{}
    mut groups := [][]Command{}
    for sub in commands {
        key := sub.group
        idx := order.index(key)
        if idx == -1 {
            order << key
            groups << [sub]
        } else {
            groups[idx] << sub
        }
    }
    return groups, order
}

fn render_flag_section(title string, flags []Flag, abbrev_len int, name_len int, posix_mode bool) string {
    mut out := '\n${title}:\n'
    prefix := if posix_mode { '--' } else { '-' }
    base_indent := ' '.repeat(base_indent_len)
    for flag in flags {
        mut flag_name := ''
        if flag.abbrev != '' {
            abbrev_indent := ' '.repeat(abbrev_len - flag.abbrev.len - 1) // - 1 for '-' in front
            flag_name = '-${flag.abbrev}${abbrev_indent}${prefix}${flag.name}'
        } else {
            abbrev_indent := ' '.repeat(abbrev_len)
            flag_name = '${abbrev_indent}${prefix}${flag.name}'
        }
        mut required := ''
        if flag.required {
            required = ' (required)'
        }
        description_indent := ' '.repeat(name_len - flag_name.len)
        out += '${base_indent}${flag_name}${description_indent}' +
            pretty_description(flag.description + required, base_indent_len + name_len) + '\n'
    }
    return out
}

fn render_command_section(title string, commands []Command, name_len int) string {
    mut out := '\n${title}:\n'
    base_indent := ' '.repeat(base_indent_len)
    for command in commands {
        command_name := command.display_name()
        description_indent := ' '.repeat(name_len - command_name.len)
        out += '${base_indent}${command_name}${description_indent}' +
            pretty_description(command.description, base_indent_len + name_len) + '\n'
    }
    return out
}

// pretty_description resizes description text depending on terminal width.
// Essentially, smart wrap-around
fn pretty_description(s string, indent_len int) string {
    width, _ := term.get_terminal_size()
    // Don't prettify if the terminal is that small, it won't be pretty anyway.
    if indent_len > width {
        return s
    }
    indent := ' '.repeat(indent_len)
    chars_per_line := width - indent_len
    // Give us enough room, better a little bigger than smaller
    mut acc := strings.new_builder(((s.len / chars_per_line) + 1) * (width + 1))
    for k, line in s.split('\n') {
        if k != 0 {
            acc.write_string('\n${indent}')
        }
        mut i := chars_per_line - 2
        mut j := 0
        for ; i < line.len; i += chars_per_line - 2 {
            for j > 0 && line[j] != ` ` {
                j--
            }
            // indent was already done the first iteration
            if j != 0 {
                acc.write_string(indent)
            }
            acc.writeln(line[j..i].trim_space())
            j = i
        }
        // We need this even though it should never happen
        if j != 0 {
            acc.write_string(indent)
        }
        acc.write_string(line[j..].trim_space())
    }
    return acc.str()
}

fn max(a int, b int) int {
    res := if a > b { a } else { b }
    return res
}