// src-tauri/src/commands/window/debug.rs

/// 日志条目
#[derive(Debug, Clone, Serialize)]
pub struct LogEntry {
    pub timestamp: String,   // HH:mm:ss 格式，chrono::Local 生成
    pub level: String,       // "log" | "warn" | "error"
    pub message: String,     // 日志正文
}

use std::sync::{Mutex, OnceLock};

/// 全局日志缓冲区（最近 1000 条），调试窗口启动时加载历史日志
static LOG_BUFFER: OnceLock<Mutex<Vec<LogEntry>>> = OnceLock::new();

fn log_buffer() -> &'static Mutex<Vec<LogEntry>> {
    LOG_BUFFER.get_or_init(|| Mutex::new(Vec::with_capacity(1000)))
}

/// 接收前端日志并广播到调试窗口
///
/// 所有窗口（包括独立窗口）的 console.log/warn/error 都会通过此命令
/// 汇聚到全局日志缓冲区，并实时广播给调试窗口。
#[tauri::command]
pub async fn log_message(app: AppHandle, level: String, message: String) -> Result<(), String> {
    let entry = LogEntry {
        timestamp: Local::now().format("%H:%M:%S").to_string(),
        level,
        message,
    };

    {
        let buffer = log_buffer();
        let mut logs = buffer.lock().map_err(|e| e.to_string())?;
        if logs.len() >= 1000 {
            logs.remove(0);           // FIFO：移除最早日志
        }
        logs.push(entry.clone());
    }

    // 广播到所有窗口（调试窗口监听此事件实时展示日志）
    let _ = app.emit("debug-log", &entry);

    Ok(())
}

/// 获取所有已缓存的日志（调试窗口启动时加载历史日志）
#[tauri::command]
pub async fn get_debug_logs() -> Result<Vec<LogEntry>, String> {
    let buffer = log_buffer();
    let logs = buffer.lock().map_err(|e| e.to_string())?;
    Ok(logs.clone())
}

/// 清空所有缓存的日志
#[tauri::command]
pub async fn clear_debug_logs() -> Result<(), String> {
    let buffer = log_buffer();
    let mut logs = buffer.lock().map_err(|e| e.to_string())?;
    logs.clear();
    Ok(())
}

// 在 Rust 命令中记录自定义日志到调试控制台
use tauri::AppHandle;

#[tauri::command]
pub async fn some_business_logic(app: AppHandle, data: String) -> Result<(), String> {
    // 业务逻辑...
    println!("[Rust] 处理数据: {}", data);  // 打印到 Rust stdout（终端可见）

    // 发送日志到前端调试控制台（通过调用自身的 log_message 命令）
    // 注意：需要把 AppHandle 传下来，或使用 app.state::<AppDb>() 等

    Ok(())
}

#[tauri::command]
pub async fn log_message(app: AppHandle, level: String, message: String) -> Result<(), String> {
    // 同时输出到 Rust stdout（终端可见）
    match level.as_str() {
        "warn" => eprintln!("[WARN] {}", message),
        "error" => eprintln!("[ERROR] {}", message),
        _ => println!("[INFO] {}", message),
    }

    let entry = LogEntry {
        timestamp: Local::now().format("%H:%M:%S").to_string(),
        level,
        message,
    };
    // ... 写入缓冲区 + emit
    Ok(())
}

use tauri::{AppHandle, Emitter};
use chrono::Local;

// 假设在某个命令中需要记录业务日志
pub async fn do_something_complex(app: AppHandle, param: String) -> Result<String, String> {
    // 开始处理
    let entry = LogEntry {
        timestamp: Local::now().format("%H:%M:%S").to_string(),
        level: "log".to_string(),
        message: format!("开始处理: param={}", param),
    };

    // 写入全局缓冲区
    {
        let buffer = log_buffer();
        let mut logs = buffer.lock().map_err(|e| e.to_string())?;
        if logs.len() >= 1000 { logs.remove(0); }
        logs.push(entry.clone());
    }

    // 广播到调试窗口
    let _ = app.emit("debug-log", &entry);

    // 继续业务逻辑...
    match process(&param) {
        Ok(result) => {
            // 成功日志
            let entry = LogEntry {
                timestamp: Local::now().format("%H:%M:%S").to_string(),
                level: "log".to_string(),
                message: format!("处理完成: {}", result),
            };
            // ... (同样的写入 + emit)
            Ok(result)
        }
        Err(e) => {
            // 错误日志
            let entry = LogEntry {
                timestamp: Local::now().format("%H:%M:%S").to_string(),
                level: "error".to_string(),
                message: format!("处理失败: {}", e),
            };
            // ... (同样的写入 + emit)
            Err(e.to_string())
        }
    }
}

// 在 window/debug.rs 中封装一个便捷函数
use tauri::{AppHandle, Emitter};
use chrono::Local;

/// 从 Rust 侧发送一条日志到前端调试控制台
pub fn rust_log(app: &AppHandle, level: &str, message: &str) {
    let entry = LogEntry {
        timestamp: Local::now().format("%H:%M:%S").to_string(),
        level: level.to_string(),
        message: message.to_string(),
    };

    // 写入缓冲区
    if let Ok(mut logs) = log_buffer().lock() {
        if logs.len() >= 1000 { logs.remove(0); }
        logs.push(entry.clone());
    }

    // 广播事件
    let _ = app.emit("debug-log", &entry);
}

// ── 在任意命令中使用 ──
#[tauri::command]
pub async fn process_data(app: AppHandle, data: String) -> Result<(), String> {
    rust_log(&app, "log", &format!("收到数据: {}", data));

    match heavy_computation(&data) {
        Ok(result) => {
            rust_log(&app, "log", &format!("计算完成: {}", result));
            Ok(())
        }
        Err(e) => {
            rust_log(&app, "error", &format!("计算失败: {}", e));
            Err(e)
        }
    }
}

// src-tauri/src/lib.rs — setup() 中
if let Some(main) = app.get_webview_window("main") {
    let handle = app.handle().clone();
    main.on_window_event(move |event| {
        if let tauri::WindowEvent::Destroyed = event {
            // 主窗口关闭 → 关闭调试窗口
            if let Some(debug) = handle.get_webview_window("debug") {
                let _ = debug.close();
            }
        }
    });
}

// 检测调试窗口关闭，发送事件到 main 窗口复位按钮
w.on_window_event(move |event| {
    if let tauri::WindowEvent::Destroyed = event {
        let _ = main.emit("debug-window-closed", ());
    }
});

static LOG_BUFFER: OnceLock<Mutex<Vec<LogEntry>>> = OnceLock::new();

fn log_buffer() -> &'static Mutex<Vec<LogEntry>> {
    // 将 1000 改为所需容量
    LOG_BUFFER.get_or_init(|| Mutex::new(Vec::with_capacity(2000)))
}