import "../../runtime/eltest.el"
// test_transduce.el — transduction produces a SUBGRAPH, not a point.
//
// WHAT IS ACTUALLY UNDER TEST. #144 moved transduction into the language and
// got the dispatch right: realizers declared in El, resolved by name, no
// runtime patch per modality. It got the RESULT TYPE wrong —
// `transduce(signal, modality) -> Geometry`, one vector per signal.
//
// One vector is a FINGERPRINT. It can be matched and it can be ranked, and
// that is the whole of what it can ever do. It cannot be decomposed, cannot
// have one part grounded while another is not, and cannot be contradicted in
// one part while holding in another — because it has no parts. Treating
// transduction as a CONVERSION (signal in, position out) is the premise this
// file exists to falsify.
//
// A song is not a point. It decomposes into pitch, interval, rhythm, harmonic
// function — components, each with its own geometry, plus the relations among
// them. THE SONG IS THE STRUCTURE OF THE RELATIONS. So transduction yields a
// Manifold: named components carrying geometry, and typed weighted relations
// between them.
//
// The geometry tests below are UNCHANGED from #144 and still pass, which is
// the point: Geometry was never wrong, it was misplaced. A vector is the right
// representation for a COMPONENT. It was only ever wrong as the representation
// of a whole transduced signal.
//
// COMPARISON DISCIPLINE IN THIS FILE (measured 2026-08-16, not stylistic):
// elc lowers `a == b` to a NUMERIC comparison only when both operand names are
// in the per-function int-name set, which `let x: Int` populates. A bare call
// like `manifold_size(m) == 5` is not a registered name, so it lowers to
// `str_eq(...)` — strcmp on two integers reinterpreted as pointers. `<` and `>`
// lower directly via binop_to_c with no type inference at all, so truthiness is
// written `> 0` / `< 1` here, and any exact `==` is done on a value first bound
// through `let x: Int`.
//
// ONE FURTHER RULE, measured while writing this file: that int-name set LEAKS
// ACROSS `test` BLOCKS. Binding `dn` as a Float in one test and as an Int in
// another silently demoted the Int comparison to str_eq and failed an
// assertion that was arithmetically true. Every Int-bound name compared with
// `==` here is therefore spelled UNIQUELY across the whole file (note_dim,
// iv_dim, ...), rather than reusing a short name per test.

// ── A DECOMPOSING realizer, written entirely in El ──────────────────────────
// "tone" signals are note letters, e.g. "CEG". This realizer does NOT return
// one vector for the chord. It returns the PARTS — one component per note, one
// per interval between adjacent notes — and the relations that make those
// parts a chord rather than an unordered bag of pitches.
//
// The interval is deliberately a COMPONENT, not an attribute of a note. An
// interval is a thing with its own geometry that belongs to neither endpoint;
// modelling it as a field on a note is exactly the collapse this change
// rejects, one level down.
fn tone_realizer(signal: String) -> Manifold {
    let m: Manifold = manifold_new()
    let n: Int = str_len(signal)

    let i: Int = 0
    while i < n {
        let code: Int = str_char_code(signal, i)
        let g: Geometry = geometry_new(2)
        let s0: Int = geometry_set(g, 0, int_to_float(code))
        let s1: Int = geometry_set(g, 1, int_to_float(i))
        let idx: Int = manifold_add(m, "note:" + int_to_str(i), "pitch", g)
        let f: Int = geometry_free(g)
        i = i + 1
    }

    let j: Int = 1
    while j < n {
        let a: Int = str_char_code(signal, j - 1)
        let b: Int = str_char_code(signal, j)
        let lo: String = "note:" + int_to_str(j - 1)
        let hi: String = "note:" + int_to_str(j)
        let key: String = "interval:" + int_to_str(j - 1) + "-" + int_to_str(j)
        let g: Geometry = geometry_new(1)
        let s: Int = geometry_set(g, 0, int_to_float(b - a))
        let idx: Int = manifold_add(m, key, "interval", g)
        let f: Int = geometry_free(g)
        let e1: Int = manifold_relate(m, key, "spans", lo, 0.9)
        let e2: Int = manifold_relate(m, key, "spans", hi, 0.9)
        let e3: Int = manifold_relate(m, lo, "sounds_before", hi, 0.8)
        j = j + 1
    }
    m
}

// A second realizer for a different modality, to prove the registry keys on
// modality and does not just hand back "the last thing registered". Its
// decomposition has a DIFFERENT shape — two components, one relation — so a
// test can tell the two organs apart by structure alone.
fn pulse_realizer(signal: String) -> Manifold {
    let m: Manifold = manifold_new()
    let ga: Geometry = geometry_new(1)
    let sa: Int = geometry_set(ga, 0, 1.0)
    let ia: Int = manifold_add(m, "onset", "event", ga)
    let fa: Int = geometry_free(ga)
    let gb: Geometry = geometry_new(1)
    let sb: Int = geometry_set(gb, 0, 0.0)
    let ib: Int = manifold_add(m, "decay", "envelope", gb)
    let fb: Int = geometry_free(gb)
    let e: Int = manifold_relate(m, "onset", "decays_into", "decay", 0.7)
    m
}

// #144's ACTUAL CONTRACT, preserved verbatim as a control: a realizer that
// returns one vector for the whole signal. This is not a strawman — it is what
// the merged primitive asked realizers to be. It must now transduce NOTHING.
fn fingerprint_realizer(signal: String) -> Geometry {
    let g: Geometry = geometry_new(4)
    let n: Int = str_len(signal)
    let a: Int = geometry_set(g, 0, int_to_float(n))
    let b: Int = geometry_set(g, 1, int_to_float(n * 2))
    g
}

// A realizer returning something that is not a value at all.
fn bogus_realizer(signal: String) -> Manifold {
    return 12345
}

// ═══════════════════════════════════════════════════════════════════════════
// Geometry — unchanged from #144. A vector is the right representation for a
// COMPONENT; it was only ever wrong as the representation of a whole signal.
// ═══════════════════════════════════════════════════════════════════════════

test "geometry-is-a-value-with-its-own-width" {
    let g: Geometry = geometry_new(8)
    let live: Int = geometry_is(g)
    assert live > 0, "geometry_new returns a live Geometry"
    let d: Int = geometry_dim(g)
    assert d == 8, "a Geometry carries its own width"
    let freed: Int = geometry_free(g)
    assert freed > 0, "geometry_free reports what it did"
}

test "geometry-rejects-nonsense-without-an-arbitrary-bound" {
    let zero: Geometry = geometry_new(0)
    let z: Int = geometry_is(zero)
    assert z < 1, "dim 0 is not a geometry"
    let neg: Geometry = geometry_new(-4)
    let n: Int = geometry_is(neg)
    assert n < 1, "negative dim is not a geometry"
    let nd: Int = geometry_dim(0)
    assert nd < 1, "geometry_dim of a non-geometry is 0"
    let ni: Int = geometry_is(0)
    assert ni < 1, "geometry_is of a non-geometry is 0"
    let nf: Int = geometry_free(0)
    assert nf < 1, "geometry_free of a non-geometry is a no-op"
}

test "geometry-components-round-trip" {
    let g: Geometry = geometry_new(3)
    let s0: Int = geometry_set(g, 0, 1.5)
    let s1: Int = geometry_set(g, 1, -2.5)
    assert s0 > 0, "set in range succeeds"
    let oob: Int = geometry_set(g, 3, 9.0)
    assert oob < 1, "set out of range is refused, not silently dropped"
    let v0: Float = geometry_get(g, 0)
    let d0: Float = v0 - 1.5
    assert d0 < 0.001, "component 0 round-trips"
    assert d0 > -0.001, "component 0 round-trips"
    let v1: Float = geometry_get(g, 1)
    let d1: Float = v1 + 2.5
    assert d1 < 0.001, "component 1 round-trips (negative)"
    assert d1 > -0.001, "component 1 round-trips (negative)"
    let freed: Int = geometry_free(g)
}

test "hex-is-an-edge-adapter-and-derives-its-own-width" {
    let g: Geometry = geometry_from_f32le_hex("0000803f00000040")
    let live: Int = geometry_is(g)
    assert live > 0, "valid hex decodes to a Geometry"
    let hex_dim: Int = geometry_dim(g)
    assert hex_dim == 2, "width is DERIVED from the input, never supplied"
    let back: String = geometry_to_f32le_hex(g)
    assert str_eq(back, "0000803f00000040"), "hex round-trips exactly"
    let freed: Int = geometry_free(g)
}

test "hex-rejects-malformed-input" {
    let empty: Geometry = geometry_from_f32le_hex("")
    let e: Int = geometry_is(empty)
    assert e < 1, "empty hex is not a geometry"
    let ragged: Geometry = geometry_from_f32le_hex("0000803f0000")
    let r: Int = geometry_is(ragged)
    assert r < 1, "length not a multiple of 8 is refused"
    let nonhex: Geometry = geometry_from_f32le_hex("zzzzzzzz")
    let nh: Int = geometry_is(nonhex)
    assert nh < 1, "non-hex characters are refused"
}

test "norm-lets-a-caller-check-a-realizer-emitted-signal" {
    let g: Geometry = geometry_new(2)
    let z: Float = geometry_norm(g)
    assert z < 0.001, "a fresh geometry is zero — norm says so"
    let s0: Int = geometry_set(g, 0, 3.0)
    let s1: Int = geometry_set(g, 1, 4.0)
    let nrm: Float = geometry_norm(g)
    let dnorm: Float = nrm - 5.0
    assert dnorm < 0.001, "3-4-5: norm is 5"
    assert dnorm > -0.001, "3-4-5: norm is 5"
    let freed: Int = geometry_free(g)
}

// ═══════════════════════════════════════════════════════════════════════════
// Manifold — the corrected result of a transduction
// ═══════════════════════════════════════════════════════════════════════════

test "a-manifold-is-a-value-that-holds-parts-and-relations" {
    let m: Manifold = manifold_new()
    let live: Int = manifold_is(m)
    assert live > 0, "manifold_new returns a live Manifold"
    let fresh_sz: Int = manifold_size(m)
    assert fresh_sz == 0, "a fresh manifold has no components"
    let fresh_rc: Int = manifold_rel_count(m)
    assert fresh_rc == 0, "a fresh manifold has no relations"
    let freed: Int = manifold_free(m)
    assert freed > 0, "manifold_free reports what it did"
}

test "manifold-accessors-are-total" {
    let ni2: Int = manifold_is(0)
    assert ni2 < 1, "manifold_is of a non-manifold is 0"
    let ns: Int = manifold_size(0)
    assert ns < 1, "manifold_size of a non-manifold is 0"
    let nf2: Int = manifold_free(0)
    assert nf2 < 1, "manifold_free of a non-manifold is a no-op"
    let k: String = manifold_key(0, 0)
    assert str_eq(k, ""), "manifold_key of a non-manifold is empty, never a crash"
}

test "components-are-addressed-by-key-not-by-index" {
    // The key is what survives persistence: a component becomes a node, and it
    // is separately groundable precisely because it is separately NAMED.
    let m: Manifold = manifold_new()
    let g: Geometry = geometry_new(1)
    let s: Int = geometry_set(g, 0, 7.0)
    let first_idx: Int = manifold_add(m, "rhythm", "temporal", g)
    assert first_idx == 0, "the first component is index 0"
    let found_idx: Int = manifold_index_of(m, "rhythm")
    assert found_idx == 0, "a component is found by its key"
    let missing: Int = manifold_index_of(m, "never_added")
    assert missing < 0, "an unknown key resolves to -1, not to component 0"
    let role: String = manifold_role(m, 0)
    assert str_eq(role, "temporal"), "a component carries what KIND of part it is"
    let f: Int = geometry_free(g)
    let fm: Int = manifold_free(m)
}

test "a-duplicate-key-is-refused-because-addressing-must-be-unambiguous" {
    let m: Manifold = manifold_new()
    let g: Geometry = geometry_new(1)
    let ok_idx: Int = manifold_add(m, "pitch", "spectral", g)
    assert ok_idx == 0, "first add succeeds"
    let dup: Int = manifold_add(m, "pitch", "spectral", g)
    assert dup < 0, "two components answering to one name is not an addressing scheme"
    let dup_sz: Int = manifold_size(m)
    assert dup_sz == 1, "and the duplicate did not land"
    let f: Int = geometry_free(g)
    let fm: Int = manifold_free(m)
}

test "a-part-with-no-geometry-is-not-a-part" {
    let m: Manifold = manifold_new()
    let bad: Int = manifold_add(m, "ghost", "none", 0)
    assert bad < 0, "a non-Geometry is refused as a component"
    let empty_key: Int = manifold_add(m, "", "none", geometry_new(1))
    assert empty_key < 0, "an unaddressable component is refused"
    let none_sz: Int = manifold_size(m)
    assert none_sz < 1, "nothing landed"
    let fm: Int = manifold_free(m)
}

test "an-edge-to-a-nonexistent-endpoint-is-refused-not-dropped" {
    // A decomposition that silently loses edges is indistinguishable from one
    // that never had them.
    let m: Manifold = manifold_new()
    let g: Geometry = geometry_new(1)
    let a: Int = manifold_add(m, "here", "part", g)
    let dangling: Int = manifold_relate(m, "here", "points_at", "nowhere", 0.5)
    assert dangling < 1, "an edge to an unknown target is refused"
    let backwards: Int = manifold_relate(m, "nowhere", "points_at", "here", 0.5)
    assert backwards < 1, "an edge from an unknown source is refused"
    let dang_rc: Int = manifold_rel_count(m)
    assert dang_rc < 1, "and no relation was recorded"
    let f: Int = geometry_free(g)
    let fm: Int = manifold_free(m)
}

test "a-component-owns-its-geometry-independently-of-the-caller" {
    // manifold_add COPIES. Freeing the caller's vector must not disturb the
    // component, or a decomposition would be unusable the moment it was built.
    let m: Manifold = manifold_new()
    let g: Geometry = geometry_new(2)
    let s0: Int = geometry_set(g, 0, 42.0)
    let idx: Int = manifold_add(m, "part", "kind", g)
    let freed: Int = geometry_free(g)
    assert freed > 0, "the caller freed its own vector"
    let back: Geometry = manifold_geometry(m, 0)
    let live: Int = geometry_is(back)
    assert live > 0, "the component still has geometry"
    let v: Float = geometry_get(back, 0)
    let dv: Float = v - 42.0
    assert dv < 0.001, "and it is the right geometry"
    assert dv > -0.001, "and it is the right geometry"
    let fb: Int = geometry_free(back)
    let fm: Int = manifold_free(m)
}

// ═══════════════════════════════════════════════════════════════════════════
// transduce — signal in, SUBGRAPH out
// ═══════════════════════════════════════════════════════════════════════════

test "a-realizer-declared-in-el-is-a-first-class-realizer" {
    // THE CLAIM, unchanged from #144: tone_realizer is an ordinary El function.
    // It is not in the runtime and the compiler knows nothing about it.
    // Registering it by name is enough to make it the organ for a modality.
    let reg: Int = realizer_register("tone", "tone_realizer")
    assert reg > 0, "an El fn registers as a realizer by name"
    let has: Int = realizer_has("tone")
    assert has > 0, "the modality now has an organ"

    let m: Manifold = transduce("CEG", "tone")
    let live: Int = manifold_is(m)
    assert live > 0, "transduce returns a real Manifold"
    let fm: Int = manifold_free(m)
}

test "transduction-decomposes-a-signal-into-parts" {
    // THE CENTRAL CLAIM. "CEG" is three notes. What comes back is not one
    // vector standing for a chord — it is five addressable parts (three notes,
    // two intervals) and six relations. A fingerprint has one part by
    // construction and could not express this at any width.
    let reg: Int = realizer_register("tone", "tone_realizer")
    let m: Manifold = transduce("CEG", "tone")

    let ceg_sz: Int = manifold_size(m)
    assert ceg_sz == 5, "three notes and two intervals are five distinct parts"
    let ceg_rc: Int = manifold_rel_count(m)
    assert ceg_rc == 6, "and the parts stand in six stated relations"

    // Every part is independently addressable BY NAME.
    let n0: Int = manifold_index_of(m, "note:0")
    assert n0 > -1, "the first note is addressable on its own"
    let n2: Int = manifold_index_of(m, "note:2")
    assert n2 > -1, "so is the third"
    let iv: Int = manifold_index_of(m, "interval:0-1")
    assert iv > -1, "so is the interval between the first two"

    let fm: Int = manifold_free(m)
}

test "each-part-carries-its-own-geometry" {
    let reg: Int = realizer_register("tone", "tone_realizer")
    let m: Manifold = transduce("CEG", "tone")

    // 'C' is 67. The note component's geometry is the note's, not the chord's.
    let note_i: Int = manifold_index_of(m, "note:0")
    let gn: Geometry = manifold_geometry(m, note_i)
    let note_dim: Int = geometry_dim(gn)
    assert note_dim == 2, "a note component has the width its realizer gave it"
    let pitch: Float = geometry_get(gn, 0)
    let dpitch: Float = pitch - 67.0
    assert dpitch < 0.001, "and it is C, so the signal reached the El realizer"
    assert dpitch > -0.001, "and it is C, so the signal reached the El realizer"

    // Parts may have DIFFERENT widths. A single vector per signal cannot
    // represent parts of unequal dimensionality at all.
    let iv_i: Int = manifold_index_of(m, "interval:0-1")
    let gi: Geometry = manifold_geometry(m, iv_i)
    let iv_dim: Int = geometry_dim(gi)
    assert iv_dim == 1, "an interval component has its own, different width"

    let f1: Int = geometry_free(gn)
    let f2: Int = geometry_free(gi)
    let fm: Int = manifold_free(m)
}

test "the-relations-are-content-no-single-part-carries" {
    // THE POINT OF THE WHOLE CHANGE. C->E is two semitones. That "2" is not a
    // property of C and not a property of E; it exists only BETWEEN them. A
    // representation with no relations cannot hold it, which is why collapsing
    // a signal to one vector does not merely lose resolution — it loses a
    // category of content.
    let reg: Int = realizer_register("tone", "tone_realizer")
    let m: Manifold = transduce("CEG", "tone")

    let step_i: Int = manifold_index_of(m, "interval:0-1")
    let gi: Geometry = manifold_geometry(m, step_i)
    let step: Float = geometry_get(gi, 0)
    let dstep: Float = step - 2.0
    assert dstep < 0.001, "C to E is two semitones"
    assert dstep > -0.001, "C to E is two semitones"

    // And the interval is WIRED to both endpoints, so the structure says which
    // two things it is the interval between.
    let spans: Int = 0
    let span_rc: Int = manifold_rel_count(m)
    let k: Int = 0
    while k < span_rc {
        let rn: String = manifold_rel_name(m, k)
        let rf: String = manifold_rel_from(m, k)
        if str_eq(rn, "spans") {
            if str_eq(rf, "interval:0-1") { spans = spans + 1 }
        }
        k = k + 1
    }
    assert spans == 2, "the interval is related to both notes it spans"

    let fg: Int = geometry_free(gi)
    let fm: Int = manifold_free(m)
}

test "relation-weight-is-the-grounding-carried-on-the-edge" {
    // correspondence-and-censorship.md §1: grounding is an attribute of the
    // edge and it IS the weight — one quantity, not a score computed beside
    // it. A realizer states a relation and its weight is the claim.
    let reg: Int = realizer_register("tone", "tone_realizer")
    let m: Manifold = transduce("CE", "tone")

    let ce_rc: Int = manifold_rel_count(m)
    assert ce_rc == 3, "one interval yields two spans and one ordering"

    let found_w: Int = 0
    let k: Int = 0
    while k < ce_rc {
        let rn: String = manifold_rel_name(m, k)
        if str_eq(rn, "sounds_before") {
            let w: Float = manifold_rel_weight(m, k)
            let dw: Float = w - 0.8
            if dw < 0.001 { if dw > -0.001 { found_w = found_w + 1 } }
        }
        k = k + 1
    }
    assert found_w == 1, "the ordering relation carries the weight its realizer stated"

    let fm: Int = manifold_free(m)
}

test "distinct-signals-decompose-differently" {
    let reg: Int = realizer_register("tone", "tone_realizer")
    let m2: Manifold = transduce("CE", "tone")
    let m3: Manifold = transduce("CEG", "tone")
    let two_sz: Int = manifold_size(m2)
    let three_sz: Int = manifold_size(m3)
    assert two_sz == 3, "two notes decompose into two notes and one interval"
    assert three_sz == 5, "three notes decompose into three notes and two intervals"
    // Structure differs, not just position: fingerprints of a two-note and a
    // three-note signal have identical shape and differ only numerically.
    let two_rc: Int = manifold_rel_count(m2)
    let three_rc: Int = manifold_rel_count(m3)
    assert two_rc < three_rc, "and the relational structure itself differs"
    let f2: Int = manifold_free(m2)
    let f3: Int = manifold_free(m3)
}

test "the-registry-keys-on-modality" {
    let r1: Int = realizer_register("tone", "tone_realizer")
    let rp: Int = realizer_register("pulse", "pulse_realizer")
    assert rp > 0, "a second modality registers independently"
    let mt: Manifold = transduce("CEG", "tone")
    let mp: Manifold = transduce("CEG", "pulse")
    let tone_sz: Int = manifold_size(mt)
    let pulse_sz: Int = manifold_size(mp)
    assert tone_sz == 5, "tone still routes to its own realizer"
    assert pulse_sz == 2, "pulse routes to a different realizer, with its own decomposition"
    let onset: Int = manifold_index_of(mp, "onset")
    assert onset > -1, "and to that realizer's own component vocabulary"
    let f1: Int = manifold_free(mt)
    let f2: Int = manifold_free(mp)
}

test "no-organ-is-reported-as-no-organ" {
    // A modality with no realizer must transduce to NOTHING. It must never
    // fall back to embedding a description of the signal and calling that
    // perception — that silent substitution is the original defect.
    let has: Int = realizer_has("echolocation")
    assert has < 1, "unregistered modality has no organ"
    let m: Manifold = transduce("anything", "echolocation")
    let live: Int = manifold_is(m)
    assert live < 1, "no realizer means no manifold, not a fake one"
}

test "registration-of-an-unresolvable-name-fails-loudly" {
    let bad: Int = realizer_register("ghost", "no_such_function_anywhere")
    assert bad < 1, "an unresolvable realizer name is a registration failure"
    let has: Int = realizer_has("ghost")
    assert has < 1, "and nothing gets registered"
}

test "a-fingerprint-realizer-transduces-nothing" {
    // THE SUPERSESSION OF #144, asserted directly. fingerprint_realizer is
    // exactly what the merged primitive asked a realizer to be: signal in, one
    // Geometry out. It resolves, so registration succeeds — the organ is
    // present. But it does not decompose, so it does not transduce.
    //
    // This is a deliberate hard failure. "No organ" and "an organ that only
    // fingerprints" must not be indistinguishable, which is the same
    // distinction realizer_register already draws between an absent and a
    // broken organ. A modality with genuinely one part says so with
    // manifold_single, and is then visibly a size-1 manifold.
    let reg: Int = realizer_register("fingerprint", "fingerprint_realizer")
    assert reg > 0, "the symbol resolves, so registration succeeds"
    let m: Manifold = transduce("x", "fingerprint")
    let live: Int = manifold_is(m)
    assert live < 1, "a single vector is not a transduction"
}

test "a-realizer-returning-nonsense-transduces-nothing" {
    let reg: Int = realizer_register("bogus", "bogus_realizer")
    assert reg > 0, "the symbol resolves, so registration succeeds"
    let m: Manifold = transduce("x", "bogus")
    let live: Int = manifold_is(m)
    assert live < 1, "a non-Manifold return transduced nothing"
}

test "the-one-part-case-is-a-size-one-manifold-not-a-bare-vector" {
    // Some modalities really do have one part. That is a manifold of size 1 —
    // a special case of decomposition, not a parallel path back to a
    // fingerprint. Anything reading it still asks manifold_size and still gets
    // a real answer, and a second part can be added later without changing the
    // type of the thing.
    let g: Geometry = geometry_new(3)
    let s: Int = geometry_set(g, 0, 5.0)
    let m: Manifold = manifold_single("level", "scalar", g)
    let live: Int = manifold_is(m)
    assert live > 0, "manifold_single yields a real Manifold"
    let one_sz: Int = manifold_size(m)
    assert one_sz == 1, "of size one — visibly degenerate, not hidden"
    let idx: Int = manifold_index_of(m, "level")
    assert idx == 0, "and its one part is still addressable by name"
    let f: Int = geometry_free(g)
    let fm: Int = manifold_free(m)
}