/*
 * resolve.c - feature resolution + `when` guards (todo 14).
 *
 * Pure code generator: it PARSES the `when` guard grammar into an AST and
 * EMITS POSIX-sh that evaluates guards and aggregates feature results at
 * CONFIGURE time. It never runs a probe and never evaluates a guard
 * itself. See resolve.h for the guard grammar, the os-mapping table, the
 * $st_os contract, the emitted guard shape, and the feature-aggregation
 * contract that todo 16 consumes.
 *
 * Safety decisions:
 *   - Guard leaves emit `[ "$have_<ident>" = "yes" ]` and
 *     `[ "$st_os" = '<name>' ]`; the ident is validated as a POSIX shell
 *     identifier (it lands in a variable-NAME position and cannot be
 *     quoted), the os name is validated against the same charset AND
 *     single-quoted on emission (belt and braces).
 *   - Binary nodes re-parenthesize with `( ... )` because POSIX sh gives
 *     `&&`/`||` equal left-associative precedence, unlike the guard
 *     grammar's or-over-and hierarchy.
 *   - The os table is a single source of truth: st_os_normalize (C) and
 *     st_resolve_emit_os_norm (shell) both derive from os_map[].
 *
 * Copyright (c) 2026 huntedbytheirs
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include "detect/resolve.h"

#include "error.h"
#include "gen/sh_emit.h"

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* ---- the os mapping table (single source of truth) -------------------- */

struct st_os_entry {
    const char *uname_s; /* raw `uname -s` output */
    const char *norm;    /* canonical name for os= guards */
};

static const struct st_os_entry os_map[] = {
    { "Linux", "linux" },
    { "Darwin", "macos" },
    { "FreeBSD", "bsd" },
    { "OpenBSD", "bsd" },
    { "NetBSD", "bsd" },
};

#define OS_MAP_COUNT (sizeof(os_map) / sizeof(os_map[0]))

const char *
st_os_normalize(const char *uname_s)
{
    size_t i;

    if (uname_s == NULL) {
        return "other";
    }
    for (i = 0; i < OS_MAP_COUNT; i++) {
        if (strcmp(uname_s, os_map[i].uname_s) == 0) {
            return os_map[i].norm;
        }
    }
    return "other";
}

/* ---- identifiers ------------------------------------------------------ */

static bool
valid_ident(const char *s)
{
    const unsigned char *p;

    if (s == NULL || *s == '\0') {
        return false;
    }
    p = (const unsigned char *)s;
    if (!((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') ||
          *p == '_')) {
        return false;
    }
    for (p++; *p != '\0'; p++) {
        if (!((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') ||
              (*p >= '0' && *p <= '9') || *p == '_')) {
            return false;
        }
    }
    return true;
}

/* Length-bounded identifier check (word slices are not NUL-terminated). */
static bool
valid_ident_n(const char *s, size_t n)
{
    size_t i;

    if (s == NULL || n == 0) {
        return false;
    }
    if (!((s[0] >= 'a' && s[0] <= 'z') || (s[0] >= 'A' && s[0] <= 'Z') ||
          s[0] == '_')) {
        return false;
    }
    for (i = 1; i < n; i++) {
        if (!((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') ||
              (s[i] >= '0' && s[i] <= '9') || s[i] == '_')) {
            return false;
        }
    }
    return true;
}

/* ---- owned errors (same-block span, the parser.c pattern) ------------- */

static struct st_error *
err_at_owned(struct st_span sp, const char *msg)
{
    const size_t align = _Alignof(struct st_span);
    const size_t esize =
        (sizeof(struct st_error) + align - 1) & ~(align - 1);
    struct st_error *e;
    struct st_span *spc;
    size_t mlen;

    if (msg == NULL) {
        msg = "";
    }
    e = malloc(esize + sizeof(struct st_span));
    if (e == NULL) {
        return NULL;
    }
    mlen = strlen(msg);
    e->message = malloc(mlen + 1);
    if (e->message == NULL) {
        free(e);
        return NULL;
    }
    memcpy(e->message, msg, mlen + 1);
    e->category = ST_ERR_KDL_SCHEMA;
    spc = (struct st_span *)((unsigned char *)e + esize);
    *spc = sp;
    e->span = spc;
    return e;
}

/* ---- the guard AST ---------------------------------------------------- */

enum st_when_kind {
    ST_WHEN_HAVE = 0, /* have_<ident>: $have_<ident> = "yes" */
    ST_WHEN_OS,       /* os=<name>: $st_os = '<name>'          */
    ST_WHEN_NOT,      /* ! <left>                              */
    ST_WHEN_AND,      /* <left> && <right>                     */
    ST_WHEN_OR,       /* <left> || <right>                     */
};

struct st_when_ast {
    enum st_when_kind kind;
    char *text;                /* HAVE: ident; OS: name; else NULL */
    struct st_when_ast *left;  /* NOT operand; AND/OR left */
    struct st_when_ast *right; /* AND/OR right */
};

static char *
dup_n(const char *s, size_t n)
{
    char *p = malloc(n + 1);

    if (p == NULL) {
        return NULL;
    }
    memcpy(p, s, n);
    p[n] = '\0';
    return p;
}

static struct st_when_ast *
leaf(enum st_when_kind kind, const char *text, size_t len)
{
    struct st_when_ast *a = calloc(1, sizeof(*a));

    if (a == NULL) {
        return NULL;
    }
    a->kind = kind;
    if (text != NULL) {
        a->text = dup_n(text, len);
        if (a->text == NULL) {
            free(a);
            return NULL;
        }
    }
    return a;
}

void
st_when_free(struct st_when_ast *a)
{
    if (a == NULL) {
        return;
    }
    st_when_free(a->left);
    st_when_free(a->right);
    free(a->text);
    free(a);
}

/* ---- the guard lexer -------------------------------------------------- */

enum gtok_kind {
    GTOK_EOF = 0,
    GTOK_HAVE,       /* text = ident (slice) */
    GTOK_OS,         /* text = name (slice)  */
    GTOK_AND,
    GTOK_OR,
    GTOK_NOT,
    GTOK_LPAREN,
    GTOK_RPAREN,
    GTOK_UNKNOWN,    /* word that is none of the above */
    GTOK_HAVE_EMPTY, /* word == "have_" */
    GTOK_HAVE_BAD,   /* have_ + invalid ident */
    GTOK_OS_EMPTY,   /* word == "os=" */
    GTOK_OS_BAD,     /* os= + invalid name */
};

struct gtok {
    enum gtok_kind kind;
    size_t off;       /* byte offset of the token start in the guard */
    const char *text; /* slice into the guard (word, or ident/name) */
    size_t len;
};

struct glex {
    const char *s;
    size_t len;
    size_t pos;
    struct gtok cur;
};

static bool
is_space(unsigned char c)
{
    return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\v' ||
           c == '\f';
}

/* Classify a word slice (not NUL-terminated). For HAVE/OS success the
 * text/len are narrowed to the ident/name; for error kinds they stay the
 * whole word so the parser can echo it. */
static void
classify_word(struct gtok *t, const char *w, size_t wlen, size_t off)
{
    t->off = off;
    t->text = w;
    t->len = wlen;

    if (wlen == 3 && memcmp(w, "and", 3) == 0) {
        t->kind = GTOK_AND;
    } else if (wlen == 2 && memcmp(w, "or", 2) == 0) {
        t->kind = GTOK_OR;
    } else if (wlen == 3 && memcmp(w, "not", 3) == 0) {
        t->kind = GTOK_NOT;
    } else if (wlen >= 5 && memcmp(w, "have_", 5) == 0) {
        if (wlen == 5) {
            t->kind = GTOK_HAVE_EMPTY;
        } else if (!valid_ident_n(w + 5, wlen - 5)) {
            t->kind = GTOK_HAVE_BAD;
        } else {
            t->kind = GTOK_HAVE;
            t->text = w + 5;
            t->len = wlen - 5;
        }
    } else if (wlen >= 3 && memcmp(w, "os=", 3) == 0) {
        if (wlen == 3) {
            t->kind = GTOK_OS_EMPTY;
        } else if (!valid_ident_n(w + 3, wlen - 3)) {
            t->kind = GTOK_OS_BAD;
        } else {
            t->kind = GTOK_OS;
            t->text = w + 3;
            t->len = wlen - 3;
        }
    } else {
        t->kind = GTOK_UNKNOWN;
    }
}

static void
next_tok(struct glex *lx)
{
    const char *s = lx->s;
    size_t n = lx->len;
    size_t i = lx->pos;
    size_t start;

    while (i < n && is_space((unsigned char)s[i])) {
        i++;
    }
    lx->pos = i;
    lx->cur.text = NULL;
    lx->cur.len = 0;
    lx->cur.kind = GTOK_EOF;

    if (i >= n) {
        lx->cur.off = n;
        return;
    }
    if (s[i] == '(') {
        lx->cur.kind = GTOK_LPAREN;
        lx->cur.off = i;
        lx->cur.text = s + i;
        lx->cur.len = 1;
        lx->pos = i + 1;
        return;
    }
    if (s[i] == ')') {
        lx->cur.kind = GTOK_RPAREN;
        lx->cur.off = i;
        lx->cur.text = s + i;
        lx->cur.len = 1;
        lx->pos = i + 1;
        return;
    }

    start = i;
    while (i < n && !is_space((unsigned char)s[i]) && s[i] != '(' &&
           s[i] != ')') {
        i++;
    }
    lx->pos = i;
    classify_word(&lx->cur, s + start, i - start, start);
}

/* ---- the guard parser ------------------------------------------------- */

struct parse_ctx {
    struct glex lx;
    const struct st_span *base; /* NULL -> offset span into the guard */
};

/* 1-based line/col of byte offset `off` within `s`. */
static struct st_span
off_span(const char *s, size_t off)
{
    struct st_span sp = { NULL, 1, 1 };
    size_t i;

    for (i = 0; i < off && s[i] != '\0'; i++) {
        if (s[i] == '\n') {
            sp.line++;
            sp.col = 1;
        } else {
            sp.col++;
        }
    }
    return sp;
}

static struct st_error *
parse_error(const struct parse_ctx *pc, size_t off, const char *msg)
{
    struct st_span sp;

    if (pc->base != NULL) {
        sp = *pc->base;
    } else {
        sp = off_span(pc->lx.s, off);
    }
    return err_at_owned(sp, msg);
}

/* Copy the current token's word into `buf` for message text. */
static const char *
word_into(const struct gtok *t, char *buf, size_t cap)
{
    size_t n = t->len < cap - 1 ? t->len : cap - 1;

    if (t->text == NULL) {
        n = 0;
    }
    if (n > 0) {
        memcpy(buf, t->text, n);
    }
    buf[n] = '\0';
    return buf;
}

static struct st_error *
unexpected(struct parse_ctx *pc)
{
    const struct gtok *t = &pc->lx.cur;
    char w[65];
    char msg[160];

    switch (t->kind) {
    case GTOK_UNKNOWN:
        snprintf(msg, sizeof msg, "unknown token '%s' in when guard",
                 word_into(t, w, sizeof w));
        break;
    case GTOK_HAVE_EMPTY:
        snprintf(msg, sizeof msg,
                 "missing feature name after 'have_' in when guard");
        break;
    case GTOK_HAVE_BAD:
        snprintf(msg, sizeof msg,
                 "invalid feature name '%s' after 'have_' in when guard",
                 word_into(t, w, sizeof w));
        break;
    case GTOK_OS_EMPTY:
        snprintf(msg, sizeof msg, "missing os name after 'os=' in when "
                 "guard");
        break;
    case GTOK_OS_BAD:
        snprintf(msg, sizeof msg,
                 "invalid os name '%s' after 'os=' in when guard",
                 word_into(t, w, sizeof w));
        break;
    case GTOK_EOF:
        snprintf(msg, sizeof msg, "unexpected end of when guard expression");
        break;
    default:
        snprintf(msg, sizeof msg, "unexpected token '%s' in when guard",
                 word_into(t, w, sizeof w));
        break;
    }
    return parse_error(pc, t->off, msg);
}

static struct st_error *
parse_or(struct parse_ctx *pc, struct st_when_ast **out);

static struct st_error *
parse_primary(struct parse_ctx *pc, struct st_when_ast **out)
{
    const struct gtok *t = &pc->lx.cur;

    *out = NULL;
    switch (t->kind) {
    case GTOK_LPAREN: {
        struct st_when_ast *inner = NULL;
        struct st_error *e;

        next_tok(&pc->lx);
        e = parse_or(pc, &inner);
        if (e != NULL) {
            return e;
        }
        if (pc->lx.cur.kind != GTOK_RPAREN) {
            struct st_error *e2 = parse_error(pc, pc->lx.cur.off,
                                              "expected ')' in when guard");

            st_when_free(inner);
            return e2;
        }
        next_tok(&pc->lx);
        *out = inner;
        return NULL;
    }
    case GTOK_HAVE: {
        struct st_when_ast *a = leaf(ST_WHEN_HAVE, t->text, t->len);

        if (a == NULL) {
            return st_error_internal("out of memory parsing when guard");
        }
        next_tok(&pc->lx);
        *out = a;
        return NULL;
    }
    case GTOK_OS: {
        struct st_when_ast *a = leaf(ST_WHEN_OS, t->text, t->len);

        if (a == NULL) {
            return st_error_internal("out of memory parsing when guard");
        }
        next_tok(&pc->lx);
        *out = a;
        return NULL;
    }
    default:
        return unexpected(pc);
    }
}

static struct st_error *
parse_not(struct parse_ctx *pc, struct st_when_ast **out)
{
    if (pc->lx.cur.kind == GTOK_NOT) {
        struct st_when_ast *inner = NULL;
        struct st_when_ast *a;
        struct st_error *e;

        next_tok(&pc->lx);
        e = parse_not(pc, &inner);
        if (e != NULL) {
            return e;
        }
        a = calloc(1, sizeof(*a));
        if (a == NULL) {
            st_when_free(inner);
            return st_error_internal("out of memory parsing when guard");
        }
        a->kind = ST_WHEN_NOT;
        a->left = inner;
        *out = a;
        return NULL;
    }
    return parse_primary(pc, out);
}

static struct st_error *
parse_and(struct parse_ctx *pc, struct st_when_ast **out)
{
    struct st_when_ast *lhs = NULL;
    struct st_error *e;

    e = parse_not(pc, &lhs);
    if (e != NULL) {
        return e;
    }
    while (pc->lx.cur.kind == GTOK_AND) {
        struct st_when_ast *rhs = NULL;
        struct st_when_ast *join;

        next_tok(&pc->lx);
        e = parse_not(pc, &rhs);
        if (e != NULL) {
            st_when_free(lhs);
            return e;
        }
        join = calloc(1, sizeof(*join));
        if (join == NULL) {
            st_when_free(lhs);
            st_when_free(rhs);
            return st_error_internal("out of memory parsing when guard");
        }
        join->kind = ST_WHEN_AND;
        join->left = lhs;
        join->right = rhs;
        lhs = join;
    }
    *out = lhs;
    return NULL;
}

static struct st_error *
parse_or(struct parse_ctx *pc, struct st_when_ast **out)
{
    struct st_when_ast *lhs = NULL;
    struct st_error *e;

    e = parse_and(pc, &lhs);
    if (e != NULL) {
        return e;
    }
    while (pc->lx.cur.kind == GTOK_OR) {
        struct st_when_ast *rhs = NULL;
        struct st_when_ast *join;

        next_tok(&pc->lx);
        e = parse_and(pc, &rhs);
        if (e != NULL) {
            st_when_free(lhs);
            return e;
        }
        join = calloc(1, sizeof(*join));
        if (join == NULL) {
            st_when_free(lhs);
            st_when_free(rhs);
            return st_error_internal("out of memory parsing when guard");
        }
        join->kind = ST_WHEN_OR;
        join->left = lhs;
        join->right = rhs;
        lhs = join;
    }
    *out = lhs;
    return NULL;
}

struct st_error *
st_when_parse_at(const char *guard, const struct st_span *at,
                 struct st_when_ast **out)
{
    struct parse_ctx pc;
    struct st_when_ast *ast = NULL;
    struct st_error *e;

    if (out == NULL) {
        return st_error_usage("st_when_parse: NULL out");
    }
    *out = NULL;
    if (guard == NULL || guard[0] == '\0') {
        return NULL; /* absent guard = always true */
    }

    pc.lx.s = guard;
    pc.lx.len = strlen(guard);
    pc.lx.pos = 0;
    pc.base = at;
    next_tok(&pc.lx);

    e = parse_or(&pc, &ast);
    if (e != NULL) {
        st_when_free(ast);
        return e;
    }
    if (pc.lx.cur.kind != GTOK_EOF) {
        e = unexpected(&pc);
        st_when_free(ast);
        return e;
    }
    *out = ast;
    return NULL;
}

struct st_error *
st_when_parse(const char *guard, struct st_when_ast **out)
{
    return st_when_parse_at(guard, NULL, out);
}

/* ---- guard emission --------------------------------------------------- */

static struct st_error *
emit_node(FILE *out, const struct st_when_ast *n)
{
    switch (n->kind) {
    case ST_WHEN_HAVE:
        if (fprintf(out, "[ \"$have_%s\" = \"yes\" ]", n->text) < 0) {
            return st_error_io("I/O error emitting when guard");
        }
        break;
    case ST_WHEN_OS: {
        char *q = st_sh_quote(n->text);
        int rc;

        if (q == NULL) {
            return st_error_internal("out of memory quoting os name");
        }
        rc = fprintf(out, "[ \"$st_os\" = %s ]", q);
        free(q);
        if (rc < 0) {
            return st_error_io("I/O error emitting when guard");
        }
        break;
    }
    case ST_WHEN_NOT: {
        struct st_error *e;

        if (fputs("! ( ", out) == EOF) {
            return st_error_io("I/O error emitting when guard");
        }
        e = emit_node(out, n->left);
        if (e != NULL) {
            return e;
        }
        if (fputs(" )", out) == EOF) {
            return st_error_io("I/O error emitting when guard");
        }
        break;
    }
    case ST_WHEN_AND:
    case ST_WHEN_OR: {
        const char *op = (n->kind == ST_WHEN_AND) ? "&&" : "||";
        struct st_error *e;

        if (fputs("( ", out) == EOF) {
            return st_error_io("I/O error emitting when guard");
        }
        e = emit_node(out, n->left);
        if (e != NULL) {
            return e;
        }
        if (fprintf(out, " ) %s ( ", op) < 0) {
            return st_error_io("I/O error emitting when guard");
        }
        e = emit_node(out, n->right);
        if (e != NULL) {
            return e;
        }
        if (fputs(" )", out) == EOF) {
            return st_error_io("I/O error emitting when guard");
        }
        break;
    }
    default:
        return st_error_internal("st_when_emit: corrupted guard AST");
    }
    return NULL;
}

struct st_error *
st_when_emit(FILE *out, const struct st_when_ast *ast)
{
    if (out == NULL) {
        return st_error_usage("st_when_emit: NULL stream");
    }
    if (ast == NULL) {
        /* absent guard = always true; `:` is the no-op command */
        if (fputs(":", out) == EOF) {
            return st_error_io("I/O error emitting when guard");
        }
        return NULL;
    }
    return emit_node(out, ast);
}

/* ---- os normalization boilerplate ------------------------------------- */

struct st_error *
st_resolve_emit_os_norm(FILE *out)
{
    size_t i;

    if (out == NULL) {
        return st_error_usage("st_resolve_emit_os_norm: NULL stream");
    }
    if (fputs(
            "# st_os holds the raw `uname -s` output (set by the configure\n"
            "# preamble). st_os_norm rewrites it IN PLACE to the canonical\n"
            "# name that `os=<name>` guards compare against.\n"
            "st_os_norm() {\n"
            "    case \"$st_os\" in\n",
            out) == EOF) {
        return st_error_io("I/O error emitting st_os_norm");
    }
    for (i = 0; i < OS_MAP_COUNT; i++) {
        char *pat = st_sh_quote(os_map[i].uname_s);
        char *val = st_sh_quote(os_map[i].norm);
        int rc;

        if (pat == NULL || val == NULL) {
            free(pat);
            free(val);
            return st_error_internal("out of memory emitting st_os_norm");
        }
        rc = fprintf(out, "        %s) st_os=%s ;;\n", pat, val);
        free(pat);
        free(val);
        if (rc < 0) {
            return st_error_io("I/O error emitting st_os_norm");
        }
    }
    if (fputs("        *) st_os='other' ;;\n"
              "    esac\n"
              "}\n",
              out) == EOF) {
        return st_error_io("I/O error emitting st_os_norm");
    }
    if (ferror(out)) {
        return st_error_io("I/O error emitting st_os_norm");
    }
    return NULL;
}

/* ---- feature aggregation ---------------------------------------------- */

int
st_resolve_check_name(const char *name, size_t index, size_t count,
                      char *out, size_t out_cap)
{
    int rc;

    if (name == NULL || out == NULL || out_cap == 0) {
        return -1;
    }
    if (!valid_ident(name)) {
        return -1;
    }
    if (count == 0 || index >= count) {
        return -1;
    }
    if (count == 1) {
        rc = snprintf(out, out_cap, "%s", name);
    } else {
        rc = snprintf(out, out_cap, "%s_%zu", name, index);
    }
    if (rc < 0 || (size_t)rc >= out_cap) {
        return -1;
    }
    return 0;
}

struct st_error *
st_resolve_emit_feature(FILE *out, const struct st_resolve_feature *f)
{
    bool direct;
    size_t i;
    struct st_error *e;

    if (out == NULL || f == NULL) {
        return st_error_usage("st_resolve_emit_feature: NULL argument");
    }
    if (!valid_ident(f->name)) {
        return st_error_usage("st_resolve_emit_feature: feature name must "
                              "be a POSIX shell identifier");
    }
    if (f->check_count == 0) {
        return st_error_usage("st_resolve_emit_feature: feature has no "
                              "checks");
    }
    if (f->check_names == NULL) {
        return st_error_usage("st_resolve_emit_feature: NULL check_names");
    }
    for (i = 0; i < f->check_count; i++) {
        if (!valid_ident(f->check_names[i])) {
            return st_error_usage("st_resolve_emit_feature: check name "
                                  "must be a POSIX shell identifier");
        }
    }

    if (fprintf(out, "# feature '%s'\n", f->name) < 0) {
        return st_error_io("I/O error emitting feature resolution");
    }

    /* The single check whose name IS the feature name was already set to
     * have_<name> by todo 12's snippet — nothing to aggregate. */
    direct = (f->check_count == 1 &&
              strcmp(f->check_names[0], f->name) == 0);

    if (!direct) {
        if (f->check_count == 1) {
            if (fprintf(out, "have_%s=$have_%s\n", f->name,
                        f->check_names[0]) < 0) {
                return st_error_io("I/O error emitting feature resolution");
            }
        } else {
            if (fputs("if ", out) == EOF) {
                return st_error_io("I/O error emitting feature resolution");
            }
            for (i = 0; i < f->check_count; i++) {
                if (i > 0 && fputs(" && ", out) == EOF) {
                    return st_error_io("I/O error emitting feature "
                                       "resolution");
                }
                if (fprintf(out, "[ \"$have_%s\" = \"yes\" ]",
                            f->check_names[i]) < 0) {
                    return st_error_io("I/O error emitting feature "
                                       "resolution");
                }
            }
            if (fprintf(out, "; then\n    have_%s=yes\nelse\n    "
                        "have_%s=no\nfi\n", f->name, f->name) < 0) {
                return st_error_io("I/O error emitting feature resolution");
            }
        }
    }

    if (f->guard != NULL) {
        if (fputs("if ", out) == EOF) {
            return st_error_io("I/O error emitting feature resolution");
        }
        e = st_when_emit(out, f->guard);
        if (e != NULL) {
            return e;
        }
        if (fprintf(out, "; then\n    :\nelse\n    have_%s=no\nfi\n",
                    f->name) < 0) {
            return st_error_io("I/O error emitting feature resolution");
        }
    }

    if (ferror(out)) {
        return st_error_io("I/O error emitting feature resolution");
    }
    return NULL;
}