// Claude Desktop — Tauri Backend
// Hauptmodul für die Rust-Seite der App

use std::sync::{Arc, Mutex};
use tauri::Manager;

mod audit;
mod claude;
mod db;
mod guard;
mod memory;
mod session;

/// Initialisiert die App
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .manage(Arc::new(Mutex::new(claude::ClaudeState::default())))
        .manage(guard::GuardState::new(Mutex::new(guard::GuardRails::new())))
        .invoke_handler(tauri::generate_handler![
            // Claude SDK
            claude::send_message,
            claude::stop_all_agents,
            claude::get_agent_status,
            claude::set_model,
            claude::get_available_models,
            claude::get_current_model,
            // Gedächtnis-System
            memory::load_memory,
            memory::get_sticky_context,
            memory::save_pattern,
            memory::detect_issue,
            // Audit-Log
            audit::get_audit_log,
            audit::add_audit_entry,
            audit::get_audit_stats,
            // Guard-Rails
            guard::check_action,
            guard::add_permission,
            guard::remove_permission,
            guard::get_permissions,
            guard::get_blocked_patterns,
            // Datenbank
            db::init_database,
            db::get_db_stats,
            // Settings
            db::get_setting,
            db::set_setting,
            db::get_all_settings,
            // Sessions
            session::create_session,
            session::update_session,
            session::list_sessions,
            session::get_session,
            session::delete_session,
            session::resume_session,
            session::get_active_session,
            session::set_claude_session_id,
            // Messages
            db::save_message,
            db::load_messages,
            db::clear_messages,
        ])
        .setup(|app| {
            let handle = app.handle().clone();

            println!("🤖 Claude Desktop gestartet");

            // Datenbank initialisieren
            let app_dir = app.path().app_data_dir()
                .expect("Konnte App-Datenverzeichnis nicht ermitteln");
            std::fs::create_dir_all(&app_dir).ok();
            let db_path = app_dir.join("claude-desktop.db");
            println!("📦 Datenbank: {:?}", db_path);

            let db = db::Database::open(&db_path)
                .expect("Datenbank konnte nicht geöffnet werden");
            app.manage(Arc::new(Mutex::new(db)));

            // Guard-Rails: permanente Permissions aus DB laden
            {
                let db_state = handle.state::<Arc<Mutex<db::Database>>>();
                let guard_state = handle.state::<guard::GuardState>();
                let db_lock = db_state.lock().unwrap();
                let mut guard_lock = guard_state.lock().unwrap();
                if let Ok(perms) = db_lock.load_permissions() {
                    for p in perms {
                        guard_lock.add_permission(p);
                    }
                    println!("🛡️ {} permanente Permissions geladen", guard_lock.get_all_permissions().len());
                }
            }

            // Gedächtnis-System laden
            tauri::async_runtime::spawn(async move {
                println!("🧠 Initialisiere Gedächtnis-System...");
            });

            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("Fehler beim Starten der App");
}