// log — process logger over a [[io.stream]] sink. Subset of Hare's
// lib/log (ref/hare/log/{logger,funcs,global,silent}.ha).
//
// Surface today:
//
//   log.logger     — vtable with `println` + `printfln` slots
//   log.stdlogger  — first-field embed of logger + a `*io.stream` sink
//   log.new        (sl: *stdlogger, sink: *io.stream) void
//   log.silent     *logger — a logger that discards every record
//   log.default    *logger — a stdlogger writing to stderr
//   log.global     *logger — the dispatch target for [[println]] / [[fatal]]
//   log.println    (args: fmt.formattable...) void
//   log.lprintln   (log: *logger, args: fmt.formattable...) void
//   log.printfln   (format: str, fields: fmt.field...) void
//   log.lprintfln  (log: *logger, format: str, fields: fmt.field...) void
//   log.fatal      (args: fmt.formattable...) never
//   log.lfatal     (log: *logger, args: fmt.formattable...) never
//   log.fatalf     (format: str, fields: fmt.field...) never
//   log.lfatalf    (log: *logger, format: str, fields: fmt.field...) never
//   log.setlogger  (log: *logger) void
//
// Divergences from Hare:
//
//   • Hare returns the stdlogger from `new` by value; ww cgen can't
//     return wide structs, so [[new]] is out-parameter shaped. Same
//     workaround as memio.fixed / bufio.init.
//
//   • Hare initialises silent / default / _default via module-scope
//     struct literal lets. cstage `emit_lets` (cmd/w6c/cgen.c:6176)
//     only constexprs primitive / str-literal / array-literal lets —
//     struct- and pointer-literal init aren't reachable. ww drops to
//     a lazy [[ensureinit]] (lib/temp's `rnginit==0` pattern) called
//     from every exported fn. The public *logger globals are zero
//     initially and become non-nil after the first lib/log call;
//     callers that read globals directly (rather than going through
//     [[println]] / [[lprintln]] / [[setlogger]] / etc.) must call
//     some lib/log fn first so init runs.
//
//   • Param name divergence from Hare: the format-string parameter is
//     `format` (not Hare's `fmt`) because ww's resolver shadows the
//     `fmt` module reference inside a body when a same-name param is
//     in scope (silent miscompile — CALL through str.ptr). Tracked as
//     task #19; rename to `fmt` when fixed.
//
// Sink today is [[io.stream]] only — lib/io has no fd-backed stream
// yet (Hare's `io::handle = file | int` collapses to one variant).
// The default logger writes to stderr via a private io.stream whose
// write callback forwards to [[os.write]] on fd 2.
//
// Compiler note: wwstage cgen's variadic dispatch is name-based
// (`fnparamslookup(callee.str)`), which would conflate the
// `logger.println` vtable field with the top-level [[println]] fn
// if both stages compiled this module. cstage uses type-driven
// dispatch via the call-node's lhs type and handles fn-pointer
// variadic calls correctly. Today lib/log is consumed only by tests
// routed through `ww run` (cstage), so this is a latent issue
// covered by #11 (wwstage checkfile pass).
//
//   let buf: [128]u8;
//   let mem: memio.state;
//   let s:   io.stream;
//   memio.fixed(&mem, &s, buf[0:128]);
//
//   let sl: log.stdlogger;
//   log.new(&sl, &s);
//   log.lprintln(&sl.logger, "hello", 42i64);
//   // mem now holds "hello 42\n"
//
//   log.setlogger(&sl.logger);
//   log.println("through global");
//
//   log.setlogger(log.silent);
//   log.println("dropped");

use fmt;
use io;
use os;

// logger — interface for log dispatch. Two vtable slots: bare-args
// `println` (formattable-variadic) and `printfln` (format-string +
// field-variadic). Mirrors ref/hare/log/logger.ha:9.
export type logger = struct {
	println:  fn(l: *logger, args: fmt.formattable...) void,
	printfln: fn(l: *logger, format: str, fields: fmt.field...) void,
};

// stdlogger — concrete logger forwarding to a `*io.stream` sink.
// First-field embed: `&sl.logger` yields a `*logger` (same shape as
// bufio.stream over its embedded io.stream vtable). The vtable
// callback recovers the outer stdlogger by casting the dispatch arg
// back to `*stdlogger`.
export type stdlogger = struct {
	logger: logger,
	sink:   *io.stream,
};

// stderrsink — private io.stream wired through fd 2 via [[os.write]].
// Used as [[default]]'s sink. Independent of lib/io's future fd-backed
// stream — when that lands, this collapses to a thin wrapper and
// graduates in one go.
let stderrsink: io.stream;

// _silent — backing storage for the [[silent]] global.
let _silent: logger;

// _default — backing storage for the [[default]] global. Its sink
// points at [[stderrsink]] after [[ensureinit]] runs.
let _default: stdlogger;

// silent / default / global — Hare-style *logger globals. Zero-init
// at link time; lazily wired by [[ensureinit]] on the first call to
// any exported fn. See the file header for the divergence rationale.
export let silent:  *logger;
export let default: *logger;
export let global:  *logger;

// initdone — guards [[ensureinit]] so the one-shot wiring runs once.
// Mirrors lib/temp's `rnginit` pattern.
let initdone: i32 = 0;

fn ensureinit() void = {
	if (initdone != 0) { return; };
	stderrsink.ctx   = nil;
	stderrsink.read  = stderrread;
	stderrsink.write = stderrwrite;
	stderrsink.close = stderrclose;

	_silent.println  = silentprintln;
	_silent.printfln = silentprintfln;

	_default.logger.println  = stdprintln;
	_default.logger.printfln = stdprintfln;
	_default.sink = &stderrsink;

	silent  = &_silent;
	default = &_default.logger;
	global  = default;
	initdone = 1;
};

// stderrread / stderrwrite / stderrclose — io.stream callbacks for
// the private stderr sink. Read is a no-op returning io.eof; close
// is a no-op (the process owns fd 2). Write forwards to write(2)
// and translates a negative-errno into io.closed.
fn stderrread(s: *io.stream, buf: []u8) (i32 | io.eof | io.closed) = {
	let e: io.eof;
	return e;
};

fn stderrwrite(s: *io.stream, buf: []u8) (i32 | io.closed) = {
	let r: i64 = os.write(2, buf.ptr, buf.len: u64);
	if (r < 0) {
		let e: io.closed;
		return e;
	};
	return r: i32;
};

fn stderrclose(s: *io.stream) (void | io.closed) = { return; };

// stdprintln — vtable callback for stdlogger. Forwards to
// [[fmt.fprintln]] on the sink; the (i32 | io.closed) result is
// dropped — lib/log's surface is `void` (matches Hare).
fn stdprintln(l: *logger, args: fmt.formattable...) void = {
	let sl: *stdlogger = l: *stdlogger;
	fmt.fprintln(sl.sink, args...);
};

// stdprintfln — vtable callback for stdlogger's format-string slot.
// Mirrors ref/hare/log/logger.ha:38 log_printfln. `format` (not
// Hare's `fmt`) per the param-name divergence noted in the header.
fn stdprintfln(l: *logger, format: str, fields: fmt.field...) void = {
	let sl: *stdlogger = l: *stdlogger;
	fmt.fprintfln(sl.sink, format, fields...);
};

// silentprintln — vtable callback for the silent logger. Discards
// every record without dispatching through fmt; keeps silent truly
// silent if fmt ever gets stateful.
fn silentprintln(l: *logger, args: fmt.formattable...) void = { };

// silentprintfln — format-string sibling of [[silentprintln]].
// Mirrors ref/hare/log/silent.ha:15.
fn silentprintfln(l: *logger, format: str, fields: fmt.field...) void = { };

// new — wire `sl` as a stdlogger over `sink`. Hare returns by value
// (ref/hare/log/logger.ha:20); ww cgen can't return wide structs,
// so we take an out-parameter pointer (same shape as memio.fixed,
// bufio.init).
export fn new(sl: *stdlogger, sink: *io.stream) void = {
	ensureinit();
	sl.logger.println  = stdprintln;
	sl.logger.printfln = stdprintfln;
	sl.sink = sink;
};

// lprintln — dispatch `args` through `log`. Hare's lib/log/funcs.ha
// counterpart at line 8.
export fn lprintln(log: *logger, args: fmt.formattable...) void = {
	ensureinit();
	log.println(log, args...);
};

// println — dispatch through the [[global]] logger.
export fn println(args: fmt.formattable...) void = {
	ensureinit();
	lprintln(global, args...);
};

// lfatal — lprintln to `log` then exit(255). `never` return marks
// the bottom type so flow-control checks treat callers as terminated.
// Hare's lib/log/funcs.ha counterpart at line 28.
export fn lfatal(log: *logger, args: fmt.formattable...) never = {
	lprintln(log, args...);
	os.exit(255);
};

// fatal — lprintln to [[global]] then exit(255). Hare's lib/log/
// funcs.ha counterpart at line 45.
export fn fatal(args: fmt.formattable...) never = {
	println(args...);
	os.exit(255);
};

// setlogger — install `log` as the [[global]] logger. Hare's
// lib/log/global.ha counterpart at line 20.
export fn setlogger(log: *logger) void = {
	ensureinit();
	global = log;
};

// lprintfln — dispatch a format-string record through `log`. Hare's
// lib/log/funcs.ha counterpart at line 13.
export fn lprintfln(log: *logger, format: str, fields: fmt.field...) void = {
	ensureinit();
	log.printfln(log, format, fields...);
};

// printfln — dispatch through the [[global]] logger. Hare's
// lib/log/funcs.ha counterpart at line 23.
export fn printfln(format: str, fields: fmt.field...) void = {
	ensureinit();
	lprintfln(global, format, fields...);
};

// lfatalf — lprintfln to `log` then exit(255). Hare's
// lib/log/funcs.ha counterpart at line 35.
export fn lfatalf(log: *logger, format: str, fields: fmt.field...) never = {
	lprintfln(log, format, fields...);
	os.exit(255);
};

// fatalf — lprintfln to [[global]] then exit(255). Hare's
// lib/log/funcs.ha counterpart at line 52.
export fn fatalf(format: str, fields: fmt.field...) never = {
	printfln(format, fields...);
	os.exit(255);
};