scoped_logger.v

// Scoped logger for building wide events incrementally
module logger

import x.json2
import time

// new_request_logger creates a new request-scoped logger
// Auto-generates correlation_id if not provided in context
// Usage:
//   mut req_log := logger.new_request_logger({
//     'method': json2.Any('TRADE_EXECUTED')
//     'path': json2.Any('/trading/execute')
//   })
pub fn new_request_logger(initial_context ?map[string]json2.Any) &RequestLogger {
	mut ctx := if ic := initial_context {
		ic.clone()
	} else {
		map[string]json2.Any{}
	}

	// Extract or generate correlation ID
	correlation_id := extract_correlation_from_context(ctx) or { generate_correlation_id() }
	span_id := generate_correlation_id()

	// Set correlation ID in context if not present
	if 'correlation_id' !in ctx {
		ctx['correlation_id'] = json2.Any(correlation_id)
	}

	return &RequestLogger{
		context:        ctx.clone()
		start_time:     time.now()
		request_logs:   []
		field_configs:  global_config.field_configs
		has_error:      false
		has_warn:       false
		correlation_id: correlation_id
		span_id:        span_id
	}
}

// new_child_request_logger creates a child logger with the same correlation ID
// This is useful for tracking related operations (e.g., order placement → execution)
pub fn new_child_request_logger(parent &RequestLogger, child_context ?map[string]json2.Any) &RequestLogger {
	mut ctx := if cc := child_context {
		cc.clone()
	} else {
		map[string]json2.Any{}
	}

	// Inherit correlation ID from parent
	ctx['correlation_id'] = json2.Any(parent.correlation_id)
	ctx['parent_span_id'] = json2.Any(parent.span_id)

	child_span_id := generate_correlation_id()

	return &RequestLogger{
		context:        ctx.clone()
		start_time:     time.now()
		request_logs:   []
		field_configs:  global_config.field_configs
		has_error:      false
		has_warn:       false
		correlation_id: parent.correlation_id
		span_id:        child_span_id
		parent_span_id: parent.span_id
	}
}

// new_request_logger_with_correlation creates a logger with a specific correlation ID
// Useful when continuing a trace from an external source (webhook, message queue, etc.)
pub fn new_request_logger_with_correlation(correlation_id string, initial_context ?map[string]json2.Any) &RequestLogger {
	mut ctx := if ic := initial_context {
		ic.clone()
	} else {
		map[string]json2.Any{}
	}
	ctx['correlation_id'] = json2.Any(correlation_id)
	span_id := generate_correlation_id()

	return &RequestLogger{
		context:        ctx.clone()
		start_time:     time.now()
		request_logs:   []
		field_configs:  global_config.field_configs
		has_error:      false
		has_warn:       false
		correlation_id: correlation_id
		span_id:        span_id
	}
}

// set adds or updates context data by merging with existing context
pub fn (mut r RequestLogger) set(data map[string]json2.Any) {
	r.context = deep_merge(data, r.context)
}

// set_field sets a single field in the context
pub fn (mut r RequestLogger) set_field(key string, value json2.Any) {
	r.context[key] = value
}

// get_correlation_id returns the correlation ID for this request
pub fn (r &RequestLogger) get_correlation_id() string {
	return r.correlation_id
}

// get_span_id returns the span ID for this specific operation
pub fn (r &RequestLogger) get_span_id() string {
	return r.span_id
}

// error logs an error and marks the request as having an error
// The error details are added to the context
pub fn (mut r RequestLogger) error(err IError, error_context ?map[string]json2.Any) {
	r.has_error = true

	mut error_data := if ec := error_context {
		ec.clone()
	} else {
		map[string]json2.Any{}
	}
	mut err_map := map[string]json2.Any{}
	err_map['type'] = json2.Any(err.type_name())
	err_map['message'] = json2.Any(err.msg())
	err_map['code'] = json2.Any(err.code())
	err_map['span_id'] = json2.Any(r.span_id) // Track which span had the error
	error_data['error'] = json2.Any(err_map)

	r.context = deep_merge(error_data, r.context)
}

// error_str logs an error message and marks the request as having an error
pub fn (mut r RequestLogger) error_str(message string, error_context ?map[string]json2.Any) {
	r.has_error = true

	mut error_data := if ec := error_context {
		ec.clone()
	} else {
		map[string]json2.Any{}
	}
	mut err_map := map[string]json2.Any{}
	err_map['type'] = json2.Any('Error')
	err_map['message'] = json2.Any(message)
	err_map['code'] = json2.Any(1)
	err_map['span_id'] = json2.Any(r.span_id)
	error_data['error'] = json2.Any(err_map)

	r.context = deep_merge(error_data, r.context)
}

// info logs an info message and adds it to the request logs
pub fn (mut r RequestLogger) info(message string, info_context ?map[string]json2.Any) {
	// Check if info level is enabled
	if int(LogLevel.info) < int(global_config.level) {
		return
	}

	r.request_logs << LogEntry{
		level:     .info
		message:   message
		timestamp: time.now()
	}

	if ctx := info_context {
		r.context = deep_merge(ctx, r.context)
	}
}

// warn logs a warning message, marks the request as having a warning, and adds it to request logs
pub fn (mut r RequestLogger) warn(message string, warn_context ?map[string]json2.Any) {
	// Check if warn level is enabled
	if int(LogLevel.warn) < int(global_config.level) {
		return
	}

	r.has_warn = true
	r.request_logs << LogEntry{
		level:     .warn
		message:   message
		timestamp: time.now()
	}

	if ctx := warn_context {
		r.context = deep_merge(ctx, r.context)
	}
}

// debug logs a debug message and adds it to the request logs
pub fn (mut r RequestLogger) debug(message string, debug_context ?map[string]json2.Any) {
	// Check if debug level is enabled
	if int(LogLevel.debug) < int(global_config.level) {
		return
	}

	r.request_logs << LogEntry{
		level:     .debug
		message:   message
		timestamp: time.now()
	}

	if ctx := debug_context {
		r.context = deep_merge(ctx, r.context)
	}
}

// emit finalizes the request logger and emits a wide event
// Returns the emitted event or none if logging is disabled
pub fn (mut r RequestLogger) emit(overrides ?map[string]json2.Any) ?WideEvent {
	duration_ms := int(time.since(r.start_time).milliseconds())

	// Determine level based on flags
	level := if r.has_error {
		LogLevel.error
	} else if r.has_warn {
		LogLevel.warn
	} else {
		LogLevel.info
	}

	// Merge overrides
	mut final_context := r.context.clone()
	if over := overrides {
		final_context = deep_merge(over, final_context)
	}

	// Add duration fields
	final_context['duration_ms'] = json2.Any(duration_ms)
	final_context['duration'] = json2.Any(format_duration(duration_ms))

	// Add correlation IDs to context for display
	final_context['correlation_id'] = json2.Any(r.correlation_id)
	final_context['_internal_span_id'] = json2.Any(r.span_id)
	if psid := r.parent_span_id {
		final_context['_internal_parent_span_id'] = json2.Any(psid)
	}

	// Add request logs if any exist
	if r.request_logs.len > 0 {
		mut logs_json := []json2.Any{}
		for entry in r.request_logs {
			logs_json << json2.Any({
				'level':     json2.Any(entry.level.str())
				'message':   json2.Any(entry.message)
				'timestamp': json2.Any(entry.timestamp.format_rfc3339())
			})
		}
		final_context['request_logs'] = json2.Any(logs_json)
	}

	return emit_wide_event(level, final_context)
}

// emit_with_level emits the event with a specific level override
pub fn (mut r RequestLogger) emit_with_level(level LogLevel, overrides ?map[string]json2.Any) ?WideEvent {
	duration_ms := int(time.since(r.start_time).milliseconds())

	// Merge overrides
	mut final_context := r.context.clone()
	if over := overrides {
		final_context = deep_merge(over, final_context)
	}

	// Add duration fields
	final_context['duration_ms'] = json2.Any(duration_ms)
	final_context['duration'] = json2.Any(format_duration(duration_ms))

	// Add correlation IDs
	final_context['correlation_id'] = json2.Any(r.correlation_id)
	final_context['_internal_span_id'] = json2.Any(r.span_id)
	if psid := r.parent_span_id {
		final_context['_internal_parent_span_id'] = json2.Any(psid)
	}

	// Add request logs if any exist
	if r.request_logs.len > 0 {
		mut logs_json := []json2.Any{}
		for entry in r.request_logs {
			logs_json << json2.Any({
				'level':     json2.Any(entry.level.str())
				'message':   json2.Any(entry.message)
				'timestamp': json2.Any(entry.timestamp.format_rfc3339())
			})
		}
		final_context['request_logs'] = json2.Any(logs_json)
	}

	return emit_wide_event(level, final_context)
}

// get_duration returns the duration since the logger was created
pub fn (r &RequestLogger) get_duration() time.Duration {
	return time.since(r.start_time)
}

// get_duration_ms returns the duration in milliseconds
pub fn (r &RequestLogger) get_duration_ms() int {
	return int(time.since(r.start_time).milliseconds())
}

// get_context returns a copy of the current context
pub fn (r &RequestLogger) get_context() map[string]json2.Any {
	return r.context.clone()
}

// has_errors returns true if any errors were logged
pub fn (r &RequestLogger) has_errors() bool {
	return r.has_error
}

// has_warnings returns true if any warnings were logged
pub fn (r &RequestLogger) has_warnings() bool {
	return r.has_warn
}

// get_log_count returns the number of log entries
pub fn (r &RequestLogger) get_log_count() int {
	return r.request_logs.len
}