use kizzasi::prelude::*;

fn main() -> KizzasiResult<()> {
    // Configure predictor with Mamba2 backend
    let config = KizzasiConfig::new()
        .model_type(ModelType::Mamba2)
        .input_dim(3)
        .output_dim(3)
        .hidden_dim(256)
        .state_dim(16)
        .num_layers(4)
        .context_window(8192);

    let mut predictor = Kizzasi::new(config)?;

    // Single step prediction (O(1) complexity)
    let input = array![0.1, 0.2, 0.3];
    let output = predictor.step(&input)?;

    println!("Predicted: {:?}", output);
    Ok(())
}

use kizzasi::prelude::*;

fn main() -> KizzasiResult<()> {
    let config = KizzasiConfig::new()
        .model_type(ModelType::Rwkv)
        .input_dim(3)
        .output_dim(3);

    let mut predictor = Kizzasi::new(config)?;

    // Define safety constraints
    let guardrails = GuardrailSet::new()
        .add(Guardrail::new(
            ConstraintBuilder::new()
                .name("velocity_limit")
                .bound(0, BoundType::Range(-1.0, 1.0))  // Clamp to [-1, 1]
                .bound(1, BoundType::LessThan(100.0))   // Max value < 100
                .build()?
        ))
        .add(Guardrail::new(
            ConstraintBuilder::new()
                .name("rate_limit")
                .rate_limit(0.1)  // Max change per step
                .build()?
        ));

    predictor.set_guardrails(guardrails);

    // Predictions automatically satisfy constraints
    let input = array![0.5, 0.5, 0.5];
    let safe_output = predictor.step(&input)?;

    Ok(())
}

use kizzasi::prelude::*;

fn main() -> KizzasiResult<()> {
    // Use audio preset for optimized configuration
    let config = KizzasiConfig::audio_preset()
        .sample_rate(44100.0);

    let mut predictor = Kizzasi::new(config)?;

    // Stream from microphone
    let audio_config = AudioConfig::new()
        .sample_rate(44100)
        .channels(1)
        .buffer_size(1024);

    let mut audio = AudioInput::new(audio_config)?;
    audio.start()?;

    loop {
        let buffer = audio.read()?;
        for sample in buffer.iter() {
            let prediction = predictor.step(&array![*sample])?;
            // Use prediction for audio effect, anomaly detection, etc.
        }
    }
}

use kizzasi::prelude::*;

fn main() -> KizzasiResult<()> {
    let config = KizzasiConfig::new()
        .model_type(ModelType::S4D)
        .input_dim(6)
        .output_dim(6);

    let mut predictor = Kizzasi::new(config)?;

    // Predict N steps into the future
    let initial = array![0.0, 0.0, 0.0, 1.0, 0.0, 0.0];
    let trajectory = predictor.predict_n(&initial, 100)?;

    println!("Predicted {} future states", trajectory.len());
    Ok(())
}

// High-performance, long context
ModelType::Mamba2  // Selective SSM with SSD

// Lightweight, embedded systems
ModelType::Rwkv    // Linear attention, minimal state

// Smooth signal dynamics
ModelType::S4D     // HiPPO initialization, diagonal SSM

// Comparison/research
ModelType::Transformer  // Standard attention (O(N) per step)

use kizzasi_logic::{ConstraintAwareLoss, LagrangianRelaxation};

// Combine task loss with constraint violation penalty
let loss = ConstraintAwareLoss::new()
    .task_loss(mse_loss)
    .constraint_loss(guardrails.violation_loss(&prediction))
    .weight(0.1);

// Or use Lagrangian relaxation for adaptive weighting
let relaxation = LagrangianRelaxation::new(guardrails)
    .learning_rate(0.01);

use kizzasi_tokenizer::{VQVAETokenizer, VQConfig};

// Create VQ-VAE tokenizer with 1024 codebook entries
let config = VQConfig::new()
    .codebook_size(1024)
    .embed_dim(256)
    .ema_decay(0.99);

let tokenizer = VQVAETokenizer::new(config)?;

let tokens = tokenizer.encode(&signal)?;
let reconstructed = tokenizer.decode(&tokens)?;

let config = KizzasiConfig::robotics_preset()
    .input_dim(12)   // 6 joint positions + 6 velocities
    .output_dim(6);  // 6 torque commands

let guardrails = GuardrailSet::new()
    .add(joint_limits())      // Physical joint ranges
    .add(velocity_limits())   // Maximum angular velocities
    .add(torque_limits());    // Actuator saturation

let config = KizzasiConfig::sensor_preset()
    .input_dim(32);  // 32 sensor channels

// Train on "normal" operation data
// At runtime, large prediction errors indicate anomalies
let prediction = predictor.step(&sensor_reading)?;
let anomaly_score = (prediction - actual).mapv(|x| x.abs()).sum();

let config = KizzasiConfig::audio_preset()
    .model_type(ModelType::Rwkv);  // Fast, lightweight

// WaveNet-style sample-by-sample generation
let mut predictor = Kizzasi::new(config)?;
for sample in input_audio.iter() {
    let next_sample = predictor.step(&array![*sample])?;
    output_audio.push(next_sample[0]);
}

let config = KizzasiConfig::new()
    .model_type(ModelType::Mamba2)
    .input_dim(1024)   // Frame embedding dimension
    .output_dim(1024);

// Enforce skeleton/pose constraints
let guardrails = GuardrailSet::new()
    .add(bone_length_constraints())
    .add(joint_angle_limits());