//! `Sub` — two-input f64 difference (input 0 minus input 1), e.g. a fast/slow
//! spread. The walking skeleton's second worked node: it gives the sim loop a
//! real fan-out + join to run (two SMAs joining into one node), exercising
//! multi-input `Ctx` access inside a running graph.

use aura_core::{Ctx, FieldSpec, Firing, InputSpec, LeafFactory, Node, NodeSchema, Scalar, ScalarKind};

/// Two-input f64 difference: input 0 minus input 1. Emits `None` until both
/// inputs have a value.
pub struct Sub {
    out: [Scalar; 1],
}

impl Sub {
    /// Build a `Sub` node.
    pub fn new() -> Self {
        Self { out: [Scalar::F64(0.0)] }
    }

    /// The param-generic recipe for a blueprint leaf: paramless, builds through
    /// `Sub::new`.
    pub fn factory() -> LeafFactory {
        LeafFactory::new("Sub", vec![], |_| Box::new(Sub::new()))
    }
}

impl Default for Sub {
    fn default() -> Self {
        Self::new()
    }
}

impl Node for Sub {
    fn schema(&self) -> NodeSchema {
        NodeSchema {
            inputs: vec![
                InputSpec { kind: ScalarKind::F64, lookback: 1, firing: Firing::Any },
                InputSpec { kind: ScalarKind::F64, lookback: 1, firing: Firing::Any },
            ],
            output: vec![FieldSpec { name: "value", kind: ScalarKind::F64 }],
            params: vec![],
        }
    }

    fn eval(&mut self, ctx: Ctx<'_>) -> Option<&[Scalar]> {
        let a = ctx.f64_in(0);
        let b = ctx.f64_in(1);
        if a.is_empty() || b.is_empty() {
            return None;
        }
        self.out[0] = Scalar::F64(a[0] - b[0]);
        Some(&self.out)
    }

    fn label(&self) -> String {
        "Sub".to_string()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use aura_core::{AnyColumn, Timestamp};

    #[test]
    fn factory_params_match_built_node_schema() {
        let f = Sub::factory();
        let built = f.build(&[]);
        assert_eq!(f.params(), built.schema().params.as_slice());
    }

    #[test]
    fn sub_is_difference_once_both_inputs_present() {
        let mut sub = Sub::new();
        let mut inputs = vec![
            AnyColumn::with_capacity(ScalarKind::F64, 1),
            AnyColumn::with_capacity(ScalarKind::F64, 1),
        ];

        // only input 0 present -> None
        inputs[0].push(Scalar::F64(10.0)).unwrap();
        assert_eq!(sub.eval(Ctx::new(&inputs, Timestamp(0))), None);

        // both present -> a - b
        inputs[1].push(Scalar::F64(4.0)).unwrap();
        assert_eq!(sub.eval(Ctx::new(&inputs, Timestamp(0))), Some([Scalar::F64(6.0)].as_slice()));
    }
}