#include "kiran_ensemble_v070.h"
#include "kiran_ensemble_v070_data.h"
#include <math.h>
#include <string.h>

void kiran_rolling_buffer_init(KiranRollingBuffer *buf) {
    memset(buf, 0, sizeof(KiranRollingBuffer));
}

void kiran_rolling_buffer_push(KiranRollingBuffer *buf, const float *base_features) {
    int idx = buf->pos % KIRAN_LONG_LOOKBACK;
    buf->hr[idx]   = base_features[KIRAN_IDX_HR];
    buf->eda[idx]  = base_features[KIRAN_IDX_EDA];
    buf->acc[idx]  = base_features[KIRAN_IDX_ACC];
    buf->temp[idx] = base_features[KIRAN_IDX_TEMP];
    buf->pos++;
    if (buf->count < KIRAN_LONG_LOOKBACK)
        buf->count++;
}

static float arr_mean(const float *ring, int ring_size, int total_pos, int n) {
    float sum = 0.0f;
    for (int i = 0; i < n; i++) {
        int idx = (total_pos - n + i) % ring_size;
        sum += ring[idx];
    }
    return sum / (float)n;
}

static float arr_std(const float *ring, int ring_size, int total_pos, int n, float mean) {
    if (n < 2) return 0.0f;
    float sum_sq = 0.0f;
    for (int i = 0; i < n; i++) {
        int idx = (total_pos - n + i) % ring_size;
        float d = ring[idx] - mean;
        sum_sq += d * d;
    }
    return sqrtf(sum_sq / (float)n);
}

static float arr_trend(const float *ring, int ring_size, int total_pos, int n) {
    if (n < 2) return 0.0f;
    float x_mean = (float)(n - 1) / 2.0f;
    float y_sum = 0.0f;
    for (int i = 0; i < n; i++) {
        int idx = (total_pos - n + i) % ring_size;
        y_sum += ring[idx];
    }
    float y_mean = y_sum / (float)n;

    float num = 0.0f, den = 0.0f;
    for (int i = 0; i < n; i++) {
        int idx = (total_pos - n + i) % ring_size;
        float dx = (float)i - x_mean;
        num += dx * (ring[idx] - y_mean);
        den += dx * dx;
    }
    if (den < 1e-12f) return 0.0f;
    return num / den;
}

static float arr_corr(const float *ring_a, const float *ring_b, int ring_size, int total_pos, int n) {
    if (n < 2) return 0.0f;
    float ma = arr_mean(ring_a, ring_size, total_pos, n);
    float mb = arr_mean(ring_b, ring_size, total_pos, n);
    float sa = arr_std(ring_a, ring_size, total_pos, n, ma);
    float sb = arr_std(ring_b, ring_size, total_pos, n, mb);
    if (sa < 1e-12f || sb < 1e-12f) return 0.0f;

    float cov = 0.0f;
    for (int i = 0; i < n; i++) {
        int idx = (total_pos - n + i) % ring_size;
        cov += (ring_a[idx] - ma) * (ring_b[idx] - mb);
    }
    cov /= (float)n;
    float r = cov / (sa * sb);
    if (r != r) return 0.0f; /* NaN guard */
    return r;
}

static float arr_sum_sq(const float *ring, int ring_size, int total_pos, int n) {
    float sum = 0.0f;
    for (int i = 0; i < n; i++) {
        int idx = (total_pos - n + i) % ring_size;
        sum += ring[idx] * ring[idx];
    }
    return sum;
}

static float arr_range(const float *ring, int ring_size, int total_pos, int n) {
    if (n < 2) return 0.0f;
    int idx0 = (total_pos - n) % ring_size;
    float mn = ring[idx0], mx = ring[idx0];
    for (int i = 1; i < n; i++) {
        int idx = (total_pos - n + i) % ring_size;
        if (ring[idx] < mn) mn = ring[idx];
        if (ring[idx] > mx) mx = ring[idx];
    }
    return mx - mn;
}

void kiran_compute_medium_rolling(const KiranRollingBuffer *buf, float *out14) {
    int n = buf->count;
    if (n > KIRAN_MEDIUM_LOOKBACK) n = KIRAN_MEDIUM_LOOKBACK;
    int rs = KIRAN_LONG_LOOKBACK;
    int tp = buf->pos;

    float hr_m  = arr_mean(buf->hr,   rs, tp, n);
    float eda_m = arr_mean(buf->eda,  rs, tp, n);
    float acc_m = arr_mean(buf->acc,  rs, tp, n);
    float tmp_m = arr_mean(buf->temp, rs, tp, n);

    out14[0]  = hr_m;
    out14[1]  = arr_std(buf->hr, rs, tp, n, hr_m);
    out14[2]  = arr_trend(buf->hr, rs, tp, n);
    out14[3]  = eda_m;
    out14[4]  = arr_std(buf->eda, rs, tp, n, eda_m);
    out14[5]  = arr_trend(buf->eda, rs, tp, n);
    out14[6]  = acc_m;
    out14[7]  = arr_std(buf->acc, rs, tp, n, acc_m);
    out14[8]  = arr_sum_sq(buf->acc, rs, tp, n);
    out14[9]  = tmp_m;
    out14[10] = arr_std(buf->temp, rs, tp, n, tmp_m);
    out14[11] = arr_trend(buf->temp, rs, tp, n);
    out14[12] = arr_corr(buf->hr, buf->eda, rs, tp, n);
    out14[13] = arr_corr(buf->hr, buf->acc, rs, tp, n);
}

void kiran_compute_long_rolling(const KiranRollingBuffer *buf, float *out20) {
    int n = buf->count;
    if (n > KIRAN_LONG_LOOKBACK) n = KIRAN_LONG_LOOKBACK;
    int rs = KIRAN_LONG_LOOKBACK;
    int tp = buf->pos;

    float hr_m  = arr_mean(buf->hr,   rs, tp, n);
    float eda_m = arr_mean(buf->eda,  rs, tp, n);
    float acc_m = arr_mean(buf->acc,  rs, tp, n);
    float tmp_m = arr_mean(buf->temp, rs, tp, n);
    float hr_s  = arr_std(buf->hr, rs, tp, n, hr_m);

    out20[0]  = hr_m;
    out20[1]  = hr_s;
    out20[2]  = arr_trend(buf->hr, rs, tp, n);
    out20[3]  = arr_range(buf->hr, rs, tp, n);
    out20[4]  = eda_m;
    out20[5]  = arr_std(buf->eda, rs, tp, n, eda_m);
    out20[6]  = arr_trend(buf->eda, rs, tp, n);
    out20[7]  = arr_range(buf->eda, rs, tp, n);
    out20[8]  = acc_m;
    out20[9]  = arr_std(buf->acc, rs, tp, n, acc_m);
    out20[10] = arr_sum_sq(buf->acc, rs, tp, n);

    /* fraction of windows with ACC > 0.5 */
    float acc_frac = 0.0f;
    for (int i = 0; i < n; i++) {
        int idx = (tp - n + i) % rs;
        if (buf->acc[idx] > 0.5f) acc_frac += 1.0f;
    }
    out20[11] = acc_frac / (float)n;

    out20[12] = tmp_m;
    out20[13] = arr_std(buf->temp, rs, tp, n, tmp_m);
    out20[14] = arr_range(buf->temp, rs, tp, n);
    out20[15] = arr_corr(buf->hr, buf->acc, rs, tp, n);
    out20[16] = arr_corr(buf->hr, buf->eda, rs, tp, n);
    out20[17] = arr_corr(buf->acc, buf->eda, rs, tp, n);

    /* exercise indicator: fraction of windows where HR elevated AND ACC sustained */
    float ex_frac = 0.0f;
    float hr_thresh = hr_m + 0.5f * hr_s;
    if (n >= 2) {
        for (int i = 0; i < n; i++) {
            int idx = (tp - n + i) % rs;
            if (buf->hr[idx] > hr_thresh && buf->acc[idx] > 0.5f)
                ex_frac += 1.0f;
        }
        ex_frac /= (float)n;
    }
    out20[18] = ex_frac;

    /* baseline stability: 1 if HR std < 5.0 */
    out20[19] = (n >= 2 && hr_s < 5.0f) ? 1.0f : 0.0f;
}

float kiran_sigmoid(float x) {
    return 1.0f / (1.0f + expf(-x));
}

static float predict_one_tree(
    const float *features,
    const int16_t *left,
    const int16_t *right,
    const int16_t *split_idx,
    const float *split_val,
    const float *leaf_val,
    int offset
) {
    int node = 0;
    for (;;) {
        int abs_node = offset + node;
        if (left[abs_node] == -1) {
            return leaf_val[abs_node];
        }
        if (features[split_idx[abs_node]] < split_val[abs_node]) {
            node = left[abs_node];
        } else {
            node = right[abs_node];
        }
    }
}

float kiran_scaler_transform_predict(
    const float *features,
    int n_features,
    const float *scaler_mean,
    const float *scaler_scale,
    const int16_t *tree_left,
    const int16_t *tree_right,
    const int16_t *tree_split_idx,
    const float *tree_split_val,
    const float *tree_leaf_val,
    const int *tree_offsets,
    int n_trees,
    float base_score
) {
    float scaled[KIRAN_N_LONG_FEATURES];
    for (int i = 0; i < n_features; i++) {
        scaled[i] = (features[i] - scaler_mean[i]) / scaler_scale[i];
    }

    float raw = logf(base_score / (1.0f - base_score));
    for (int t = 0; t < n_trees; t++) {
        raw += predict_one_tree(
            scaled,
            tree_left, tree_right,
            tree_split_idx, tree_split_val, tree_leaf_val,
            tree_offsets[t]
        );
    }
    return raw;
}

KiranResult kiran_ensemble_predict(
    const float *base_features,
    KiranRollingBuffer *buf
) {
    KiranResult r;

    kiran_rolling_buffer_push(buf, base_features);

    float medium_rolling[KIRAN_N_MEDIUM_ROLLING];
    float long_rolling[KIRAN_N_LONG_ROLLING];
    kiran_compute_medium_rolling(buf, medium_rolling);
    kiran_compute_long_rolling(buf, long_rolling);

    float feat_medium[KIRAN_N_MEDIUM_FEATURES];
    float feat_long[KIRAN_N_LONG_FEATURES];
    memcpy(feat_medium, base_features, KIRAN_N_BASE_FEATURES * sizeof(float));
    memcpy(feat_medium + KIRAN_N_BASE_FEATURES, medium_rolling, KIRAN_N_MEDIUM_ROLLING * sizeof(float));
    memcpy(feat_long, base_features, KIRAN_N_BASE_FEATURES * sizeof(float));
    memcpy(feat_long + KIRAN_N_BASE_FEATURES, long_rolling, KIRAN_N_LONG_ROLLING * sizeof(float));

    float raw_short = kiran_scaler_transform_predict(
        base_features, KIRAN_N_BASE_FEATURES,
        scaler_short_mean, scaler_short_scale,
        tree_left_short, tree_right_short,
        tree_split_idx_short, tree_split_val_short, tree_leaf_val_short,
        tree_offsets_short, N_TREES_SHORT, base_score_short
    );
    float raw_medium = kiran_scaler_transform_predict(
        feat_medium, KIRAN_N_MEDIUM_FEATURES,
        scaler_medium_mean, scaler_medium_scale,
        tree_left_medium, tree_right_medium,
        tree_split_idx_medium, tree_split_val_medium, tree_leaf_val_medium,
        tree_offsets_medium, N_TREES_MEDIUM, base_score_medium
    );
    float raw_long = kiran_scaler_transform_predict(
        feat_long, KIRAN_N_LONG_FEATURES,
        scaler_long_mean, scaler_long_scale,
        tree_left_long, tree_right_long,
        tree_split_idx_long, tree_split_val_long, tree_leaf_val_long,
        tree_offsets_long, N_TREES_LONG, base_score_long
    );

    r.p_short  = kiran_sigmoid(raw_short);
    r.p_medium = kiran_sigmoid(raw_medium);
    r.p_long   = kiran_sigmoid(raw_long);

    r.p_ensemble = (
        (float)KIRAN_WEIGHT_SHORT  * r.p_short +
        (float)KIRAN_WEIGHT_MEDIUM * r.p_medium +
        (float)KIRAN_WEIGHT_LONG   * r.p_long
    ) / (float)KIRAN_WEIGHT_SUM;

    r.prediction = (r.p_ensemble >= KIRAN_THRESHOLD) ? 1 : 0;

    return r;
}
