#define MAX_BRANCHES 3
#define MAX_DEPTH    4
#define NWIN         256   // window length for energy/power estimates

typedef struct Node {
    var  v;   // state
    var  r;   // intrinsic rate
    void* c;  // array of child Node* (cast on access)
    int  n;   // number of children
    int  d;   // depth
} Node;

Node* Root;

// ---- Discrete-time helpers for energy/power -------------------------------

// Sum of squares over the last N samples of a series (Data[0] = most recent)
var sumsq(vars Data, int N)
{
    var s = 0;
    int i;
    for(i = 0; i < N; i++)
        s += Data[i]*Data[i];
    return s;
}

// ---- Tree construction / evaluation ---------------------------------------

Node* createNode(int depth)
{
    Node* u = (Node*)malloc(sizeof(Node));
    u->v = random();
    u->r = 0.01 + 0.02*depth + random()*0.005;
    u->d = depth;

    if(depth > 0) {
        u->n = (int)(random()*MAX_BRANCHES) + 1;
        u->c = malloc(u->n * sizeof(void*));  // array of Node*
        int i;
        for(i = 0; i < u->n; i++)
            ((Node**)u->c)[i] = createNode(depth - 1);
    } else {
        u->n = 0;
        u->c = 0;
    }
    return u;
}

var evaluateNode(Node* u)
{
    if(!u) return 0;

    var sum = 0;
    int i;
    for(i = 0; i < u->n; i++)
        sum += evaluateNode(((Node**)u->c)[i]);

    // depth-attenuated phase response
    var phase  = sin(u->r * Bar + sum);
    var weight = 1.0 / pow(u->d + 1, 1.25);
    u->v = (1 - weight)*u->v + weight*phase;
    return u->v;
}

int countNodes(Node* u)
{
    if(!u) return 0;
    int count = 1, i;
    for(i = 0; i < u->n; i++)
        count += countNodes(((Node**)u->c)[i]);
    return count;
}

void printTree(Node* u, int indent)
{
    if(!u) return;
    string pad = " ";
    int i;
    for(i = 0; i < indent; i++)
        pad = strf("%s ", pad);
    printf("\n%s[Node] d=%i n=%i v=%.3f", pad, u->d, u->n, u->v);
    for(i = 0; i < u->n; i++)
        printTree(((Node**)u->c)[i], indent + 1);
}

void freeTree(Node* u)
{
    if(!u) return;
    int i;
    for(i = 0; i < u->n; i++)
        freeTree(((Node**)u->c)[i]);
    if(u->c) free(u->c);
    free(u);
}

// ---- Main bar loop ---------------------------------------------------------

function run()
{
    static int initialized = 0;
    static var E_cum = 0;          // cumulative energy of lambda
    static var lambda;             // field projection per bar

    if(is(INITRUN) && !initialized) {
        // ensure series buffer supports our window NWIN
        if(LookBack < NWIN) LookBack = NWIN;
        Root = createNode(MAX_DEPTH);
        initialized = 1;
        printf("\nRoot initialized with %i nodes", countNodes(Root));
    }

    // 1) Evaluate harmonic field -> lambda[n]
    lambda = evaluateNode(Root);

    // 2) Build a series of lambda for windowed energy/power
    vars LamSeries = series(lambda);       // LamSeries[0] == current lambda

    // 3) Windowed energy & power (discrete-time)
    var E_win = sumsq(LamSeries, NWIN);    // sum_{k=0..NWIN-1} |lambda|^2
    var P_win = E_win / NWIN;              // average power over the window

    // 4) Cumulative energy (to date)
    E_cum += lambda*lambda;

    // 5) Output / optional plot
    printf("\nlambda=%.6f  E_win(%i)=%.6f  P_win=%.6f  E_cum=%.6f",
        lambda, NWIN, E_win, P_win, E_cum);

    plot("lambda",lambda,LINE,0);
    plot("P_win",P_win,LINE,0);

    if(Bar % 100 == 0)
        printTree(Root, 0);

    // Optional symbolic trigger
    if(lambda > 0.75)
        enterLong();
}

// Called automatically at end of session/backtest; free memory.
function cleanup()
{
    if(Root) freeTree(Root);
}