Motor de Inferencia ECG — NeuroPulse AI

// NeuroPulse AI — Motor ECG de alto rendimiento
// CULTIVA IA · Ingeniería MLOps · 2026
const std = @import("std");
const ecg = @import("ecg_parser.zig");
const dsp = @import("dsp.zig");
const bio = @import("c_interop.zig");
const Allocator = std.mem.Allocator;

// Config compilada — cero overhead en runtime
const Config = struct {
    const WORKERS: u8    = 8;
    const PORT: u16       = 8080;
    const ARENA_SIZE: u32 = 64 * 1024;  // 64KB por worker
    const HRV_ALERT_MS: f32 = 20.0;     // umbral crítico
};

// Resultado del análisis ECG
const EcgResult = struct {
    hrv_ms:     f32,   // Heart Rate Variability
    rr_ms:      f32,   // RR interval promedio
    qrs_width:  f32,   // Ancho complejo QRS
    bpm:        u16,   // Frecuencia cardíaca
    alert:      bool,  // HRV < umbral crítico
    latency_us: u64,   // Latencia del análisis en µs
};

pub fn main() !void {
    // Allocator global: General Purpose (detección de leaks en debug)
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const gpa_alloc = gpa.allocator();

    // Pool de arenas pre-asignadas — una por worker
    var arenas: [Config.WORKERS]std.heap.ArenaAllocator = undefined;
    for (&arenas) |*a| a.* = std.heap.ArenaAllocator.init(gpa_alloc);
    defer for (&arenas) |*a| a.deinit();

    // Servidor TCP
    var server = try std.net.Server.init(.{
        .address       = try std.net.Address.parseIp("0.0.0.0", Config.PORT),
        .reuse_address = true,
    });
    defer server.deinit();

    std.log.info("NeuroPulse ECG server on :{d} | {d} workers",
        .{ Config.PORT, Config.WORKERS });

    // Thread pool — spawn Config.WORKERS goroutines Zig
    var pool: std.Thread.Pool = undefined;
    try pool.init(.{ .allocator = gpa_alloc, .n_jobs = Config.WORKERS });
    defer pool.deinit();

    while (true) {
        const conn = try server.accept();
        try pool.spawn(handleConn, .{ conn, &arenas[pool.workerIndex()] });
    }
}

// Handler por conexión — usa el arena del worker (sin alloc compartido)
fn handleConn(conn: std.net.Server.Connection, arena: *std.heap.ArenaAllocator) void {
    defer conn.stream.close();
    defer _ = arena.reset(.retain_capacity);  // reutiliza memoria sin free/malloc
    const alloc = arena.allocator();

    var buf: [16384]u8 = undefined;
    var http_srv = std.http.Server.init(conn, &buf);
    var req = http_srv.receiveHead() catch return;

    if (std.mem.eql(u8, req.head.target, "/api/analyze") and
        req.head.method == .POST)
    {
        analyzeEcg(alloc, &req) catch |err| {
            const msg = std.fmt.allocPrint(alloc,
                "{\"error\":\"{s}\"}", .{@errorName(err)}) catch return;
            req.respond(msg, .{ .status = .bad_request }) catch return;
        };
    }
}

fn analyzeEcg(alloc: Allocator, req: *std.http.Server.Request) !void {
    const t0 = std.time.microTimestamp();

    // 1. Leer body (zero-copy: slice del buffer de la arena)
    const body = try req.readAllAlloc(alloc, 64 * 1024);

    // 2. Parsear trama ECG binaria IEDF-247
    const frame = try ecg.parseFrame(body);  // devuelve []i16 slice del body

    // 3. Filtro paso banda DSP (0.5–40 Hz)
    var filtered: [2048]f32 = undefined;
    dsp.bandpass(frame.samples, &filtered, 500, 0.5, 40.0);

    // 4. Extraer features
    const result = EcgResult{
        .hrv_ms    = dsp.computeHrv(&filtered),
        .rr_ms     = dsp.meanRr(&filtered),
        .qrs_width = dsp.qrsWidth(&filtered),
        .bpm       = dsp.heartRate(&filtered, 500),
        .alert     = dsp.computeHrv(&filtered) < Config.HRV_ALERT_MS,
        .latency_us = @intCast(std.time.microTimestamp() - t0),
    };

    // 5. Serializar a JSON — sin alloc extra (fmt en el buffer de la arena)
    const json = try std.fmt.allocPrint(alloc,
        \\{{"hrv_ms":{d:.2},"rr_ms":{d:.2},"qrs_width":{d:.2},
        \\  "bpm":{d},"alert":{s},"latency_us":{d}}},
        .{ result.hrv_ms, result.rr_ms, result.qrs_width,
           result.bpm, if (result.alert) "true" else "false",
           result.latency_us });

    try req.respond(json, .{
        .extra_headers = &.{.{ .name = "content-type", .value = "application/json" }},
    });
}

// build.zig — sistema de build nativo Zig (reemplaza CMake/Make)
const std = @import("std");

pub fn build(b: *std.Build) void {
    // Target: Linux x86_64 (deploy en EC2 c7g)
    const target = b.resolveTargetQuery(.{
        .cpu_arch    = .x86_64,
        .os_tag     = .linux,
        .abi        = .gnu,
        .cpu_model  = .{ .explicit = &std.Target.x86.cpu.skylake },  // AVX2
    });
    const opt = b.standardOptimizeOption(.{ .preferred_optimize_mode = .ReleaseFast });

    const exe = b.addExecutable(.{
        .name           = "neuropulse-ecg",
        .root_source_file = b.path("src/main.zig"),
        .target         = target,
        .optimize       = opt,
    });

    // Linkear libbiosig (C) — sin FFI overhead
    exe.linkSystemLibrary("biosig");
    exe.linkLibC();

    // Opciones de compilación para señales DSP (SIMD automático)
    exe.root_module.addOptions("config", &.{
        .{ .name = "sample_rate",  .value = @as(u32, 500)  },
        .{ .name = "use_avx2",    .value = true           },
    });

    b.installArtifact(exe);

    // Test suite
    const tests = b.addTest(.{
        .root_source_file = b.path("src/dsp_test.zig"),
        .target  = target,
        .optimize = opt,
    });
    const run_tests = b.addRunArtifact(tests);
    b.step("test", "Run DSP unit tests").dependOn(&run_tests.step);
}

// ── DEPLOY (shell script) ────────────────────────────────────────────
// $ zig build -Doptimize=ReleaseFast -Dtarget=x86_64-linux-gnu
// $ scp zig-out/bin/neuropulse-ecg ec2-user@10.0.1.42:/opt/neuropulse/
// $ ssh ec2-user@10.0.1.42 "systemctl restart neuropulse"
// Binary size: 284 KB (stripped) — sin runtime, sin VM, sin intérprete