module builder

import os
import strings
import v.pref
import v.gen.c as cgen
import v.util.version

const default_c_error_bug_report_url = 'https://bugs.vlang.io/bug-report'
const c_error_bug_report_disabled_env = 'V_C_ERROR_BUG_REPORT_DISABLED'
const c_error_context_radius = 5
const c_error_bug_report_max_body_bytes = 256 * 1024
const c_error_bug_report_truncation_notice = '\n... report truncated before upload ...\n'

struct CErrorReportLine {
pub:
	line int
	text string
}

struct CErrorReportLocation {
pub:
	file string
	line int
}

struct CErrorBugReport {
pub:
	kind           string
	v_version      string
	target_os      string
	target_backend string
	ccompiler      string
	c_error        string
	c_file         string
	c_line         int
	c_context      []CErrorReportLine
	v_file         string
	v_line         int
	v_context      []CErrorReportLine
}

fn (mut v Builder) submit_c_error_bug_report(ccompiler string, c_output string) {
	if !should_submit_c_error_bug_report(v.pref.c_error_bug_report_url) {
		return
	}
	mut raw_report := v.new_c_error_bug_report(ccompiler, c_output)
	if raw_report.v_file == '' {
		// The default `.tmp.c` has no `#line` directives, so the C error could not be
		// traced back to a V line. Regenerate the C with `#line` info (as `-g` would),
		// recompile, and reuse the richer report when it does map to a V source line.
		if vlines_report := v.new_c_error_bug_report_with_vlines(ccompiler) {
			raw_report = vlines_report
		}
	}
	report := bounded_c_error_bug_report(raw_report, c_error_bug_report_max_body_bytes)
	report_url := c_error_bug_report_url(v.pref.c_error_bug_report_url)
	tool_output := send_c_error_bug_report(report, report_url) or {
		eprintln('C compiler bug report was not sent to ${report_url}: ${err}')
		return
	}
	println('================== C compiler bug report ==============')
	if tool_output != '' {
		println(tool_output)
	}
	print_c_error_bug_report_context(report)
	println('='.repeat('================== C compiler bug report =============='.len))
}

fn (mut v Builder) new_c_error_bug_report(ccompiler string, c_output string) CErrorBugReport {
	c_source := os.read_file(v.out_name_c) or { '' }
	c_lines := c_source.split_into_lines()
	mut c_file := v.out_name_c
	mut c_line := 0
	mut v_file := ''
	mut v_line := 0
	if c_loc := c_error_location_for_generated_c(c_output, v.out_name_c) {
		c_file = c_loc.file
		c_line = c_loc.line
		if v_loc := v_source_location_for_c_line(c_lines, c_line, v.out_name_c) {
			v_file = v_loc.file
			v_line = v_loc.line
		}
	} else if source_loc := first_error_source_location(c_output) {
		v_file = source_loc.file
		v_line = source_loc.line
		if found_c_line := generated_c_line_for_source_location(c_lines, source_loc, v.out_name_c) {
			c_line = found_c_line
		}
	}
	v_source := if v_file != '' { os.read_file(v_file) or { '' } } else { '' }
	return CErrorBugReport{
		kind:           'v-c-compiler-error'
		v_version:      version.full_v_version(true)
		target_os:      v.pref.os.str()
		target_backend: v.pref.backend.str()
		ccompiler:      ccompiler
		c_error:        c_output
		c_file:         c_file
		c_line:         c_line
		c_context:      numbered_context_lines(c_lines, c_line, c_error_context_radius)
		v_file:         v_file
		v_line:         v_line
		v_context:      numbered_context_lines(v_source.split_into_lines(), v_line,
			c_error_context_radius)
	}
}

// new_c_error_bug_report_with_vlines regenerates the program's C source with `#line`
// directives enabled (the same information `-g` would add), recompiles it with the
// previously used C compiler command, and builds a report from the recompiled output.
// Because the regenerated C carries `#line` annotations, the C error can be mapped back
// to the exact V source line that produced it. It returns none when the V mapping still
// cannot be produced, so the caller keeps the original, C-only report.
fn (mut v Builder) new_c_error_bug_report_with_vlines(ccompiler string) ?CErrorBugReport {
	if v.pref.is_vlines || v.pref.parallel_cc || v.pref.generate_c_project != ''
		|| v.last_cc_cmd == '' || v.parsed_files.len == 0 || v.out_name_c == '' {
		return none
	}
	old_is_vlines := v.pref.is_vlines
	v.pref.is_vlines = true
	defer {
		v.pref.is_vlines = old_is_vlines
	}
	// Regenerate the C source, now with `#line` directives, into the same `.tmp.c` file,
	// so that the recorded compiler command recompiles exactly the annotated source.
	// Keep the original `.tmp.c` so that it can be restored afterwards (e.g. for `-keepc`).
	original_c := os.read_file(v.out_name_c) or { return none }
	goutput := cgen.gen(v.parsed_files, mut v.table, v.pref)
	mut c_builder := goutput.res_builder
	c_builder = cgen.fix_reset_dbg_line(c_builder, v.out_name_c)
	os.write_file_array(v.out_name_c, c_builder) or { return none }
	vdir := os.dir(pref.vexe_path())
	original_pwd := os.getwd()
	os.chdir(vdir) or {}
	recompiled := os.execute(v.last_cc_cmd)
	os.chdir(original_pwd) or {}
	report := v.new_c_error_bug_report(ccompiler, recompiled.output)
	// Restore the C source that the user actually compiled, now that the report is built.
	os.write_file(v.out_name_c, original_c) or {}
	if report.v_file == '' {
		return none
	}
	return report
}

fn c_error_bug_report_url(flag_url string) string {
	trimmed_flag_url := flag_url.trim_space()
	if trimmed_flag_url != '' {
		return trimmed_flag_url.trim_right('/')
	}
	env_url := os.getenv('V_C_ERROR_BUG_REPORT_URL').trim_space()
	if env_url != '' {
		return env_url.trim_right('/')
	}
	return default_c_error_bug_report_url
}

fn should_submit_c_error_bug_report(flag_url string) bool {
	if c_error_bug_reports_disabled() {
		return false
	}
	if running_in_github_ci() {
		return c_error_bug_report_url(flag_url) != default_c_error_bug_report_url
	}
	return true
}

fn c_error_bug_reports_disabled() bool {
	return os.getenv(c_error_bug_report_disabled_env).trim_space().to_lower() in ['1', 'true',
		'yes', 'on']
}

fn disable_c_error_bug_reports() {
	os.setenv(c_error_bug_report_disabled_env, '1', true)
}

fn running_in_github_ci() bool {
	return os.getenv('GITHUB_ACTIONS') == 'true' || os.getenv('GITHUB_JOB') != ''
}

fn send_c_error_bug_report(report CErrorBugReport, report_url string) !string {
	report_path := os.join_path(os.vtmp_dir(), 'v-c-error-report-${os.getpid()}.json')
	os.write_file(report_path, c_error_bug_report_json(report))!
	defer {
		os.rm(report_path) or {}
	}
	cmd := '${os.quoted_path(pref.vexe_path())} bug-report-send --url ${os.quoted_path(report_url)} --file ${os.quoted_path(report_path)}'
	res := os.execute(cmd)
	if res.exit_code != 0 {
		return error(res.output.trim_space())
	}
	return res.output.trim_right('\r\n')
}

fn c_error_bug_report_json(report CErrorBugReport) string {
	mut b := strings.new_builder(1024 + report.c_error.len)
	b.write_u8(`{`)
	write_json_string_field(mut b, 'kind', report.kind, false)
	write_json_string_field(mut b, 'v_version', report.v_version, true)
	write_json_string_field(mut b, 'target_os', report.target_os, true)
	write_json_string_field(mut b, 'target_backend', report.target_backend, true)
	write_json_string_field(mut b, 'ccompiler', report.ccompiler, true)
	write_json_string_field(mut b, 'c_error', report.c_error, true)
	write_json_string_field(mut b, 'c_file', report.c_file, true)
	write_json_int_field(mut b, 'c_line', report.c_line, true)
	write_json_report_lines_field(mut b, 'c_context', report.c_context, true)
	write_json_string_field(mut b, 'v_file', report.v_file, true)
	write_json_int_field(mut b, 'v_line', report.v_line, true)
	write_json_report_lines_field(mut b, 'v_context', report.v_context, true)
	b.write_u8(`}`)
	return b.str()
}

fn write_json_string_field(mut b strings.Builder, name string, value string, needs_comma bool) {
	write_json_field_name(mut b, name, needs_comma)
	write_json_string(mut b, value)
}

fn write_json_int_field(mut b strings.Builder, name string, value int, needs_comma bool) {
	write_json_field_name(mut b, name, needs_comma)
	b.write_string(value.str())
}

fn write_json_report_lines_field(mut b strings.Builder, name string, lines []CErrorReportLine, needs_comma bool) {
	write_json_field_name(mut b, name, needs_comma)
	b.write_u8(`[`)
	for idx, line in lines {
		if idx > 0 {
			b.write_u8(`,`)
		}
		b.write_u8(`{`)
		write_json_int_field(mut b, 'line', line.line, false)
		write_json_string_field(mut b, 'text', line.text, true)
		b.write_u8(`}`)
	}
	b.write_u8(`]`)
}

fn write_json_field_name(mut b strings.Builder, name string, needs_comma bool) {
	if needs_comma {
		b.write_u8(`,`)
	}
	write_json_string(mut b, name)
	b.write_u8(`:`)
}

fn write_json_string(mut b strings.Builder, value string) {
	b.write_u8(`"`)
	for ch in value.bytes() {
		match ch {
			`"` {
				b.write_string('\\"')
			}
			`\\` {
				b.write_string('\\\\')
			}
			`\b` {
				b.write_string('\\b')
			}
			`\f` {
				b.write_string('\\f')
			}
			`\n` {
				b.write_string('\\n')
			}
			`\r` {
				b.write_string('\\r')
			}
			`\t` {
				b.write_string('\\t')
			}
			else {
				if ch < 0x20 {
					write_json_control_escape(mut b, ch)
				} else {
					b.write_u8(ch)
				}
			}
		}
	}
	b.write_u8(`"`)
}

fn write_json_control_escape(mut b strings.Builder, ch u8) {
	hex := '0123456789abcdef'
	b.write_string('\\u00')
	b.write_u8(hex[ch >> 4])
	b.write_u8(hex[ch & 0x0f])
}

fn bounded_c_error_bug_report(report CErrorBugReport, max_body_bytes int) CErrorBugReport {
	if max_body_bytes <= 0 || c_error_bug_report_json(report).len <= max_body_bytes {
		return report
	}
	if bounded := report_with_bounded_c_error(report, max_body_bytes, report.c_context,
		report.v_context)
	{
		return bounded
	}
	for context_text_bytes in [4096, 1024, 256, 80, 0] {
		c_context := bounded_report_lines(report.c_context, context_text_bytes)
		v_context := bounded_report_lines(report.v_context, context_text_bytes)
		if bounded := report_with_bounded_c_error(report, max_body_bytes, c_context, v_context) {
			return bounded
		}
	}
	return CErrorBugReport{
		...report
		c_error:   truncated_report_text(report.c_error, 0)
		c_context: []CErrorReportLine{}
		v_context: []CErrorReportLine{}
	}
}

fn report_with_bounded_c_error(report CErrorBugReport, max_body_bytes int, c_context []CErrorReportLine, v_context []CErrorReportLine) ?CErrorBugReport {
	min_report := CErrorBugReport{
		...report
		c_error:   truncated_report_text(report.c_error, 0)
		c_context: c_context
		v_context: v_context
	}
	if c_error_bug_report_json(min_report).len > max_body_bytes {
		return none
	}
	mut low := 0
	mut high := report.c_error.len
	mut best := min_report
	for low <= high {
		mid := (low + high) / 2
		candidate := CErrorBugReport{
			...report
			c_error:   truncated_report_text(report.c_error, mid)
			c_context: c_context
			v_context: v_context
		}
		if c_error_bug_report_json(candidate).len <= max_body_bytes {
			best = candidate
			low = mid + 1
		} else {
			high = mid - 1
		}
	}
	return best
}

fn bounded_report_lines(lines []CErrorReportLine, max_text_bytes int) []CErrorReportLine {
	mut bounded := []CErrorReportLine{cap: lines.len}
	for report_line in lines {
		bounded << CErrorReportLine{
			line: report_line.line
			text: truncated_report_text(report_line.text, max_text_bytes)
		}
	}
	return bounded
}

fn truncated_report_text(text string, max_bytes int) string {
	if max_bytes <= 0 {
		return ''
	}
	if text.len <= max_bytes {
		return text
	}
	if max_bytes <= c_error_bug_report_truncation_notice.len {
		return text[..max_bytes]
	}
	kept_bytes := max_bytes - c_error_bug_report_truncation_notice.len
	head_bytes := kept_bytes / 2
	tail_bytes := kept_bytes - head_bytes
	return text[..head_bytes] + c_error_bug_report_truncation_notice + text[text.len - tail_bytes..]
}

fn print_c_error_bug_report_context(report CErrorBugReport) {
	println('Generated C lines sent from ${report.c_file}:${report.c_line}:')
	print_report_lines(report.c_context, report.c_line)
	if report.v_file != '' {
		println('Corresponding V lines sent from ${report.v_file}:${report.v_line}:')
		print_report_lines(report.v_context, report.v_line)
	} else {
		println('Corresponding V lines sent: no V source mapping was available.')
	}
}

fn print_report_lines(lines []CErrorReportLine, center int) {
	if lines.len == 0 {
		println('  (no source lines available)')
		return
	}
	for line in lines {
		prefix := if line.line == center { '>' } else { ' ' }
		println('${prefix} ${line.line:6} | ${line.text}')
	}
}

fn numbered_context_lines(lines []string, center int, radius int) []CErrorReportLine {
	if center <= 0 || lines.len == 0 {
		return []CErrorReportLine{}
	}
	mut start := center - radius
	if start < 1 {
		start = 1
	}
	mut end := center + radius
	if end > lines.len {
		end = lines.len
	}
	mut context := []CErrorReportLine{cap: end - start + 1}
	for line_nr in start .. end + 1 {
		context << CErrorReportLine{
			line: line_nr
			text: lines[line_nr - 1]
		}
	}
	return context
}

fn c_error_location_for_generated_c(c_output string, generated_c_file string) ?CErrorReportLocation {
	needles := c_error_generated_c_needles(generated_c_file)
	for output_line in c_output.split_into_lines() {
		if !output_line.to_lower_ascii().contains('error') {
			continue
		}
		for needle in needles {
			if loc := parse_error_location_after_needle(output_line, needle) {
				return loc
			}
		}
	}
	return none
}

fn c_error_generated_c_needles(generated_c_file string) []string {
	mut needles := []string{}
	for candidate in [generated_c_file, os.real_path(generated_c_file),
		os.file_name(generated_c_file)] {
		if candidate != '' && candidate !in needles {
			needles << candidate
		}
		normalized := candidate.replace('\\', '/')
		if normalized != '' && normalized !in needles {
			needles << normalized
		}
	}
	return needles
}

fn parse_error_location_after_needle(output_line string, needle string) ?CErrorReportLocation {
	idx := output_line.index(needle) or { return none }
	after := output_line[idx + needle.len..]
	if after.starts_with(':') {
		line_nr := leading_int(after[1..])
		if line_nr > 0 {
			return CErrorReportLocation{
				file: needle
				line: line_nr
			}
		}
	}
	if after.starts_with('(') {
		line_nr := leading_int(after[1..])
		if line_nr > 0 {
			return CErrorReportLocation{
				file: needle
				line: line_nr
			}
		}
	}
	return none
}

fn first_error_source_location(c_output string) ?CErrorReportLocation {
	for output_line in c_output.split_into_lines() {
		if !output_line.to_lower_ascii().contains('error') {
			continue
		}
		if loc := parse_colon_error_location(output_line) {
			return loc
		}
		if loc := parse_msvc_error_location(output_line) {
			return loc
		}
	}
	return none
}

fn parse_colon_error_location(output_line string) ?CErrorReportLocation {
	parts := output_line.split(':')
	if parts.len < 2 {
		return none
	}
	for idx := 1; idx < parts.len; idx++ {
		line_nr := parts[idx].int()
		if line_nr <= 0 {
			continue
		}
		file := parts[..idx].join(':')
		if file == '' {
			continue
		}
		return CErrorReportLocation{
			file: file
			line: line_nr
		}
	}
	return none
}

fn parse_msvc_error_location(output_line string) ?CErrorReportLocation {
	open_idx := output_line.index('(') or { return none }
	close_rel_idx := output_line[open_idx + 1..].index(')') or { return none }
	line_nr := leading_int(output_line[open_idx + 1..open_idx + 1 + close_rel_idx])
	if line_nr <= 0 {
		return none
	}
	return CErrorReportLocation{
		file: output_line[..open_idx]
		line: line_nr
	}
}

fn v_source_location_for_c_line(c_lines []string, c_line int, generated_c_file string) ?CErrorReportLocation {
	if c_line <= 0 || c_lines.len == 0 {
		return none
	}
	mut current := CErrorReportLocation{}
	last_line := if c_line <= c_lines.len { c_line } else { c_lines.len }
	for idx in 0 .. last_line {
		if directive := parse_line_directive(c_lines[idx]) {
			current = directive
			continue
		}
		if idx + 1 == c_line && is_v_source_file(current.file)
			&& !same_path(current.file, generated_c_file) {
			return current
		}
		if current.file != '' {
			current = CErrorReportLocation{
				file: current.file
				line: current.line + 1
			}
		}
	}
	return none
}

fn generated_c_line_for_source_location(c_lines []string, source CErrorReportLocation, generated_c_file string) ?int {
	if source.file == '' || source.line <= 0 {
		return none
	}
	mut current := CErrorReportLocation{}
	mut fallback_line := 0
	for idx, line in c_lines {
		if directive := parse_line_directive(line) {
			current = directive
			continue
		}
		if is_v_source_file(current.file) && !same_path(current.file, generated_c_file)
			&& same_path(current.file, source.file) && current.line == source.line {
			if fallback_line == 0 {
				fallback_line = idx + 1
			}
			if line.trim_space() != '' {
				return idx + 1
			}
		}
		if current.file != '' {
			current = CErrorReportLocation{
				file: current.file
				line: current.line + 1
			}
		}
	}
	if fallback_line > 0 {
		return fallback_line
	}
	return none
}

fn parse_line_directive(line string) ?CErrorReportLocation {
	trimmed := line.trim_space()
	if !trimmed.starts_with('#line ') {
		return none
	}
	rest := trimmed['#line '.len..].trim_space()
	line_nr := leading_int(rest)
	if line_nr <= 0 {
		return none
	}
	first_quote_idx := rest.index('"') or { return none }
	remaining := rest[first_quote_idx + 1..]
	second_quote_idx := remaining.index('"') or { return none }
	return CErrorReportLocation{
		file: remaining[..second_quote_idx]
		line: line_nr
	}
}

fn leading_int(s string) int {
	mut end := 0
	for end < s.len && s[end].is_digit() {
		end++
	}
	if end == 0 {
		return 0
	}
	return s[..end].int()
}

fn is_v_source_file(path string) bool {
	return path.ends_with('.v') || path.ends_with('.vv') || path.ends_with('.vsh')
}

fn same_path(a string, b string) bool {
	if a == b {
		return true
	}
	normalized_a := a.replace('\\', '/')
	normalized_b := b.replace('\\', '/')
	return normalized_a == normalized_b
		|| os.real_path(a).replace('\\', '/') == os.real_path(b).replace('\\', '/')
}