use cersei::vms::prelude::*;
// or, when working against the crate directly:
use cersei_vms::prelude::*;

#[async_trait]
pub trait SandboxRuntime: Send + Sync {
    fn name(&self) -> &str;
    fn capabilities(&self) -> RuntimeCaps;

    async fn create(&self, opts: SandboxOpts) -> Result<SandboxHandle>;
    async fn get(&self, id: &SandboxId) -> Result<SandboxHandle>;
    async fn list(&self) -> Result<Vec<SandboxInfo>>;

    async fn restore(&self, snapshot: &SnapshotId) -> Result<SandboxHandle>;
}

pub struct RuntimeCaps {
    pub snapshots: bool,
    pub pause_resume: bool,
    pub gpu: bool,
    pub network_isolation: bool,
    pub shared_volumes: bool,
    pub remote: bool,
}

#[async_trait]
pub trait Sandbox: Send + Sync {
    fn id(&self) -> &SandboxId;
    fn info(&self) -> SandboxInfo;
    fn commands(&self) -> Arc<dyn Commands>;
    fn filesystem(&self) -> Arc<dyn Filesystem>;

    async fn snapshot(&self) -> Result<SnapshotId>;
    async fn pause(&self) -> Result<()>;
    async fn resume(&self) -> Result<()>;
    async fn kill(&self) -> Result<()>;
}

pub struct SandboxOpts {
    pub image: String,
    pub workdir: Option<PathBuf>,
    pub env: HashMap<String, String>,
    pub volumes: Vec<VolumeMount>,
    pub cpu_limit: Option<f32>,
    pub mem_limit: Option<u64>,
    pub labels: HashMap<String, String>,
    pub from_snapshot: Option<SnapshotId>,
    pub mailbox_topics: Vec<String>,
}

let opts = SandboxOpts::image("alpine:3.20")
    .with_workdir("/work")
    .with_env("LANG", "C.UTF-8")
    .with_volume(VolumeMount {
        volume_id: shared_vol.id.clone(),
        mount_path: "/shared".into(),
        read_only: false,
    })
    .with_label("cersei.task", "build");

pub enum SandboxStatus { Creating, Running, Paused, Exited, Killed, Failed }

pub struct SandboxInfo {
    pub id: SandboxId,
    pub backend: String,                          // "local" | "docker"
    pub image: String,
    pub status: SandboxStatus,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub labels: HashMap<String, String>,
}

#[async_trait]
pub trait Commands: Send + Sync {
    async fn run(&self, req: RunRequest) -> Result<RunOutput>;
    async fn stream(&self, req: RunRequest) -> Result<CommandStream>;
    async fn signal(&self, pid: u32, sig: Signal) -> Result<()>;
}

pub struct RunRequest {
    pub command: String,
    pub workdir: Option<PathBuf>,
    pub env: HashMap<String, String>,
    pub timeout: Option<Duration>,    // default 120s, max 600s
    pub background: bool,
}

let req = RunRequest::new("cargo test --quiet")
    .workdir("/work/myproj")
    .env("RUST_BACKTRACE", "1")
    .timeout(Duration::from_secs(300));

pub struct RunOutput {
    pub stdout: String,
    pub stderr: String,
    pub exit_code: i32,
    pub timed_out: bool,
    pub pid: Option<u32>,    // populated for background runs
}

pub enum StreamChunk {
    Started { pid: u32 },
    Stdout  { data: String },   // one line per chunk
    Stderr  { data: String },
    Exit    { code: i32 },
    Error   { message: String },
}

pub enum Signal { Term, Kill, Int, Hup, Usr1, Usr2 }

#[async_trait]
pub trait Filesystem: Send + Sync {
    async fn read(&self, path: &str) -> Result<Bytes>;
    async fn write(&self, path: &str, data: &[u8]) -> Result<()>;
    async fn list(&self, path: &str, depth: u32) -> Result<Vec<FileEntry>>;
    async fn stat(&self, path: &str) -> Result<FileEntry>;
    async fn watch(&self, path: &str, recursive: bool) -> Result<WatchStream>;
    async fn mkdir(&self, path: &str, recursive: bool) -> Result<()>;
    async fn remove(&self, path: &str, recursive: bool) -> Result<()>;
    async fn upload(&self, local: &Path, remote: &str) -> Result<()>;
    async fn download(&self, remote: &str, local: &Path) -> Result<()>;
}

pub enum FileKind { File, Dir, Symlink }

pub struct FileEntry {
    pub path: PathBuf,
    pub kind: FileKind,
    pub size: u64,
    pub modified_unix_ms: i64,
}

pub struct Volume {
    pub id: VolumeId,
    pub label: Option<String>,
    pub host_path: PathBuf,
    pub created_at: chrono::DateTime<chrono::Utc>,
}

let reg = VolumeRegistry::default_user()?;       // ~/.cersei/vms/volumes
let shared = reg.create(Some("build-cache".into()))?;
// `shared.host_path` is now bind-mountable.

let mailbox = Mailbox::new();                          // or with_capacity(N)
let mut sub = mailbox.subscribe("workers/results");
mailbox.publish("workers/results", SandboxId::new(), json!({ "ok": true }))?;
let env: MailboxEnvelope = sub.recv().await?;

let kv = KvStore::open("~/.cersei/vms/kv.json")?;
let entry = kv.set("progress", b"42".to_vec())?;
let again = kv.cas("progress", Some(entry.version), b"43".to_vec())?;
// `Ok(None)` on version mismatch, `Ok(Some(new_entry))` on success.

pub struct SnapshotManifest {
    pub id: SnapshotId,
    pub backend: String,                    // "local" | "docker"
    pub fs_pointer: String,                 // backend-specific FS state pointer
    pub original_opts: SandboxOpts,
    pub volumes: Vec<VolumeMount>,
    pub kv: KvSnapshot,
    pub mailbox_topics: Vec<String>,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub labels: HashMap<String, String>,
}

cargo build -p cersei-vms --bin cersei-envd --release --features envd

pub enum VmError {
    NotFound(String),
    SnapshotNotFound(String),
    VolumeNotFound(String),
    Lifecycle(String),
    Transport(String),
    Backend { backend: String, message: String },
    Timeout(Duration),
    Permission(String),
    Snapshot(String),
    Mailbox(String),
    Kv(String),
    Invalid(String),
    Io(std::io::Error),
    Json(serde_json::Error),
    Other(anyhow::Error),
}

pub type Result<T> = std::result::Result<T, VmError>;

use cersei_tools::ToolContext;
use cersei_vms::Sandbox;
use std::sync::Arc;

let sandbox: Arc<dyn Sandbox> = runtime.create(opts).await?;
let ctx: ToolContext = /* … */;
ctx.extensions.insert::<Arc<dyn Sandbox>>(sandbox);
// `BashTool` now runs every command inside the sandbox.