use mofa_plugins::{LLMPlugin, LLMPluginConfig, ChatMessage};

// Configure LLM
let llm_config = LLMPluginConfig {
    model: "gpt-4".to_string(),
    max_tokens: 4096,
    temperature: 0.7,
    ..Default::default()
};

// Create and register
let mut llm = LLMPlugin::new("llm_main")
    .with_config(llm_config);

manager.register(llm).await?;

// Use for chat
let messages = vec![
    ChatMessage::system("You are a helpful assistant"),
    ChatMessage::user("What is Rust?"),
];

let response = manager.execute(
    "llm_main",
    serde_json::to_string(&messages)?
).await?;

use mofa_plugins::{StoragePlugin, MemoryStorage};

// Create with in-memory backend
let storage = StoragePlugin::new("storage_main")
    .with_backend(MemoryStorage::new());

manager.register(storage).await?;

// Store data
manager.execute("storage_main", "set user:name Alice".to_string()).await?;
manager.execute("storage_main", "set user:age 30".to_string()).await?;

// Retrieve data
let name = manager.execute("storage_main", "get user:name".to_string()).await?;
let age = manager.execute("storage_main", "get user:age".to_string()).await?;

println!("User: name={}, age={}", name, age);

use mofa_plugins::MemoryPlugin;

let memory = MemoryPlugin::new("memory_main")
    .with_max_memories(1000);

manager.register(memory).await?;

// Add memories with importance scores
manager.execute(
    "memory_main",
    "add User prefers dark mode 0.9".to_string()
).await?;

manager.execute(
    "memory_main",
    "add Last query was about weather 0.6".to_string()
).await?;

// Search memories
let results = manager.execute(
    "memory_main",
    "search weather".to_string()
).await?;

println!("Found memories: {}", results);

use mofa_plugins::{
    AgentPlugin, PluginContext, PluginMetadata, PluginResult,
    PluginState, PluginType, PluginPriority
};
use std::any::Any;
use std::collections::HashMap;

struct MonitorPlugin {
    metadata: PluginMetadata,
    state: PluginState,
    metrics: HashMap<String, f64>,
    alert_threshold: f64,
}

impl MonitorPlugin {
    fn new(plugin_id: &str) -> Self {
        let metadata = PluginMetadata::new(
            plugin_id,
            "Monitor Plugin",
            PluginType::Monitor
        )
        .with_description("System monitoring and alerting plugin")
        .with_capability("metrics")
        .with_capability("alerting")
        .with_priority(PluginPriority::High);

        Self {
            metadata,
            state: PluginState::Unloaded,
            metrics: HashMap::new(),
            alert_threshold: 80.0,
        }
    }

    fn record_metric(&mut self, name: &str, value: f64) {
        self.metrics.insert(name.to_string(), value);
        if value > self.alert_threshold {
            warn!("ALERT: {} exceeded threshold: {} > {}",
                name, value, self.alert_threshold);
        }
    }
}

#[async_trait::async_trait]
impl AgentPlugin for MonitorPlugin {
    fn metadata(&self) -> &PluginMetadata {
        &self.metadata
    }

    fn state(&self) -> PluginState {
        self.state.clone()
    }

    async fn load(&mut self, _ctx: &PluginContext) -> PluginResult<()> {
        self.state = PluginState::Loading;
        info!("Loading Monitor plugin: {}", self.metadata.id);
        self.state = PluginState::Loaded;
        Ok(())
    }

    async fn init_plugin(&mut self) -> PluginResult<()> {
        info!("Initializing Monitor plugin: {}", self.metadata.id);
        // Initialize base metrics
        self.metrics.insert("cpu_usage".to_string(), 0.0);
        self.metrics.insert("memory_usage".to_string(), 0.0);
        Ok(())
    }

    async fn start(&mut self) -> PluginResult<()> {
        self.state = PluginState::Running;
        info!("Monitor plugin {} started", self.metadata.id);
        Ok(())
    }

    async fn stop(&mut self) -> PluginResult<()> {
        self.state = PluginState::Paused;
        info!("Monitor plugin {} stopped", self.metadata.id);
        Ok(())
    }

    async fn unload(&mut self) -> PluginResult<()> {
        self.metrics.clear();
        self.state = PluginState::Unloaded;
        info!("Monitor plugin {} unloaded", self.metadata.id);
        Ok(())
    }

    async fn execute(&mut self, input: String) -> PluginResult<String> {
        let parts: Vec<&str> = input.split_whitespace().collect();
        match parts.as_slice() {
            ["record", name, value] => {
                let v: f64 = value.parse().unwrap_or(0.0);
                self.record_metric(name, v);
                Ok(format!("Recorded {} = {}", name, v))
            }
            ["get", name] => {
                Ok(self.metrics.get(*name)
                    .map(|v| v.to_string())
                    .unwrap_or_else(|| "null".to_string()))
            }
            ["list"] => Ok(serde_json::to_string(&self.metrics)?),
            _ => Err(PluginError::ExecutionFailed(
                "Invalid command".to_string()
            )),
        }
    }

    fn stats(&self) -> HashMap<String, serde_json::Value> {
        let mut stats = HashMap::new();
        stats.insert("metric_count".to_string(),
            serde_json::json!(self.metrics.len()));
        stats.insert("alert_threshold".to_string(),
            serde_json::json!(self.alert_threshold));
        stats
    }

    fn as_any(&self) -> &dyn Any { self }
    fn as_any_mut(&mut self) -> &mut dyn Any { self }
    fn into_any(self: Box<Self>) -> Box<dyn Any> { self }
}