module main

import os
import cli
import net.http
import net.urllib
import json
import rand
import term

const search_endpoint = 'https://api.github.com/search/issues'
const issue_endpoint = 'https://api.github.com/repos/vlang/v/issues'
const confirm_search_query = 'repo:vlang/v is:issue is:open -label:"Status: Confirmed"'
const fix_search_query = 'repo:vlang/v is:issue is:open'
const feature_search_query = 'repo:vlang/v is:issue state:open label:"Feature/Enhancement Request"'
const per_page = 100
const max_search_results = 1000

struct SearchResponse {
    total_count int
    items       []Issue
}

struct Issue {
    number   int
    title    string
    html_url string
    body     string
    labels   []Label
}

struct Label {
    name string
}

struct IssueDetails {
    number   int
    title    string
    html_url string
    body     string
    labels   []Label
    state    string
}

fn main() {
    // the 0th arg is /path/to/vquest, the 1st is `quest`; the args after that are the subcommands
    mut args := []string{}
    args << os.args[0]
    args << os.args#[2..]
    mut app := cli.Command{
        name:        'v quest'
        description: 'A tool to help make V better for everyone, by spending some time each day, on random tasks/missions like:\n * documenting public APIs\n * issue confirmation reviewing and triage\n * testing'
        execute:     cli.print_help_for_command
        posix_mode:  true
        defaults:    struct {
            man: false
        }
        commands:    [
            cli.Command{
                name:        'document'
                description: 'Print a random missing doc entry from the V standard library.'
                execute:     run_document
            },
            cli.Command{
                name:        'confirm'
                description: 'Open a random vlang/v issue, that is still unconfirmed in your browser.'
                flags:       issue_flags.clone()
                execute:     run_confirm
            },
            cli.Command{
                name:        'fix'
                description: 'Open a random vlang/v issue (but still open) in your browser.'
                flags:       issue_flags.clone()
                execute:     run_fix
            },
            cli.Command{
                name:        'implement'
                description: 'Open a random vlang/v feature request issue in your browser.'
                flags:       issue_flags.clone()
                execute:     run_implement
            },
            cli.Command{
                name:        'solve'
                description: 'Find a random bug reproducible on your OS, print it to stdout and save to bug-<issue_id>.md.'
                flags:       solve_flags.clone()
                execute:     run_solve
            },
        ]
    }
    app.setup()
    if args.len <= 1 {
        if rcmd := rand.element(app.commands) {
            rcmd.execute(rcmd)!
            return
        }
    }
    app.parse(args)
}

const issue_flags = [
    cli.Flag{
        description: 'Print the issue URL without opening a browser.'
        flag:        .bool
        name:        'print-only'
        abbrev:      'p'
    },
    cli.Flag{
        description:   'Start page for issues (default -1: auto). Must be > 0.'
        flag:          .int
        name:          'from'
        abbrev:        'f'
        default_value: ['-1']
    },
    cli.Flag{
        description:   'End page for issues (default -1: auto). Must be > 0 and >= the from page (see -f).'
        flag:          .int
        name:          'to'
        abbrev:        't'
        default_value: ['-1']
    },
]

const solve_flags = [
    cli.Flag{
        description:   'Override OS detection (macos, windows, linux).'
        flag:          .string
        name:          'os'
        abbrev:        'o'
        default_value: ['']
    },
    cli.Flag{
        description:   'Start page for issues (default -1: auto). Must be > 0.'
        flag:          .int
        name:          'from'
        abbrev:        'f'
        default_value: ['-1']
    },
    cli.Flag{
        description:   'End page for issues (default -1: auto). Must be > 0 and >= the from page (see -f).'
        flag:          .int
        name:          'to'
        abbrev:        't'
        default_value: ['-1']
    },
    cli.Flag{
        description:   'Output file for the bug report (default: bug-<issue_id>.md).'
        flag:          .string
        name:          'output'
        abbrev:        'O'
        default_value: ['']
    },
]

fn run_confirm(cmd cli.Command) ! {
    run_issue(cmd, confirm_search_query, 'still unconfirmed',
        'Help us by confirming and triaging this issue:')!
}

fn run_fix(cmd cli.Command) ! {
    run_issue(cmd, fix_search_query, 'open', 'Help us by fixing or confirming this issue:')!
}

fn run_implement(cmd cli.Command) ! {
    run_issue(cmd, feature_search_query, 'feature request',
        'Help us by implementing the issue in a PR, or triage it:')!
}

fn run_solve(cmd cli.Command) ! {
    // Clean up old bug report files
    for f in os.glob('bug-*.md') or { []string{} } {
        os.rm(f) or {}
    }

    user_os := get_target_os(cmd)
    os_label := get_os_label(user_os)
    output_override := cmd.flags.get_string('output') or { '' }

    // Build query that excludes issues for other OSes
    // We look for open bugs that are NOT exclusive to other operating systems
    excluded_os_labels := get_excluded_os_labels(user_os)
    mut query := 'repo:vlang/v is:issue is:open label:Bug'
    for label in excluded_os_labels {
        query += ' -label:"${label}"'
    }

    total := fetch_total_count(query)!
    max_pages := total_to_max_pages(total)
    if max_pages == 0 {
        return error('no bugs found for ${os_label}')
    }
    start_page, end_page := resolve_page_range(cmd, max_pages)!
    page := start_page + (rand.intn(end_page - start_page + 1) or { 0 })
    eprintln(term.colorize(term.gray,
        'Found: ${total} bugs reproducible on ${os_label}. Fetching from page: ${page} in [${start_page}, ${end_page}] ...'))

    issue := fetch_issue_from_page(query, page)!
    details := fetch_issue_details(issue.number)!

    // Format the bug report
    report := format_bug_report(details, user_os)

    // Print to stdout
    println(report)

    // Determine output filename (default: bug-<issue_id>.md)
    output_file := if output_override != '' { output_override } else { 'bug-${details.number}.md' }

    // Write to file
    os.write_file(output_file, report) or {
        return error('failed to write to ${output_file}: ${err}')
    }
    eprintln(term.colorize(term.green, '\nBug report saved to: ${output_file}'))
}

fn get_target_os(cmd cli.Command) string {
    override := cmd.flags.get_string('os') or { '' }
    if override != '' {
        return override.to_lower()
    }
    return os.user_os()
}

fn get_os_label(user_os string) string {
    return match user_os {
        'macos' { 'macOS' }
        'windows' { 'Windows' }
        'linux' { 'Linux' }
        'freebsd' { 'FreeBSD' }
        else { user_os }
    }
}

fn get_excluded_os_labels(user_os string) []string {
    // Return labels for OSes that should be EXCLUDED
    // i.e., if user is on macOS, exclude Windows-only and Linux-only bugs
    all_os_labels := ['OS: Windows', 'OS: Linux', 'OS: macOS', 'OS: FreeBSD']
    user_label := match user_os {
        'macos' { 'OS: macOS' }
        'windows' { 'OS: Windows' }
        'linux' { 'OS: Linux' }
        'freebsd' { 'OS: FreeBSD' }
        else { '' }
    }

    return all_os_labels.filter(it != user_label)
}

fn fetch_issue_details(issue_number int) !IssueDetails {
    url := '${issue_endpoint}/${issue_number}'
    body := api_get(url)!
    return json.decode(IssueDetails, body)!
}

fn format_bug_report(issue IssueDetails, user_os string) string {
    mut report := '# Bug #${issue.number}: ${issue.title}\n\n'
    report += '**URL:** ${issue.html_url}\n\n'
    report += '**Target OS:** ${get_os_label(user_os)}\n\n'

    if issue.labels.len > 0 {
        labels := issue.labels.map(it.name).join(', ')
        report += '**Labels:** ${labels}\n\n'
    }

    report += '## Description\n\n'
    report += issue.body
    report += '\n'

    return report
}

fn run_issue(cmd cli.Command, issue_query string, issue_label string, help_label string) ! {
    print_only := cmd.flags.get_bool('print-only') or { false }
    total := fetch_total_count(issue_query)!
    max_pages := total_to_max_pages(total)
    if max_pages == 0 {
        return error('no unconfirmed issues found')
    }
    start_page, end_page := resolve_page_range(cmd, max_pages)!
    page := start_page + (rand.intn(end_page - start_page + 1) or { 0 })
    eprintln(term.colorize(term.gray,
        'Found: ${total} ${issue_label} issues. Fetching issue from page: ${page} in [${start_page}, ${end_page}] ...'))
    issue := fetch_issue_from_page(issue_query, page)!
    println(term.colorize(term.green, help_label))
    println(issue.html_url)
    if print_only {
        return
    }
    open_uri(issue.html_url)!
}

fn run_document(_cmd cli.Command) ! {
    res :=
        os.execute('${os.quoted_path(@VEXE)} missdoc --exclude vlib/v --exclude /linux_bare/ --exclude /wasm_bare/ @vlib')
    if res.exit_code != 0 {
        return error('v missdoc failed: ${res.output}')
    }
    lines := res.output.split_into_lines().filter(it.trim_space() != '')
    if lines.len == 0 {
        return error('no missing doc entries found')
    }
    idx := rand.intn(lines.len) or { 0 }
    eprintln(term.colorize(term.green, 'Help us document this public API:'))
    println(term.colorize(term.bold, lines[idx]))
}

fn fetch_total_count(query string) !int {
    url := build_search_url(query, 1, 1)
    body := api_get(url)!
    resp := json.decode(SearchResponse, body)!
    return resp.total_count
}

fn resolve_page_range(cmd cli.Command, max_pages int) !(int, int) {
    from, from_set := read_page_limit(cmd, 'from', '-f')!
    to, to_set := read_page_limit(cmd, 'to', '-t')!
    if from_set && to_set && to < from {
        return error('invalid page range: -t (${to}) is smaller than -f (${from})')
    }
    mut start_page := 1
    mut end_page := max_pages
    if from_set {
        start_page = from
    }
    if to_set {
        end_page = to
    }
    if start_page < 1 {
        start_page = 1
    }
    if end_page > max_pages {
        end_page = max_pages
    }
    if end_page < start_page {
        return error('no issues found in the requested page range')
    }
    return start_page, end_page
}

fn read_page_limit(cmd cli.Command, name string, flag_label string) !(int, bool) {
    value := cmd.flags.get_int(name)!
    is_set := flag_is_set(cmd, name)
    if is_set && value < 0 {
        return error('${flag_label} must be >= 0')
    }
    return value, is_set
}

fn flag_is_set(cmd cli.Command, name string) bool {
    for flag in cmd.flags.get_all_found() {
        if flag.name == name {
            return true
        }
    }
    return false
}

fn fetch_issue_from_page(query string, page int) !Issue {
    url := build_search_url(query, page, per_page)
    body := api_get(url)!
    resp := json.decode(SearchResponse, body)!
    if resp.items.len == 0 {
        return error('no issues returned for page ${page}')
    }
    idx := rand.intn(resp.items.len) or { 0 }
    return resp.items[idx]
}

fn build_search_url(query string, page int, per_page int) string {
    mut values := urllib.new_values()
    values.add('q', query)
    values.add('per_page', per_page.str())
    values.add('page', page.str())
    return '${search_endpoint}?${values.encode()}'
}

fn api_get(url string) !string {
    resp := http.fetch(
        url:    url
        method: .get
        header: http.new_header_from_map({
            http.CommonHeader.accept:     'application/vnd.github+json'
            http.CommonHeader.user_agent: 'v quest'
        })
    )!
    if resp.status_code != 200 {
        return error('GitHub API error ${resp.status_code}: ${resp.body}')
    }
    return resp.body
}

fn total_to_max_pages(total int) int {
    if total <= 0 {
        return 0
    }
    max_pages := (total + per_page - 1) / per_page
    limit := max_search_results / per_page
    return if max_pages < limit { max_pages } else { limit }
}

fn open_uri(uri string) ! {
    $if !termux {
        os.open_uri(uri)!
    }
}