pub trait Skill: Send + Sync {
    fn name(&self) -> &str;
    fn version(&self) -> &str;
    fn capabilities(&self) -> Vec<Capability>;
    fn execute(&self, input: SkillInput) -> Result<SkillOutput, SkillError>;
    fn initialize(&mut self) -> Result<(), SkillError> { Ok(()) }
    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),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SkillInput {
    Text(String),
    Image(Vec<u8>),
    Audio(Vec<f32>),
    Json(serde_json::Value),
    Binary(Vec<u8>),
}

#[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>),
}

#[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>),
}

export_skill!(YourSkillType);

#[no_mangle]
pub unsafe extern "C" fn create_skill() -> *mut std::ffi::c_void {
    let skill = Box::new(YourSkillType::new());
    let boxed: Box<dyn Skill> = skill;
    Box::into_raw(Box::new(boxed)) as *mut std::ffi::c_void
}

pub type CreateSkillFn = unsafe extern "C" fn() -> *mut std::ffi::c_void;

use soul_kernel_skill_abi::*;

pub struct MySkill;

impl MySkill {
    pub fn new() -> Self {
        Self
    }
}

impl Skill for MySkill {
    fn name(&self) -> &str {
        "my-skill"
    }
    
    fn version(&self) -> &str {
        "1.0.0"
    }
    
    fn capabilities(&self) -> Vec<Capability> {
        vec![Capability::TextProcessing]
    }
    
    fn execute(&self, input: SkillInput) -> Result<SkillOutput, SkillError> {
        match input {
            SkillInput::Text(text) => {
                Ok(SkillOutput::Text(text.to_uppercase()))
            }
            _ => Err(SkillError::InvalidInput("Expected text".to_string()))
        }
    }
}

export_skill!(MySkill);

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

[dependencies]
soul-kernel-skill-abi = "0.1"