pretty_printer.v

// Pretty printer for tree-formatted logging
module logger

import x.json2
import time

// Tree drawing characters
const tee = '├─'
const corner = '└─'
const pipe = '│'
const space = '  '

// pretty_print_event renders a wide event as a tree structure
pub fn pretty_print_event(event WideEvent, config LoggerConfig) {
	mode := config.mode
	field_configs := config.field_configs.clone()

	// Build and print header line
	header := build_header(event, field_configs)
	println(header)

	// Separate fields by priority
	mut header_fields := []string{}
	mut important_fields := []string{}
	mut normal_fields := []string{}
	mut boring_fields := []string{}

	for field, _ in event.context {
		cfg := get_field_config(field, field_configs)

		match cfg.priority {
			.header { header_fields << field }
			.important { important_fields << field }
			.normal { normal_fields << field }
			.boring { boring_fields << field }
			.internal {} // Skip
		}
	}

	// Determine which fields to show based on mode
	mut fields_to_show := []string{}
	fields_to_show << important_fields

	if mode == .normal || mode == .verbose {
		fields_to_show << normal_fields
	}

	if mode == .verbose {
		fields_to_show << boring_fields
	}

	// Calculate hidden count for compact mode
	hidden_count := normal_fields.len + boring_fields.len

	// Print tree
	for i, field in fields_to_show {
		value := event.context[field] or { json2.Any('') }
		is_last := i == fields_to_show.len - 1
		print_tree_node(field, value, 0, is_last, field_configs, mode)
	}

	// Show hidden count in compact mode
	if mode == .compact && hidden_count > 0 {
		println('  ${dim}└─ [${hidden_count} fields hidden, use --verbose]${reset}')
	}

	// Add spacing after event for readability
	println('')
}

// build_header constructs the header line for a wide event
fn build_header(event WideEvent, field_configs map[string]FieldConfig) string {
	mut parts := []string{}

	// Timestamp
	parts << '${dim}${event.timestamp.format_ss()}${reset}'

	// Level with color
	level_color := get_level_color(event.level)
	parts << '${level_color}${event.level.str().to_upper()}${reset}'

	// Service
	parts << '${cyan}[${event.service}]${reset}'

	// Configured header fields from context (in order of appearance in context)
	for field, value in event.context {
		cfg := get_field_config(field, field_configs)
		if cfg.priority != .header {
			continue
		}

		formatted := format_value(value, cfg)
		color_code := if cfg.color != '' { cfg.color } else { reset }
		parts << '${color_code}${formatted}${reset}'
	}

	return parts.join(' ')
}

// print_tree_node recursively prints a tree node
fn print_tree_node(field string, value json2.Any, depth int, is_last bool, configs map[string]FieldConfig, mode DisplayMode) {
	indent := space.repeat(depth)
	prefix := if is_last { corner } else { tee }
	cfg := get_field_config(field, configs)
	color_code := if cfg.color != '' { cfg.color } else { cyan }

	// Format the value
	formatted := format_value(value, cfg)

	// Print the node
	println('${indent}${dim}${prefix}${reset} ${color_code}${field}:${reset} ${formatted}')

	// For objects, recurse if in verbose mode or if important
	if value is map[string]json2.Any {
		m := value as map[string]json2.Any
		should_expand := mode == .verbose || cfg.priority == .important
		if should_expand && m.len > 0 {
			child_keys := m.keys()
			for i, child_key in child_keys {
				child_value := m[child_key] or { json2.Any('') }
				child_is_last := i == child_keys.len - 1
				print_tree_node(child_key, child_value, depth + 1, child_is_last, configs,
					mode)
			}
		}
	}

	// For arrays, show items or summary
	if value is []json2.Any {
		arr := value as []json2.Any
		max_items := if mode == .verbose { 10 } else { 3 }
		if arr.len == 0 {
			// Already shown as "[]" by format_value
		} else if arr.len > max_items {
			// Show first max_items
			for i in 0 .. max_items {
				child_indent := space.repeat(depth + 1)
				child_prefix := if i == max_items - 1 { corner } else { tee }
				item_value := arr[i]
				item_formatted := format_simple_value(item_value)
				println('${child_indent}${dim}${child_prefix}${reset} ${dim}[${i}]${reset} ${item_formatted}')
			}
			// Show "more items" indicator
			println('${space.repeat(depth + 1)}${dim}└─ ... and ${arr.len - max_items} more${reset}')
		} else {
			// Show all items
			for i, item_value in arr {
				child_indent := space.repeat(depth + 1)
				child_prefix := if i == arr.len - 1 { corner } else { tee }
				item_formatted := format_simple_value(item_value)
				println('${child_indent}${dim}${child_prefix}${reset} ${dim}[${i}]${reset} ${item_formatted}')
			}
		}
	}
}

// format_value formats a value based on its field configuration
fn format_value(value json2.Any, cfg FieldConfig) string {
	// Use custom formatter if provided
	if formatter := cfg.formatter {
		return formatter(value)
	}

	// Default formatting
	return format_simple_value(value)
}

// format_simple_value provides default formatting for any json2.Any value
fn format_simple_value(value json2.Any) string {
	return match value {
		string {
			value
		}
		bool {
			value.str()
		}
		int {
			value.str()
		}
		i8 {
			value.str()
		}
		i16 {
			value.str()
		}
		i64 {
			value.str()
		}
		u8 {
			value.str()
		}
		u16 {
			value.str()
		}
		u32 {
			value.str()
		}
		u64 {
			value.str()
		}
		f32 {
			'${value:.4f}'
		}
		f64 {
			'${value:.4f}'
		}
		map[string]json2.Any {
			// Summarize object
			keys := value.keys()
			return '{${keys.len} fields}'
		}
		[]json2.Any {
			// Summarize array
			return '[${value.len} items]'
		}
		time.Time {
			value.format_rfc3339()
		}
		else {
			value.str()
		}
	}
}

// format_value_with_config is a public helper for formatting with field config
pub fn format_value_with_config(value json2.Any, field_name string, configs map[string]FieldConfig) string {
	cfg := get_field_config(field_name, configs)
	return format_value(value, cfg)
}

// print_event_as_json outputs an event as JSON (for production)
pub fn print_event_as_json(event WideEvent) {
	// Build a simple JSON representation
	mut parts := []string{}
	parts << '{'
	parts << '  "timestamp": "${event.timestamp.format_rfc3339()}"'
	parts << '  "level": "${event.level.str()}"'
	parts << '  "service": "${event.service}"'
	parts << '  "environment": "${event.environment}"'

	// Add context fields
	for key, value in event.context {
		parts << '  "${key}": "${value.str()}"'
	}

	parts << '}'
	println(parts.join(',\n'))
}