[dependencies]
rotastellar = "0.1"

cargo add rotastellar

use rotastellar::types::{Position, Orbit, Satellite};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a position (e.g., Kennedy Space Center)
    let pos = Position::new(28.5729, -80.6490, 0.0)?;
    println!("Position: {}, {}", pos.latitude, pos.longitude);

    // Create an ISS-like orbit
    let orbit = Orbit::new(6778.0, 0.0001, 51.6, 100.0, 90.0, 0.0)?;
    println!("Orbital period: {:.1} minutes", orbit.orbital_period_minutes());
    println!("Apogee: {:.1} km, Perigee: {:.1} km", orbit.apogee_km(), orbit.perigee_km());

    Ok(())
}

use rotastellar::types::Position;

// Create with validation
let pos = Position::new(28.5729, -80.6490, 408.0)?;

// Access fields
println!("Latitude: {}", pos.latitude);
println!("Longitude: {}", pos.longitude);
println!("Altitude: {} km", pos.altitude_km);

use rotastellar::types::Orbit;

// Create an orbit (ISS-like)
let orbit = Orbit::new(
    6778.0,   // semi_major_axis_km
    0.0001,   // eccentricity
    51.6,     // inclination_deg
    100.0,    // raan_deg
    90.0,     // arg_periapsis_deg
    0.0       // true_anomaly_deg
)?;

// Computed properties
println!("Period: {:.1} minutes", orbit.orbital_period_minutes());
println!("Apogee: {:.1} km", orbit.apogee_km());
println!("Perigee: {:.1} km", orbit.perigee_km());
println!("Mean motion: {:.2} rev/day", orbit.mean_motion());

use rotastellar::types::{Satellite, Position, Orbit};

let sat = Satellite::new("sat_123", 25544, "ISS")
    .with_operator("NASA/Roscosmos")
    .with_constellation("Space Station")
    .with_position(Position::new(28.5729, -80.6490, 408.0)?)
    .with_orbit(orbit);

println!("Name: {}", sat.name);
println!("NORAD ID: {}", sat.norad_id);
if let Some(pos) = &sat.position {
    println!("At: {}, {}", pos.latitude, pos.longitude);
}

use rotastellar::types::TimeRange;

// Create a 24-hour time range starting now
let range = TimeRange::next_hours(24.0);
println!("Start: {}", range.start);
println!("End: {}", range.end);

use rotastellar::{Config, ConfigBuilder};

let config = Config::default();
println!("Base URL: {}", config.base_url);
println!("Timeout: {:?}", config.timeout);

use rotastellar::{validate_api_key, mask_api_key, Environment};

// Validate an API key
match validate_api_key(Some("rs_live_abc123")) {
    Ok(env) => println!("Valid key for {:?} environment", env),
    Err(e) => println!("Invalid: {}", e),
}

// Mask a key for logging
let masked = mask_api_key("rs_live_abc123def456");
println!("Masked: {}", masked);  // rs_live_abc...

use rotastellar::error::{RotaStellarError, ValidationError};
use rotastellar::types::Position;

fn create_position() -> Result<Position, RotaStellarError> {
    // This will fail validation (latitude > 90)
    let pos = Position::new(91.0, 0.0, 0.0)?;
    Ok(pos)
}

match create_position() {
    Ok(pos) => println!("Created: {:?}", pos),
    Err(RotaStellarError::Validation(e)) => {
        println!("Validation error on '{}': {}", e.field, e.message);
    }
    Err(e) => println!("Error: {}", e),
}

use rotastellar::{EARTH_RADIUS_KM, EARTH_MU};

println!("Earth radius: {} km", EARTH_RADIUS_KM);  // 6378.137
println!("Earth GM: {} km³/s²", EARTH_MU);         // 398600.4418

use rotastellar::types::Position;
use serde_json;

let pos = Position::new(28.5729, -80.6490, 408.0)?;

// Serialize
let json = serde_json::to_string(&pos)?;
println!("{}", json);

// Deserialize
let parsed: Position = serde_json::from_str(&json)?;