src/bin/biophys_app.rs

// 🌌 BioPhys v5.0 마스터 대화형 앱 + 자가회귀 생성(LLM) + 동적 RAG 통합 (src/bin/biophys_app.rs)
#[path="../dynamic_knowledge_rag.rs"] mod dynamic_knowledge_rag;
#[path="../generative_llm.rs"] mod generative_llm;
#[path="../korean_telemetry.rs"] mod korean_telemetry;
#[path="../parallel_engine.rs"] mod parallel_engine;

use std::io::{self, Write};
use std::time::Instant;
use dynamic_knowledge_rag::DynamicKnowledgeRAG;
use generative_llm::{GenerativeEngine, GenerativeContext, GenerationMode};
use parallel_engine::LargeScaleEngine;
use korean_telemetry::TelemetryReporter;

pub struct BioPhysMasterApp {
    rag: DynamicKnowledgeRAG,
    engine: LargeScaleEngine,
}

impl BioPhysMasterApp {
    pub fn new() -> Self {
        BioPhysMasterApp {
            rag: DynamicKnowledgeRAG::new("knowledge_corpus"),
            engine: LargeScaleEngine::new(256),
        }
    }

    pub fn render_header(&self) {
        println!("╔════════════════════════════════════════════════════════════════════════════╗");
        println!("║                 🌌 BioPhys v5.0 Master Generative & RAG Desktop App        ║");
        println!("║            Rust Native Autoregressive LLM + Dynamic Open-World Engine      ║");
        println!("╠════════════════════════════════════════════════════════════════════════════╣");
        println!("║  [모드 1] 💻 자유 코드 생성: '파이썬 웹서버 코드 짜줘', 'Rust 비동기 코드'   ║");
        println!("║  [모드 2] 🖋️ 창의 문학 창작: '우주와 AI에 관한 단편 소설 써줘'              ║");
        println!("║  [모드 3] 🌐 동적 지식 주입: '학습 [분야] | [제목] | [내용]' (무컴파일 RAG) ║");
        println!("║  [모드 4] 💬 전 학제 질의  : 질문을 자유롭게 입력 시 실시간 RAG 검색 & 답변║");
        println!("║  • 종료 방법: 'q' 또는 'exit' 입력                                         ║");
        println!("╚════════════════════════════════════════════════════════════════════════════╝\n");
    }

    pub fn process_input(&mut self, prompt: &str) {
        let trimmed = prompt.trim();
        if trimmed.is_empty() { return; }

        let t_start = Instant::now();

        // 1. 실시간 동적 지식 주입 명령어 처리 (ex: 학습 양자IT | QuantumX-9000 | 스펙설명)
        if trimmed.starts_with("학습") {
            let rest = trimmed.trim_start_matches("학습").trim();
            let parts: Vec<&str> = rest.split('|').map(|s| s.trim()).collect();
            if parts.len() >= 3 {
                self.rag.ingest_new_knowledge(parts[0], parts[1], parts[2]);
                println!("┌────────────────────────────────────────────────────────────────────────────");
                println!("│ ✅ [동적 지식 실시간 주입 완료! (컴파일 불필요)]");
                println!("│    ├─ 분야: [{}]", parts[0]);
                println!("│    ├─ 제목: 《 {} 》", parts[1]);
                println!("│    └─ 내용: {}", parts[2]);
                println!("│ 📁 코퍼스 저장: knowledge_corpus/world_knowledge_2026.jsonl (총 {}건 문서)", self.rag.documents.len());
                println!("└────────────────────────────────────────────────────────────────────────────\n");
                return;
            } else {
                println!("💡 [사용법 안내]: 학습 [분야] | [제목] | [상세 내용] 형식으로 입력하세요.\n");
                return;
            }
        }

        // 2. 모드 판별 및 시맨틱 RAG 검색
        let mode = GenerativeEngine::detect_mode(trimmed);
        let search_results = self.rag.search_documents(trimmed, 3);
        let retrieved_docs = search_results.into_iter().map(|(d, _)| d.clone()).collect();

        // 3. 256x256 격자 동역학 연산
        let prompt_energy: f32 = trimmed.bytes().map(|b| b as f32).sum::<f32>() / 1000.0;
        for b in self.engine.bedrock.iter_mut() {
            *b = (*b * 0.5) + (prompt_energy.sin() * 0.5);
        }
        let avg_e = self.engine.step_parallel();

        let temperature = match mode {
            GenerationMode::CodeGeneration => 0.2,
            GenerationMode::CreativeWriting => 0.8,
            GenerationMode::AnalyticalDialogue => 0.4,
        };

        let ctx = GenerativeContext {
            prompt: trimmed.to_string(),
            retrieved_docs,
            temperature,
            mode,
        };

        let generated_text = GenerativeEngine::generate_response(&ctx, avg_e);
        let dur = t_start.elapsed().as_secs_f64() * 1000.0;

        println!("┌────────────────────────────────────────────────────────────────────────────");
        println!("│ 🗣️ [사용자 입력]: \"{}\"", trimmed);
        println!("│ 🎯 [판별 모드]: {:?}", mode);
        println!("│");
        for line in generated_text.lines() {
            println!("│   {}", line);
        }
        println!("│");
        println!("│ ⏱️ [자가회귀 & RAG 생성 지연시간]: {:.3} ms | 물리 계면 에너지: {:.4}", dur, avg_e);
        println!("└────────────────────────────────────────────────────────────────────────────\n");
    }

    pub fn render_2d_lattice(&mut self) {
        println!("┌────────────────────────────────────────────────────────────────────────────");
        println!("│ ⚡ [256x256 복잡계 8대 위상 격자 실시간 2D 맵]");
        println!("│    범례: [▲▲]과흥분  [▲]흥분  [·]휴지기  [▼]억제  [▼▼]과억제\n│");
        
        for y in 0..4 {
            print!("│    ");
            for x in 0..18 {
                let state = self.engine.topsoil[y * 256 + x];
                let symbol = match state.value() {
                    v if v >= 1.5 => "▲▲",
                    v if v > 0.0 => "▲ ",
                    0.0 => "· ",
                    v if v <= -1.5 => "▼▼",
                    _ => "▼ ",
                };
                print!("{} ", symbol);
            }
            println!();
        }
        println!("│\n│ ✅ 65,536개 시냅스 전 노드 정상 평형 실시간 동기화 완료");
        println!("└────────────────────────────────────────────────────────────────────────────\n");
    }
}

fn main() {
    let mut app = BioPhysMasterApp::new();
    app.render_header();

    println!("============================================================");
    println!(" 💬 실시간 대화형 프롬프트 활성화 (질문 / 코드 요청 / 소설 요청 / '학습' 입력)");
    println!("============================================================\n");

    let stdin = io::stdin();
    let mut buffer = String::new();

    loop {
        print!("BioPhys 💬 입력 > ");
        let _ = io::stdout().flush();
        buffer.clear();

        if stdin.read_line(&mut buffer).is_err() { break; }
        let trimmed = buffer.trim();

        if trimmed == "q" || trimmed == "exit" || trimmed == "quit" {
            println!("\n👋 BioPhys 앱을 종료합니다. 엔터를 누르면 창이 닫힙니다.");
            let _ = stdin.read_line(&mut buffer);
            break;
        }

        if !trimmed.is_empty() {
            app.process_input(trimmed);
            app.render_2d_lattice();
        }
    }
}