Sessions and turns

use zyris_attacca::{AttaccaApi, AttaccaApiClient, ZNewProject, ZProjectUpdate};

async fn projects(api: &AttaccaApiClient) -> zyris::Result<()> {
    let project = api
        .create_project(ZNewProject { name: "Rollout".into(), description: Some("Q3".into()) })
        .await?;

    // Rename only: the description is left alone.
    let rename = ZProjectUpdate { name: Some("Rollout 2".into()), ..Default::default() };
    api.update_project(project.id.clone(), rename).await?;

    // Clear the description: Some(None) sends an explicit null.
    let clear = ZProjectUpdate { description: Some(None), ..Default::default() };
    api.update_project(project.id.clone(), clear).await?;

    api.delete_project(project.id).await
}

use zyris_attacca::{AttaccaApi, AttaccaApiClient, ZHistoryQuery, ZSessionFilter};

async fn print_recent(api: &AttaccaApiClient, project_id: String) -> zyris::Result<()> {
    let filter = ZSessionFilter { project_id: Some(project_id), limit: Some(10) };
    for session in api.list_sessions(filter).await? {
        let title = session.title.as_deref().unwrap_or("(untitled)");
        println!("{} {title} running={}", session.id, session.running);

        let history = api.session_history(session.id.clone(), ZHistoryQuery::default()).await?;
        for event in history {
            println!("  [{}] {} {}", event.cursor, event.kind, event.payload);
        }
    }
    Ok(())
}

use zyris::ErrorCode;
use zyris_attacca::{AttaccaApi, AttaccaApiClient, ZNewMessage};

async fn say_with(
    api: &AttaccaApiClient,
    session_id: String,
    message: String,
    agent_id: String,
) -> zyris::Result<()> {
    let request = ZNewMessage {
        session_id: session_id.clone(),
        message: message.clone(),
        agent_id: Some(agent_id),
    };
    match api.send_message_with(request).await {
        Err(e) if matches!(e.code, ErrorCode::CapabilityNotAnnounced | ErrorCode::MethodNotFound) => {
            // An older deployment: fall back to the session's own agent.
            api.send_message(session_id, message, vec![]).await
        }
        other => other,
    }
}

use futures::StreamExt;
use zyris_attacca::{AttaccaApi, AttaccaApiClient, ZSessionEvent, ZTurnFrame};

/// A transcript kept across reconnects: events by id, and the last durable cursor seen.
#[derive(Default)]
struct Transcript {
    events: Vec<ZSessionEvent>,
    last_cursor: Option<i64>,
}

impl Transcript {
    fn apply(&mut self, cursor: i64, event: ZSessionEvent) {
        // An id already held under another seq means the event moved: drop the old entry.
        if let Some(id) = &event.id {
            self.events.retain(|held| held.id.as_ref() != Some(id));
        }
        self.events.push(event);
        self.events.sort_by_key(|event| event.seq);
        self.last_cursor = Some(self.last_cursor.map_or(cursor, |last| last.max(cursor)));
    }
}

async fn follow(api: &AttaccaApiClient, session_id: String, log: &mut Transcript) -> zyris::Result<()> {
    let mut stream = api.turn_events(session_id, log.last_cursor).await?;
    println!("running={} last_cursor={:?}", stream.head.running, stream.head.last_cursor);

    while let Some(frame) = stream.items.next().await {
        match frame? {
            ZTurnFrame::Event { cursor, event } => log.apply(cursor, event),
            ZTurnFrame::Delta { .. } => {} // live text; the durable answer arrives as an Event
            ZTurnFrame::Cancelled => println!("turn stopped"),
            ZTurnFrame::Status { running } => println!("running={running}"),
        }
    }
    Ok(())
}

use zyris_attacca::{AttaccaApi, AttaccaApiClient, ZDelivered};

/// The person interrupted after hearing `spoken` of the answer. `answer_cursor` is the cursor of
/// the `chat_agent` Event being read out, or `None` while it was still arriving as Delta frames.
async fn interrupt(
    api: &AttaccaApiClient,
    session_id: String,
    answer_cursor: Option<i64>,
    spoken: &str,
) -> zyris::Result<()> {
    let delivered = ZDelivered { cursor: answer_cursor, chars: spoken.chars().count() as u64 };
    api.cancel_turn(session_id, Some(delivered)).await
}

/// Just stop; keep whatever streamed.
async fn stop(api: &AttaccaApiClient, session_id: String) -> zyris::Result<()> {
    api.cancel_turn(session_id, None).await
}