//! ente-journald-compat: stub que absorbe escrituras al journal socket.
//!
//! Listen en `/run/systemd/journal/socket` (datagram) — todo lo que llega
//! se decodifica best-effort y se emite como tracing event.
//!
//! Sin esto, apps que usan `sd_journal_send` o syslog fallan al escribir.
//! Para una implementación real: persistir a CAS por timestamp+sha,
//! exponer query API, indexar por unidad/usuario.

use ente_bus::{BusClient, BusRequest, BusResponse};
use ente_card::Capability;
use std::os::fd::{AsRawFd, OwnedFd};
use std::path::Path;
use tokio::io::unix::AsyncFd;
use tokio::signal::unix::{signal, SignalKind};
use tracing::{debug, info, warn};
use tracing_subscriber::EnvFilter;

const JOURNAL_SOCKET: &str = "/run/systemd/journal/socket";
const DEV_LOG: &str = "/dev/log";

#[tokio::main(flavor = "current_thread")]
async fn main() -> anyhow::Result<()> {
    init_tracing();
    info!("ente-journald-compat: arrancando");
    announce_to_fractal().await;

    // Intentamos vincular ambos sockets. Cada uno puede fallar
    // independientemente; si alguno funciona, seguimos.
    let mut bound = 0usize;
    if let Some(stream) = bind_dgram(JOURNAL_SOCKET) {
        bound += 1;
        spawn_listener(stream, "journal");
    } else {
        warn!(path = JOURNAL_SOCKET, "no se pudo bind — necesita CAP_NET_BIND_SERVICE o /run writable");
    }
    if let Some(stream) = bind_dgram(DEV_LOG) {
        bound += 1;
        spawn_listener(stream, "syslog");
    } else {
        warn!(path = DEV_LOG, "no se pudo bind /dev/log");
    }

    if bound == 0 {
        warn!("ningún socket bound — modo idle");
    } else {
        info!(sockets_bound = bound, "journald-compat listening");
    }

    wait_for_term().await
}

fn bind_dgram(path: &str) -> Option<AsyncFd<OwnedFdWrap>> {
    use nix::sys::socket::{bind, socket, AddressFamily, SockFlag, SockType, UnixAddr};
    let _ = std::fs::remove_file(path);
    if let Some(parent) = Path::new(path).parent() {
        let _ = std::fs::create_dir_all(parent);
    }
    let fd = match socket(
        AddressFamily::Unix,
        SockType::Datagram,
        SockFlag::SOCK_NONBLOCK | SockFlag::SOCK_CLOEXEC,
        None,
    ) {
        Ok(f) => f,
        Err(e) => { warn!(?e, "socket() falló"); return None; }
    };
    let addr = match UnixAddr::new(path) {
        Ok(a) => a,
        Err(e) => { warn!(?e, "UnixAddr falló"); return None; }
    };
    if let Err(e) = bind(fd.as_raw_fd(), &addr) {
        warn!(?e, %path, "bind falló");
        return None;
    }
    AsyncFd::new(OwnedFdWrap(fd)).ok()
}

struct OwnedFdWrap(OwnedFd);
impl AsRawFd for OwnedFdWrap {
    fn as_raw_fd(&self) -> std::os::fd::RawFd { self.0.as_raw_fd() }
}

fn spawn_listener(async_fd: AsyncFd<OwnedFdWrap>, source: &'static str) {
    tokio::spawn(async move {
        let mut buf = vec![0u8; 64 * 1024];
        loop {
            let mut guard = match async_fd.readable().await {
                Ok(g) => g,
                Err(e) => { warn!(?e, source, "readable failed"); return; }
            };
            let raw_fd = guard.get_inner().as_raw_fd();
            loop {
                let n = unsafe {
                    libc::recv(raw_fd, buf.as_mut_ptr() as *mut _, buf.len(), 0)
                };
                if n <= 0 { break; }
                handle_message(&buf[..n as usize], source);
            }
            guard.clear_ready();
        }
    });
}

/// Decodifica best-effort. Formato journald nativo: lines de "KEY=value"
/// (binario para values con newlines, pero raro). Formato syslog: texto
/// con prefijo "<priority>tag: message".
fn handle_message(buf: &[u8], source: &'static str) {
    if let Ok(s) = std::str::from_utf8(buf) {
        // Heurística: si tiene '=' en alguna línea, asumir journald.
        if s.contains('=') && s.lines().any(|l| l.contains('=')) {
            let mut message = None;
            let mut priority = None;
            let mut unit = None;
            for line in s.lines() {
                if let Some((k, v)) = line.split_once('=') {
                    match k {
                        "MESSAGE" => message = Some(v.to_string()),
                        "PRIORITY" => priority = Some(v.to_string()),
                        "_SYSTEMD_UNIT" | "UNIT" => unit = Some(v.to_string()),
                        _ => {}
                    }
                }
            }
            if let Some(msg) = message {
                info!(target: "journal", source, ?priority, ?unit, "{msg}");
            } else {
                debug!(source, len = buf.len(), "journal native sin MESSAGE");
            }
        } else {
            // Syslog
            info!(target: "syslog", source, "{}", s.trim_end());
        }
    } else {
        debug!(source, len = buf.len(), "journal binario (no UTF-8)");
    }
}

async fn announce_to_fractal() {
    if let Ok(mut client) = BusClient::from_env().await {
        let req = BusRequest::Announce {
            capabilities: vec![Capability::Journal],
        };
        match client.call(req).await {
            Ok(BusResponse::Ok) => info!("Announce → bus interno OK"),
            Ok(other) => warn!(?other, "Announce respuesta inesperada"),
            Err(e) => warn!(?e, "Announce falló"),
        }
    }
}

async fn wait_for_term() -> anyhow::Result<()> {
    let mut term = signal(SignalKind::terminate())?;
    let mut int_ = signal(SignalKind::interrupt())?;
    tokio::select! {
        _ = term.recv() => info!("SIGTERM"),
        _ = int_.recv() => info!("SIGINT"),
    }
    Ok(())
}

fn init_tracing() {
    let filter = EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| EnvFilter::new("ente_journald_compat=info,journal=info,syslog=info"));
    tracing_subscriber::fmt().with_env_filter(filter).with_target(true).init();
}