/// Core trait that all Skills must implement
pub trait Skill: Send + Sync {
    /// Unique name of the skill
    fn name(&self) -> &str;
    
    /// Semantic version of the skill
    fn version(&self) -> &str;
    
    /// List of capabilities this skill provides
    fn capabilities(&self) -> Vec<Capability>;
    
    /// Execute the skill with given input
    fn execute(&self, input: SkillInput) -> Result<SkillOutput, SkillError>;
    
    /// Initialize the skill (optional)
    fn initialize(&mut self) -> Result<(), SkillError> {
        Ok(())
    }
    
    /// Shutdown the skill (optional)
    fn shutdown(&mut self) -> Result<(), SkillError> {
        Ok(())
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Capability {
    TextProcessing,
    ImageProcessing,
    AudioProcessing,
    VoiceSynthesis,
    VisionAnalysis,
    MotorControl,
    DataStorage,
    NetworkAccess,
    Custom(String),
}

/// Input types that can be passed to skills
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SkillInput {
    Text(String),
    Image(Vec<u8>),
    Audio(Vec<f32>),
    Json(serde_json::Value),
    Binary(Vec<u8>),
}

/// Output types that skills can return
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SkillOutput {
    Text(String),
    Image(Vec<u8>),
    Audio(Vec<f32>),
    Json(serde_json::Value),
    Action(ActionCommand),
    Binary(Vec<u8>),
}

/// Commands for actuator control
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionCommand {
    pub target: String,
    pub action: String,
    pub parameters: serde_json::Value,
}

#[derive(Debug)]
pub enum SkillError {
    InvalidInput(String),
    ExecutionError(String),
    NotImplemented(String),
    ResourceUnavailable(String),
    Custom(Box<dyn Error + Send + Sync>),
}

// hello_skill/src/lib.rs
use soul_kernel_skill_abi::{
    export_skill, Capability, Skill, SkillError, SkillInput, SkillOutput,
};

pub struct HelloSkill {
    greeting: String,
}

impl HelloSkill {
    pub fn new() -> Self {
        Self {
            greeting: "Hello from Soul Kernel!".to_string(),
        }
    }
}

impl Skill for HelloSkill {
    fn name(&self) -> &str {
        "hello"
    }

    fn version(&self) -> &str {
        env!("CARGO_PKG_VERSION")
    }

    fn capabilities(&self) -> Vec<Capability> {
        vec![Capability::TextProcessing]
    }

    fn execute(&self, input: SkillInput) -> Result<SkillOutput, SkillError> {
        match input {
            SkillInput::Text(name) => {
                let response = if name.is_empty() {
                    self.greeting.clone()
                } else {
                    format!("{} Nice to meet you, {}!", self.greeting, name)
                };
                Ok(SkillOutput::Text(response))
            }
            _ => Err(SkillError::InvalidInput(
                "Hello skill expects text input".to_string(),
            )),
        }
    }
}

// Export the skill for dynamic loading
export_skill!(HelloSkill);

[package]
name = "hello-skill"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
soul-kernel-skill-abi = { path = "../skill-abi" }
serde = { version = "1.0", features = ["derive"] }

# Build as dynamic library
cargo build --release

# The skill will be available as a .dylib/.so/.dll file
ls target/release/libhello_skill.dylib

use soul_kernel_core::SkillRegistry;

// Create registry
let registry = SkillRegistry::new();

// Load skill from dynamic library
let skill_id = registry.load_skill_from_library("./libhello_skill.dylib")?;

// Execute skill
let input = SkillInput::Text("Alice".to_string());
let output = registry.execute_skill(&skill_id, input)?;

// List loaded skills
for (name, version) in registry.list_skills() {
    println!("Loaded: {} v{}", name, version);
}

// Unload skill when done
registry.unload_skill(&skill_id)?;

impl Skill for EchoSkill {
    fn capabilities(&self) -> Vec<Capability> {
        vec![
            Capability::TextProcessing,
            Capability::ImageProcessing,
            Capability::AudioProcessing,
        ]
    }

    fn execute(&self, input: SkillInput) -> Result<SkillOutput, SkillError> {
        // Echo skill simply returns the input unchanged
        match input {
            SkillInput::Text(text) => Ok(SkillOutput::Text(text)),
            SkillInput::Image(data) => Ok(SkillOutput::Image(data)),
            SkillInput::Audio(data) => Ok(SkillOutput::Audio(data)),
            SkillInput::Json(json) => Ok(SkillOutput::Json(json)),
            SkillInput::Binary(data) => Ok(SkillOutput::Binary(data)),
        }
    }
}

let skill = Box::new(MyBuiltInSkill::new());
let skill_id = registry.register_skill(skill);

Ok(SkillOutput::Action(ActionCommand {
    target: "arm".to_string(),
    action: "wave".to_string(),
    parameters: json!({
        "duration": 2.0,
        "amplitude": 0.5
    }),
}))

// Planned feature for composing multiple skills
let composite = SkillComposer::new()
    .add("vision")
    .add("language")
    .add("voice")
    .build();