// Copyright (c) 2026 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 x64

const x64_backend_feature_prefix = 'backend feature: '
pub const x64_backend_limitation_hint = 'x64: native backend limitation: retry with the C backend or reduce the source to supported x64 features'

const x64_minimal_unsupported_crt_stdio_symbols = ['stdin', 'stdout', 'stderr', 'printf', 'fprintf',
	'dprintf', 'sprintf', 'snprintf', 'wprintf', 'puts', 'fputs', 'setvbuf', 'fflush', 'fopen',
	'_wfopen', 'fdopen', 'freopen', '_wfreopen', 'fclose', 'pclose', '_pclose', 'fread', 'fwrite',
	'fgets', 'getc', 'feof', 'ferror', 'fseek', 'ftell', 'rewind', 'fileno', '_fileno',
	'_get_osfhandle', '_open_osfhandle', 'fgetpos']

const x64_unsupported_captured_fn_literal_symbol = 'v2_unsupported_captured_fn_literal'
const x64_missing_v_runtime_helpers = ['builtin__Map_string_int__keys']

fn x64_normalize_backend_feature(feature string) string {
	if feature.starts_with(x64_backend_feature_prefix) {
		return feature[x64_backend_feature_prefix.len..]
	}
	return feature
}

fn x64_unsupported_backend_feature_message(feature string) string {
	return 'x64: unsupported backend feature: ${x64_normalize_backend_feature(feature)}'
}

fn x64_unsupported(message string) {
	x64_abort_with_diagnostic(x64_unsupported_backend_feature_message(message))
}

fn x64_abort_with_diagnostic(message string) {
	eprintln(message)
	eprintln(x64_backend_limitation_hint)
	exit(1)
}

fn x64_linker_name(format ObjectFormat) string {
	return match format {
		.elf { 'ELF linker' }
		.macho { 'Mach-O linker' }
		.coff { 'PE linker' }
	}
}

fn x64_unresolved_external_symbol_message(format ObjectFormat, name string, context string) string {
	linker_name := x64_linker_name(format)
	if format == .coff && name in x64_minimal_unsupported_crt_stdio_symbols {
		return x64_unsupported_backend_feature_message('${linker_name} cannot resolve C stdio/file-descriptor symbol `${name}`: Windows x64 native backend uses Kernel32 handles, not C FILE/stdio calls; ${context}')
	}
	if name == x64_unsupported_captured_fn_literal_symbol {
		return x64_unsupported_backend_feature_message('native x64 cannot lower captured function literal: closure environments are not implemented yet; ${context}')
	}
	if name in x64_missing_v_runtime_helpers {
		return x64_unsupported_backend_feature_message('${linker_name} cannot resolve V runtime helper `${name}`: native x64 backend does not implement this feature for this target yet; ${context}')
	}
	return x64_unsupported_backend_feature_message('${linker_name} cannot resolve external symbol `${name}` yet; ${context}')
}

pub fn unsupported_external_symbol_message_for_name(format ObjectFormat, raw_name string, context string) ?string {
	name := x64_normalize_external_symbol_name(format, raw_name)
	if x64_symbol_needs_backend_runtime_support(name) {
		return x64_unresolved_external_symbol_message(format, name, context)
	}
	return none
}

fn x64_normalize_external_symbol_name(format ObjectFormat, name string) string {
	if format == .macho && name.starts_with('_') {
		return name[1..]
	}
	return name
}

fn x64_symbol_needs_backend_runtime_support(name string) bool {
	return name == x64_unsupported_captured_fn_literal_symbol
		|| name in x64_missing_v_runtime_helpers
}