use std::{collections::VecDeque, io::Write};
use haest::{
session::{Body, Frame},
wire::Outbound,
};
use tokio::sync::oneshot;
use super::{DIM, Renderer, YELLOW, inert};
pub(super) struct Question {
frame: Frame,
drawn: Option<oneshot::Sender<()>>,
}
fn asks(frame: &Frame) -> &str {
match &frame.body {
Body::Wire(Outbound::Ask { text }) => text,
_ => "",
}
}
#[derive(Default)]
pub(super) struct Held {
pieces: VecDeque<Piece>,
lines: usize,
dropped: usize,
}
enum Piece {
Out(String),
Line(String),
}
const MAX_HELD: usize = 2000;
impl Held {
fn out(&mut self, text: &str) {
match self.pieces.back_mut() {
Some(Piece::Out(run)) => run.push_str(text),
_ => self.pieces.push_back(Piece::Out(text.to_owned())),
}
}
fn line(&mut self, line: String) {
if self.lines >= MAX_HELD {
self.let_the_oldest_line_go();
}
self.pieces.push_back(Piece::Line(line));
self.lines += 1;
}
fn let_the_oldest_line_go(&mut self) {
let oldest = self.pieces.iter().position(|p| matches!(p, Piece::Line(_)));
let Some(i) = oldest else {
return;
};
if let Some(Piece::Line(line)) = self.pieces.remove(i) {
self.lines -= 1;
self.dropped += line.split('\n').count();
}
let before = i.checked_sub(1).and_then(|b| self.pieces.get(b));
let joins = matches!(
(before, self.pieces.get(i)),
(Some(Piece::Out(_)), Some(Piece::Out(_)))
);
if joins
&& let Some(Piece::Out(after)) = self.pieces.remove(i)
&& let Some(Piece::Out(before)) = self.pieces.get_mut(i - 1)
{
before.push_str(&after);
}
}
}
impl<O: Write, E: Write> Renderer<O, E> {
pub(super) fn put_out(&mut self, text: &str) {
if self.inert_answer
&& let Some(held) = &mut self.held
{
return held.out(text);
}
let _ = write!(self.out, "{text}");
let _ = self.out.flush();
}
pub(super) fn put_line(&mut self, line: String) {
if let Some(held) = &mut self.held {
return held.line(line);
}
match &self.above {
Some(above) if above.send(line.clone()).is_ok() => {}
_ => {
let _ = writeln!(self.err, "{line}");
}
}
}
pub(crate) fn answering(&mut self, frame: Frame, drawn: oneshot::Sender<()>) {
if !self.ended {
let drawn = Some(drawn);
self.question = Some(Question { frame, drawn });
}
}
pub(crate) fn ended(&mut self) {
self.ended = true;
if self.question.as_ref().is_some_and(|q| q.drawn.is_some()) {
self.question = None;
}
}
pub(super) fn asked(&mut self, seq: u64, text: &str) {
if self
.question
.as_ref()
.is_some_and(|q| q.frame.seq == seq && q.drawn.is_some())
{
self.draw_question(text);
} else {
self.ask(text);
}
}
pub(super) fn after_lost_question(&mut self, seq: u64) {
let Some(q) = &self.question else {
return;
};
if q.drawn.is_none() || seq <= q.frame.seq {
return;
}
let frame = q.frame.clone();
if self.json {
self.json_frame(&frame);
} else {
self.draw_question(asks(&frame));
}
}
fn draw_question(&mut self, text: &str) {
self.end_line();
let text = self.paint(YELLOW, &inert(text));
let _ = write!(self.err, "{text}");
let _ = self.err.flush();
self.held.get_or_insert_with(Held::default);
self.drew_question();
}
pub(super) fn wrote(&mut self, seq: u64) {
if self.question.as_ref().is_some_and(|q| q.frame.seq == seq) {
self.drew_question();
}
}
fn drew_question(&mut self) {
if let Some(drawn) = self.question.as_mut().and_then(|q| q.drawn.take()) {
let _ = drawn.send(());
}
}
pub(crate) fn answered(&mut self, enter: bool) {
self.question = None;
let Some(held) = self.held.take() else {
return;
};
if !enter {
let _ = writeln!(self.err);
}
for piece in held.pieces {
match piece {
Piece::Out(text) => self.put_out(&text),
Piece::Line(line) => self.put_line(line),
}
}
let lines = match held.dropped {
0 => return,
1 => "1 line".to_owned(),
n => format!("{n} lines"),
};
self.note(DIM, &format!("({lines} not shown while haest asked)"));
}
pub(crate) fn refused(&mut self, why: &str) {
if self.json {
self.note(YELLOW, why);
}
}
pub(super) fn ask(&mut self, question: &str) {
if self.json {
let text = question.to_string();
return self.json_line(haest::wire::Outbound::Ask { text });
}
self.note(YELLOW, question);
}
}
#[cfg(test)]
mod tests;