use paramdef::prelude::*;

let schema = Schema::new()
    .with(Text::builder("name")
        .label("Name")
        .required()
        .min_length(1)
        .build())
    
    .with(Number::builder::<f64>("opacity")
        .label("Opacity")
        .subtype(NumberSubtype::Factor)
        .range(0.0, 1.0)
        .default(1.0)
        .build())
    
    .with(Select::builder("method")
        .label("Method")
        .option("GET", "GET")
        .option("POST", "POST")
        .default("GET")
        .build());

let mut context = Context::new(schema);

// Set values
context.set_value("name", Value::Text("Hello".into()))?;
context.set_value("opacity", Value::Float(0.5))?;

// Get values
let name: String = context.get_string("name")?;
let opacity: f64 = context.get_float("opacity")?;

// Validate
if context.validate_all().await.is_ok() {
    println!("All valid!");
}

// Type-safe builders
let schema = Schema::builder()
    .add(Text::builder("username").required().build())
    .add(Number::builder::<i64>("age").range(0, 150).build())
    .build();

// Type-safe getters
let name: &str = context.get_string("username")?;
let age: i64 = context.get_int("age")?;

Number::builder::<f64>("height")
    .subtype(NumberSubtype::Distance)  // WHAT it is
    .unit(NumberUnit::Length)          // HOW to measure
    .build()

// American user sees: "5.9 ft"
// European user sees: "1.8 m"
// Stored as: 1.8 (meters)

Mode::builder("auth")
    .variant("none", "No Auth", Schema::empty())
    .variant("basic", "Basic", Schema::new()
        .with(username_param)
        .with(password_param))
    .variant("oauth", "OAuth", Schema::new()
        .with(client_id_param)
        .with(client_secret_param))
    .build()

Number::builder::<f64>("angle")
    .transformer(RoundTransformer { step: 15.0 })
    .transformer(ModuloTransformer { modulo: 360.0 })
    .build()

// Input: 373.0 -> Round: 375.0 -> Modulo: 15.0

Text::builder("api_key")
    .subtype(TextSubtype::Secret)
    .flags(Flags::SENSITIVE | Flags::WRITE_ONLY | Flags::SKIP_SAVE)
    .build()

// Or use convenience methods:
Text::builder("api_key")
    .subtype(TextSubtype::Secret)
    .sensitive()
    .write_only()
    .skip_save()
    .build()

Text::builder("email")
    .subtype(TextSubtype::Email)  // Built-in validation
    .required()
    .async_validator(Arc::new(EmailExistsValidator::new(db)))
    .build()

use Expr::*;

Text::builder("ssl_cert")
    .visible_when(Eq("protocol".into(), Value::text("https")))
    .build()

// Schema is immutable, shareable
let schema = Arc::new(Schema::new()
    .with(Text::builder("name").build())
);

// Context holds mutable state
let mut context_a = Context::new(schema.clone());
let mut context_b = Context::new(schema.clone());

// Same schema, different values!
context_a.set_value("name", "Alice".into())?;
context_b.set_value("name", "Bob".into())?;