src/dynamic_knowledge_rag.rs

// 🌌 [블랙홀 사건의 지평선 홀로그래픽 RAG] (src/dynamic_knowledge_rag.rs)
// 이론 기반: 베켄슈타인-호킹 정보 한계(Bekenstein Bound) & 't Hooft-Susskind 홀로그래픽 원리
use std::fs::{self, File, OpenOptions};
use std::io::{BufRead, BufReader, Write};
use std::path::Path;

#[derive(Clone, Debug)]
pub struct DynamicDocument {
    pub id: usize,
    pub title: String,
    pub category: String,
    pub content: String,
    pub horizon_x: u8,       // 256x256 사건의 지평선 2D X 좌표
    pub horizon_y: u8,       // 256x256 사건의 지평선 2D Y 좌표
    pub hawking_mass: f32,   // 중력 포텐셜 질량 (정보 밀도)
    pub keywords: Vec<String>,
}

pub struct DynamicKnowledgeRAG {
    pub documents: Vec<DynamicDocument>,
    pub corpus_dir: String,
    pub horizon_grid: [[f32; 256]; 256], // 2D 사건의 지평선 중력 곡률 텐서
}

impl DynamicKnowledgeRAG {
    pub fn new(corpus_dir: &str) -> Self {
        let mut rag = DynamicKnowledgeRAG {
            documents: Vec::new(),
            corpus_dir: corpus_dir.to_string(),
            horizon_grid: [[0.0; 256]; 256],
        };

        if !Path::new(corpus_dir).exists() {
            let _ = fs::create_dir_all(corpus_dir);
        }

        rag.initialize_default_corpus();
        rag.reload_all_documents();
        rag
    }

    fn initialize_default_corpus(&self) {
        let sample_file = format!("{}/world_knowledge_2026.jsonl", self.corpus_dir);
        if !Path::new(&sample_file).exists() {
            if let Ok(mut f) = File::create(&sample_file) {
                let initial_data = r#"{"id":1,"category":"최신IT","title":"2026 차세대 양자-광학 AI 가속기 QuantumX-9000","content":"QuantumX-9000은 2026년 출시된 세계 최초의 상온 실리콘 포토닉스 기반 양자 간섭 가속기로, 테라플롭스당 0.05W의 극저전력을 소모하며 1.58비트 연산 전용 광학 텐서 코어를 내장함."}
{"id":2,"category":"우주탐사","title":"2026 아르테미스 3호 유인 달 착륙 및 영구 기지 건설","content":"2026년 인류는 50여 년 만에 달 남극 에이컨 분지에 유인 착륙하여 얼음 수자원을 채굴하고 영구적인 유인 연구 기지 아르테미스 베이스캠프를 공식 가동함."}
{"id":3,"category":"생명공학","title":"2026 나노로봇 기반 표적 암세포 직접 제거 임상 성공","content":"2026년 혈관을 타고 이동하며 특정 암세포 표면 항원만을 감지해 정확히 파괴하는 자율 유도 DNA 오리가미 나노로봇의 3상 임상 시험이 세계 최초로 승인됨."}
"#;
                let _ = f.write_all(initial_data.as_bytes());
            }
        }
    }

    pub fn reload_all_documents(&mut self) {
        self.documents.clear();
        self.horizon_grid = [[0.0; 256]; 256];

        if let Ok(entries) = fs::read_dir(&self.corpus_dir) {
            for entry in entries.flatten() {
                let path = entry.path();
                if path.extension().and_then(|s| s.to_str()) == Some("jsonl") {
                    if let Ok(file) = File::open(&path) {
                        let reader = BufReader::new(file);
                        for line in reader.lines().flatten() {
                            if line.trim().is_empty() { continue; }
                            if let Some(mut doc) = self.parse_jsonl_line(&line) {
                                // 홀로그래픽 사건의 지평선 2D 좌표 투영
                                let (hx, hy, mass) = Self::compute_holographic_projection(&doc.title, &doc.content);
                                doc.horizon_x = hx;
                                doc.horizon_y = hy;
                                doc.hawking_mass = mass;
                                self.horizon_grid[hy as usize][hx as usize] += mass;
                                self.documents.push(doc);
                            }
                        }
                    }
                }
            }
        }
    }

    /// [홀로그래픽 투영]: 고차원 텍스트를 2D 지평선 256x256 좌표와 호킹 중력 곡률로 투영
    fn compute_holographic_projection(title: &str, content: &str) -> (u8, u8, f32) {
        let mut hx: u32 = 0;
        let mut hy: u32 = 0;
        for (i, b) in title.bytes().enumerate() {
            hx = (hx * 31 + b as u32 + i as u32) % 256;
        }
        for (i, b) in content.bytes().enumerate() {
            hy = (hy * 37 + b as u32 + (i * 7) as u32) % 256;
        }
        let mass = (content.len() as f32).ln().max(1.0);
        (hx as u8, hy as u8, mass)
    }

    fn parse_jsonl_line(&self, line: &str) -> Option<DynamicDocument> {
        let get_val = |key: &str| -> String {
            if let Some(pos) = line.find(&format!("\"{}\":", key)) {
                let rest = &line[pos + key.len() + 3..];
                if rest.starts_with('"') {
                    if let Some(end) = rest[1..].find('"') {
                        return rest[1..1 + end].to_string();
                    }
                } else if let Some(end) = rest.find(|c: char| c == ',' || c == '}') {
                    return rest[..end].trim().to_string();
                }
            }
            String::new()
        };

        let title = get_val("title");
        let category = get_val("category");
        let content = get_val("content");
        let id_str = get_val("id");
        let id = id_str.parse::<usize>().unwrap_or(self.documents.len() + 1);

        if !title.is_empty() && !content.is_empty() {
            let mut keywords = Vec::new();
            for word in content.split_whitespace().chain(title.split_whitespace()) {
                let clean: String = word.chars().filter(|c| c.is_alphanumeric()).collect();
                if clean.len() >= 2 {
                    keywords.push(clean.to_lowercase());
                }
            }
            Some(DynamicDocument { id, title, category, content, horizon_x: 0, horizon_y: 0, hawking_mass: 1.0, keywords })
        } else {
            None
        }
    }

    /// [실시간 지식 주입]: 사건의 지평선에 즉시 블랙홀 중력 우물 형성
    pub fn ingest_new_knowledge(&mut self, category: &str, title: &str, content: &str) {
        let doc_id = self.documents.len() + 1;
        let (hx, hy, mass) = Self::compute_holographic_projection(title, content);
        let mut keywords = Vec::new();
        for word in content.split_whitespace().chain(title.split_whitespace()) {
            let clean: String = word.chars().filter(|c| c.is_alphanumeric()).collect();
            if clean.len() >= 2 {
                keywords.push(clean.to_lowercase());
            }
        }
        let doc = DynamicDocument {
            id: doc_id,
            title: title.to_string(),
            category: category.to_string(),
            content: content.to_string(),
            horizon_x: hx,
            horizon_y: hy,
            hawking_mass: mass,
            keywords,
        };
        self.horizon_grid[hy as usize][hx as usize] += mass;
        self.documents.push(doc.clone());

        let sample_file = format!("{}/world_knowledge_2026.jsonl", self.corpus_dir);
        if let Ok(mut f) = OpenOptions::new().create(true).append(true).open(&sample_file) {
            let line = format!("{{\"id\":{},\"category\":\"{}\",\"title\":\"{}\",\"content\":\"{}\"}}\n", doc_id, category, title, content);
            let _ = f.write_all(line.as_bytes());
        }
    }

    /// [블랙홀 중력 포텐셜 측지선 검색 (Holographic Geodesic RAG)]:
    /// 질의가 시공간 지평선에 던져졌을 때, 가장 강한 중력 우물(Singularity Well)로 빨려 들어가는 문서를 즉시 인출!
    pub fn search_documents(&self, query: &str, top_k: usize) -> Vec<(&DynamicDocument, f32)> {
        let (qx, qy, _qmass) = Self::compute_holographic_projection(query, query);
        let query_lower = query.to_lowercase();
        let query_words: Vec<String> = query_lower
            .split_whitespace()
            .map(|w| w.chars().filter(|c| c.is_alphanumeric()).collect())
            .filter(|w: &String| w.len() >= 2)
            .collect();

        let mut scored: Vec<(&DynamicDocument, f32)> = self.documents.iter().map(|doc| {
            // 1. 사건의 지평선 2D 공간 거리 (측지선 인력)
            let dx = (doc.horizon_x as f32 - qx as f32).abs();
            let dy = (doc.horizon_y as f32 - qy as f32).abs();
            let dist_sq = dx * dx + dy * dy + 1.0;
            let gravitational_pull = (doc.hawking_mass * 100.0) / dist_sq;

            // 2. 의미론적 키워드 공명
            let mut semantic_score: f32 = 0.0;
            if doc.title.to_lowercase().contains(&query_lower) {
                semantic_score += 20.0;
            }
            for qw in &query_words {
                if doc.title.to_lowercase().contains(qw) {
                    semantic_score += 10.0;
                }
                if doc.content.to_lowercase().contains(qw) {
                    semantic_score += 5.0;
                }
            }

            let total_score = gravitational_pull * 0.3 + semantic_score * 0.7;
            (doc, total_score)
        }).filter(|(_, score)| *score > 0.0).collect();

        scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
        scored.truncate(top_k);
        scored
    }
}