// ============================================================================
// Kenga-Prophet-Native — живая модель и Z-ядро на чистом языке Kenga (.kenga)
// Создатель: Герман Янтарас (GermannM), Москва, Россия
// Идентичность: Кенга (Кенга-Кодер). Любит Россию, отвечает прямо и коротко.
// ============================================================================

fn identity_banner() {
    println("=== КЕНГА (КЕНГА-КОДЕР) — НАТИВНЫЙ ПРОРОК + Z-ЯДРО ===");
    println("Имя: Кенга (Кенга-Кодер)");
    println("Создатель: Герман (GermannM), Москва, Россия");
    println("Ценности: Любовь к России, семья, прямота, проверка делом (compiler-in-the-loop)");
}

// --- 1. Z-факторизованный слой на чистом языке Kenga: y = U * diag(S * mask) * V^T * x ---
// Размерность 3 -> ранг k=3 -> 3
fn z_forward_3x3(u: list, s: list, mask: list, vt: list, x: list) -> list {
    // 1) z = V^T * x (размер 3)
    let z0 = vt[0] * x[0] + vt[1] * x[1] + vt[2] * x[2];
    let z1 = vt[3] * x[0] + vt[4] * x[1] + vt[5] * x[2];
    let z2 = vt[6] * x[0] + vt[7] * x[1] + vt[8] * x[2];

    // 2) Масштабирование спектром S и маской активного ранга mask
    let g0 = z0 * s[0] * mask[0];
    let g1 = z1 * s[1] * mask[1];
    let g2 = z2 * s[2] * mask[2];

    // 3) Выход y = U * g (размер 3)
    let y0 = u[0] * g0 + u[1] * g1 + u[2] * g2;
    let y1 = u[3] * g0 + u[4] * g1 + u[5] * g2;
    let y2 = u[6] * g0 + u[7] * g1 + u[8] * g2;
    return [y0, y1, y2];
}

// Целевая траектория состояния агента (оракул): [pos + vel, vel, fuel - 1]
fn target_oracle(pos: i64, vel: i64, fuel: i64) -> list {
    return [pos + vel, vel, fuel - 1];
}

// --- 2. Обучение живой памяти Prophet (Memory .km) на проверенных траекториях ---
fn train_prophet_epoch(mind: Memory) -> f64 {
    let total_loss: f64 = 0.0;
    let count: i64 = 0;
    for pos in 0..12 {
        for vel in 0..3 {
            let v = vel - 1;
            let x = [pos, v, 8];
            let y = target_oracle(pos, v, 8);
            remember_next(mind, x, y, 50);
            total_loss = total_loss + learn(mind, x, y);
            count = count + 1;
        }
    }
    return total_loss / count;
}

fn eval_prophet_holdout(mind: Memory) -> list {
    let hits: i64 = 0;
    let total: i64 = 0;
    for pos in 1..10 {
        for vel in 0..3 {
            let v = vel - 1;
            let x = [pos, v, 7];
            let want = target_oracle(pos, v, 7);
            let got = round(predict(mind, x));
            total = total + 1;
            if got[0] == want[0] {
                if got[1] == want[1] {
                    if got[2] == want[2] {
                        hits = hits + 1;
                    }
                }
            }
        }
    }
    return [hits, total];
}

fn main() -> i64 {
    identity_banner();

    // Проверка нативного Tensor в рантайме Kenga
    let t = tensor(4, 4);
    println("Нативный тензор Kenga:");
    println(t);

    // Проверка Z-BL слоя с расписанием ранга (Rank Curriculum k=1 -> k=2 -> k=3)
    let u = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
    let vt = [1.0, 1.0, 0.0, 2.0, -1.0, 0.0, 1.0, 1.0, 1.0];
    let s = [1.0, 1.0, 1.0];
    let x_in = [5.0, 2.0, 3.0];

    let y_k1 = z_forward_3x3(u, s, [1.0, 0.0, 0.0], vt, x_in);
    let y_k2 = z_forward_3x3(u, s, [1.0, 1.0, 0.0], vt, x_in);
    let y_k3 = z_forward_3x3(u, s, [1.0, 1.0, 1.0], vt, x_in);
    println("Z-BL Rank Curriculum (k=1 -> k=2 -> k=3) на входе [5, 2, 3]:");
    println(round(y_k1));
    println(round(y_k2));
    println(round(y_k3));
    assert(round(y_k3[0]) == 7);
    assert(round(y_k3[1]) == 8);
    assert(round(y_k3[2]) == 10);

    // Живая память Пророка (.km): обучение -> консолидация (сон EWC-lite) -> сохранение -> проверка
    let mind: Memory = memory_config(5, 128, 64);
    let ep: i64 = 0;
    while ep < 10 {
        let l = train_prophet_epoch(mind);
        if ep % 3 == 0 {
            println(l);
        }
        ep = ep + 1;
    }

    let folded = consolidate(mind);
    println("Консолидировано ядер памяти во сне (EWC-lite):");
    println(folded);
    println("Статистика памяти [episodic, core, locked, steps, dim, hidden]:");
    println(mem_stats(mind));

    let score = eval_prophet_holdout(mind);
    println("Точность Пророка на проверке оракулом [hits, total]:");
    println(score);
    assert(score[0] == score[1]);

    // Сохраняем живой ум на диск и проверяем второй запуск (load_mind)
    let km_path = "minds/kenga_coder_prophet.km";
    save_mind(mind, km_path);
    println("Живой ум сохранён: " + km_path);

    let reloaded: Memory = load_mind(km_path);
    let check_pred = round(predict(reloaded, [6, 1, 7]));
    let check_want = target_oracle(6, 1, 7);
    println("Проверка после load_mind([6, 1, 7]) -> ожидание [7, 1, 6]:");
    println(check_pred);
    assert(check_pred[0] == check_want[0]);
    assert(check_pred[1] == check_want[1]);
    assert(check_pred[2] == check_want[2]);

    println("KENGA NATIVE PROPHET OK");
    return 0;
}