// 🔬 실제 하드웨어 AI 및 텐서 연산 실측 벤치마크 스위트 (src/bin/run_ai_benchmarks.rs)
use std::time::Instant;
use rayon::prelude::*;
use rand::Rng;

fn main() {
    println!("============================================================");
    println!(" 🧪 [실제 로컬 하드웨어] AI 및 복잡계 성능 실측 벤치마크");
    println!("============================================================\n");

    // -------------------------------------------------------------
    // 1. 행렬 곱셈 (Dense MatMul / GFLOPS 측정)
    // -------------------------------------------------------------
    println!("▶ [테스트 1] 표준 신경망 핵심 연산: 1024x1024 FP32 Dense MatMul");
    let n = 1024;
    let mut rng = rand::thread_rng();
    let a: Vec<f32> = (0..n * n).map(|_| rng.gen_range(-1.0..1.0)).collect();
    let b: Vec<f32> = (0..n * n).map(|_| rng.gen_range(-1.0..1.0)).collect();
    let mut c = vec![0.0f32; n * n];

    // 워밍업
    for i in 0..10 {
        c[i] = a[i] * b[i];
    }

    let start = Instant::now();
    // 병렬 타일링 행렬 곱셈
    c.par_chunks_mut(n).enumerate().for_each(|(i, row)| {
        for k in 0..n {
            let a_val = a[i * n + k];
            for j in 0..n {
                row[j] += a_val * b[k * n + j];
            }
        }
    });
    let matmul_time = start.elapsed().as_secs_f64();
    let total_flops = 2.0 * (n as f64) * (n as f64) * (n as f64);
    let gflops = (total_flops / matmul_time) / 1e9;

    println!("   └─ 소요 시간: {:.4} 초 | 실측 연산력: {:.2} GFLOPS\n", matmul_time, gflops);

    // -------------------------------------------------------------
    // 2. 어텐션(Attention) 연산 시퀀스 길이별 레이턴시 측정
    // -------------------------------------------------------------
    println!("▶ [테스트 2] 트랜스포머 Self-Attention O(N^2) 시퀀스별 지연시간");
    let d_head = 64;
    for &seq_len in &[512, 1024, 2048] {
        let q: Vec<f32> = (0..seq_len * d_head).map(|_| rng.gen_range(-1.0..1.0)).collect();
        let k: Vec<f32> = (0..seq_len * d_head).map(|_| rng.gen_range(-1.0..1.0)).collect();
        
        let start_att = Instant::now();
        // Attention Score: Q * K^T (seq_len x seq_len)
        let _scores: Vec<f32> = (0..seq_len).into_par_iter().flat_map(|i| {
            let mut row = vec![0.0f32; seq_len];
            let q_vec = &q[i * d_head..(i + 1) * d_head];
            for j in 0..seq_len {
                let k_vec = &k[j * d_head..(j + 1) * d_head];
                let mut dot = 0.0f32;
                for d in 0..d_head {
                    dot += q_vec[d] * k_vec[d];
                }
                row[j] = dot;
            }
            row
        }).collect();
        let att_dur = start_att.elapsed().as_secs_f64() * 1000.0;
        println!("   └─ 시퀀스 길이 {:4} 토큰: 레이턴시 {:.2} ms", seq_len, att_dur);
    }
    println!();

    // -------------------------------------------------------------
    // 3. BioPhys 8-State 복잡계 엔진 100만 노드 스케일링 측정
    // -------------------------------------------------------------
    println!("▶ [테스트 3] BioPhys 8-State 복잡계 엔진 처리량 (스케일별 실측)");
    for &grid_size in &[256, 512, 1024] {
        let total_nodes = grid_size * grid_size;
        let bedrock: Vec<f32> = vec![0.1f32; total_nodes];
        let mut topsoil: Vec<f32> = vec![0.5f32; total_nodes];

        let start_engine = Instant::now();
        for _ in 0..5 {
            let s = grid_size as i32;
            let next: Vec<f32> = (0..grid_size).into_par_iter().flat_map(|y| {
                let mut row = Vec::with_capacity(grid_size);
                for x in 0..grid_size {
                    let idx = y * grid_size + x;
                    let u = ((y as i32 - 1 + s) % s * s + x as i32) as usize;
                    let d = ((y as i32 + 1) % s * s + x as i32) as usize;
                    let l = (y as i32 * s + (x as i32 - 1 + s) % s) as usize;
                    let r = (y as i32 * s + (x as i32 + 1) % s) as usize;
                    let neighbor_e = (topsoil[u] + topsoil[d] + topsoil[l] + topsoil[r]) * 0.25;
                    row.push(neighbor_e + bedrock[idx]);
                }
                row
            }).collect();
            topsoil = next;
        }
        let dur = start_engine.elapsed().as_secs_f64();
        let updates = (total_nodes as f64 * 5.0) / dur;
        println!("   └─ 격자 {:4}x{:4} ({:7} 노드): 처리량 {:.2} MCell/sec", grid_size, grid_size, total_nodes, updates / 1e6);
    }

    println!("\n============================================================");
    println!(" ✅ 실제 로컬 하드웨어 벤치마크 전 항목 측정 완료");
    println!("============================================================");
}