use super::{components, safe};
use crate::theme::Theme;
use crate::vim::{Outcome, Vim};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use dugix_core::interactive::{Node, Session};
use ratatui::{
buffer::Buffer,
layout::{Position, Rect},
style::{Modifier, Style},
widgets::{Clear, Paragraph, Widget},
};
use std::collections::HashMap;
use tui_textarea::{CursorMove, TextArea, WrapMode};
#[derive(Default)]
pub(super) struct Inputs {
fields: HashMap<String, TextArea<'static>>,
pub(super) vim: bool,
vims: HashMap<String, Vim>,
code_vims: HashMap<usize, Vim>,
body: Option<Rect>,
}
fn wrap_mode(field: &Node) -> WrapMode {
if field.is_textarea() {
WrapMode::WordOrGlyph
} else {
WrapMode::None
}
}
fn editor(value: &str, field: &Node) -> TextArea<'static> {
let mut editor = TextArea::new(value.split('\n').map(str::to_owned).collect());
editor.move_cursor(CursorMove::Bottom);
editor.move_cursor(CursorMove::End);
editor.set_max_histories(64);
editor.set_wrap_mode(wrap_mode(field));
editor
}
fn sanitize_paste(text: &str, field: &Node) -> String {
let multiline = field.is_textarea();
let limit = field.input_limit().unwrap_or_default();
let mut clean = String::new();
for ch in text.replace("\r\n", "\n").chars() {
let ch = match ch {
'\n' if !multiline => ' ',
'\n' => '\n',
ch if ch.is_control() => continue,
ch => ch,
};
if clean.len() + ch.len_utf8() > limit + 1 {
break;
}
clean.push(ch);
}
clean
}
impl Inputs {
fn sync_editor(&mut self, session: &Session, node: usize) -> Option<&mut TextArea<'static>> {
let input @ Node::Input { key, .. } = session.document().node(node)? else {
return None;
};
let live = |key: &String| {
session
.document()
.all_nodes()
.iter()
.any(|node| matches!(node, Node::Input { key: field, .. } if field == key))
};
self.fields.retain(|key, _| live(key));
self.vims.retain(|key, _| live(key));
let value = session.value(key);
let field = self
.fields
.entry(key.clone())
.or_insert_with(|| editor(&value, input));
if field.lines().join("\n") != value {
*field = editor(&value, input);
}
field.set_wrap_mode(wrap_mode(input));
Some(field)
}
fn change(
&mut self,
session: &mut Session,
node: usize,
change: impl FnOnce(&mut TextArea<'static>),
) -> anyhow::Result<()> {
let Some(Node::Input { key, .. }) = session.document().node(node) else {
return Ok(());
};
let key = key.clone();
let Some(field) = self.sync_editor(session, node) else {
return Ok(());
};
let previous = field.clone();
change(field);
let value = field.lines().join("\n");
if value != session.value(&key)
&& let Err(error) = session.input(&key, value)
{
*field = previous;
return Err(error);
}
Ok(())
}
fn vim_key(
&mut self,
session: &mut Session,
node: usize,
key: KeyEvent,
) -> anyhow::Result<Option<bool>> {
let Some(Node::Input { key: name, .. }) = session.document().node(node) else {
return Ok(Some(false));
};
let name = name.clone();
let mut vim = self.vims.remove(&name).unwrap_or_default();
let mut outcome = Outcome::Passthrough;
let result = self.change(session, node, |field| outcome = vim.key(field, key));
self.vims.insert(name, vim);
result?;
Ok(match outcome {
Outcome::Handled => Some(true),
Outcome::Submit | Outcome::Leave => Some(false),
Outcome::Passthrough => None,
})
}
pub(super) fn key(
&mut self,
session: &mut Session,
node: usize,
mut key: KeyEvent,
) -> anyhow::Result<bool> {
let Some(field) = session.document().node(node) else {
return Ok(false);
};
if !matches!(field, Node::Input { .. }) {
return Ok(false);
}
let textarea = field.is_textarea();
if self.vim
&& let Some(consumed) = self.vim_key(session, node, key)?
{
return Ok(consumed);
}
if matches!(
key.code,
KeyCode::Tab | KeyCode::BackTab | KeyCode::Esc | KeyCode::F(_)
) || (!textarea
&& matches!(
key.code,
KeyCode::Enter | KeyCode::PageUp | KeyCode::PageDown
))
{
return Ok(false);
}
let command = key
.modifiers
.intersects(KeyModifiers::CONTROL | KeyModifiers::SUPER);
if key.modifiers.contains(KeyModifiers::ALT)
&& matches!(key.code, KeyCode::Left | KeyCode::Right)
{
key.modifiers.remove(KeyModifiers::ALT);
key.modifiers.insert(KeyModifiers::CONTROL);
}
self.change(session, node, |field| match key.code {
KeyCode::Char('a' | 'A') if command => field.select_all(),
KeyCode::Char('z' | 'Z') if command => {
if key.modifiers.contains(KeyModifiers::SHIFT) {
field.redo();
} else {
field.undo();
}
}
KeyCode::Char('y' | 'Y') if command => {
field.redo();
}
KeyCode::Backspace if command => {
field.delete_word();
}
KeyCode::Delete if command => {
field.delete_next_word();
}
KeyCode::Home | KeyCode::End if command => {
if key.modifiers.contains(KeyModifiers::SHIFT) {
if !field.is_selecting() {
field.start_selection();
}
} else {
field.cancel_selection();
}
let end = key.code == KeyCode::End;
field.move_cursor(if end {
CursorMove::Bottom
} else {
CursorMove::Top
});
field.move_cursor(if end {
CursorMove::End
} else {
CursorMove::Head
});
}
KeyCode::Char(ch)
if !command && !key.modifiers.contains(KeyModifiers::ALT) && !ch.is_control() =>
{
field.input(key);
}
KeyCode::Left
| KeyCode::Right
| KeyCode::Up
| KeyCode::Down
| KeyCode::Home
| KeyCode::End
| KeyCode::PageUp
| KeyCode::PageDown
| KeyCode::Backspace
| KeyCode::Delete
| KeyCode::Enter => {
field.input(key);
}
_ => {}
})?;
Ok(true)
}
pub(super) fn selection(
&mut self,
session: &mut Session,
node: usize,
cut: bool,
) -> anyhow::Result<Option<String>> {
let Some(field) = self.sync_editor(session, node) else {
return Ok(None);
};
if field
.selection_range()
.is_none_or(|(start, end)| start == end)
{
return Ok(None);
}
let mut copy = field.clone();
copy.copy();
let text = copy.yank_text();
if cut {
self.change(session, node, |field| {
field.cut();
})?;
}
Ok(Some(text))
}
pub(super) fn paste(
&mut self,
session: &mut Session,
node: usize,
text: &str,
) -> anyhow::Result<()> {
let Some(field) = session.document().node(node) else {
return Ok(());
};
let text = sanitize_paste(text, field);
if text.is_empty() {
return Ok(());
}
self.change(session, node, |field| {
field.insert_str(text);
})
}
pub(super) fn draw_focused(
&mut self,
session: &Session,
node: usize,
width: u16,
theme: &Theme,
buffer: &mut Buffer,
) {
self.body = None;
let Some((input, area)) = components::visible_regions(session, width)
.into_iter()
.find(|(input, _)| session.document().node_index(input) == node)
else {
return;
};
let name = match input {
Node::Input { key, .. } => key.clone(),
_ => String::new(),
};
let vim = self
.vim
.then(|| self.vims.remove(&name).unwrap_or_default());
if let Some(field) = self.sync_editor(session, node) {
self.body = Some(paint(
field,
FieldView {
node: input,
session,
area,
theme,
selected: true,
vim: vim.as_ref(),
},
buffer,
));
}
if let Some(vim) = vim {
self.vims.insert(name, vim);
}
}
pub(super) fn code_vim(&mut self, node: usize) -> &mut Vim {
self.code_vims.entry(node).or_default()
}
pub(super) fn code_mode_label(&self, node: usize) -> Option<&'static str> {
self.vim
.then(|| self.code_vims.get(&node).map_or("INSERT", Vim::label))
}
pub(super) fn mode_label(&self, session: &Session, node: usize) -> Option<&'static str> {
let Some(Node::Input { key, .. }) = session.document().node(node) else {
return None;
};
self.vim
.then(|| self.vims.get(key).map_or("INSERT", Vim::label))
}
pub(super) fn caret(&self, buffer: &Buffer) -> Option<Position> {
caret(buffer, self.body?.intersection(buffer.area))
}
pub(super) fn click(
&mut self,
session: &Session,
node: usize,
position: Position,
width: u16,
extend: bool,
) {
let Some(input @ Node::Input { .. }) = session.document().node(node) else {
return;
};
let area = Rect::new(0, 0, width, input.rows());
let Some(field) = self.sync_editor(session, node) else {
return;
};
let mut buffer = Buffer::empty(area);
let body = paint(
field,
FieldView {
node: input,
session,
area,
theme: &Theme::default(),
selected: true,
vim: None,
},
&mut buffer,
);
let position = if extend {
Position::new(
position
.x
.clamp(body.left(), body.right().saturating_sub(1)),
position
.y
.clamp(body.top(), body.bottom().saturating_sub(1)),
)
} else {
position
};
if !body.contains(position) {
return;
}
let Some(mut caret) = caret(&buffer, body) else {
return;
};
let mut candidate = field.clone();
candidate.cancel_selection();
for _ in 0..body.height {
if caret.y == position.y {
break;
}
let before = candidate.cursor();
candidate.move_cursor(if caret.y > position.y {
CursorMove::Up
} else {
CursorMove::Down
});
caret = probe(&candidate, body);
if candidate.cursor() == before {
break;
}
}
for _ in 0..=body.width {
if caret.x == position.x {
break;
}
let before = candidate.cursor();
let forward = caret.x < position.x;
candidate.move_cursor(if forward {
CursorMove::Forward
} else {
CursorMove::Back
});
let next = probe(&candidate, body);
if next.y != caret.y || (forward && next.x > position.x) {
candidate.move_cursor(jump(before));
break;
}
caret = next;
if candidate.cursor() == before {
break;
}
}
if extend {
if !field.is_selecting() {
field.start_selection();
}
} else {
field.cancel_selection();
}
field.move_cursor(jump(candidate.cursor()));
if !extend {
field.start_selection();
}
}
}
fn jump((row, column): (usize, usize)) -> CursorMove {
CursorMove::Jump(
u16::try_from(row).unwrap_or(u16::MAX),
u16::try_from(column).unwrap_or(u16::MAX),
)
}
fn probe(field: &TextArea<'_>, body: Rect) -> Position {
let mut buffer = Buffer::empty(body);
field.render(body, &mut buffer);
caret(&buffer, body).unwrap_or(body.as_position())
}
pub(super) fn caret(buffer: &Buffer, area: Rect) -> Option<Position> {
area.positions()
.find(|&position| buffer[position].modifier.contains(Modifier::REVERSED))
}
pub(super) fn render_static(
node: &Node,
session: &Session,
area: Rect,
theme: &Theme,
selected: bool,
buffer: &mut Buffer,
) {
if let Node::Input { key, .. } = node {
paint(
&mut editor(&session.value(key), node),
FieldView {
node,
session,
area,
theme,
selected,
vim: None,
},
buffer,
);
}
}
#[derive(Clone, Copy)]
struct FieldView<'a> {
node: &'a Node,
session: &'a Session,
area: Rect,
theme: &'a Theme,
selected: bool,
vim: Option<&'a Vim>,
}
fn field_frame(
buffer: &mut Buffer,
frame: Rect,
label: &str,
(selected, invalid): (bool, bool),
theme: &Theme,
) -> Rect {
let (line, label_style) = if selected {
(
theme.accent,
Style::default()
.fg(theme.accent)
.add_modifier(Modifier::BOLD),
)
} else if invalid {
(theme.error, Style::default().fg(theme.error))
} else {
(theme.border_dim, Style::default().fg(theme.fg_dim))
};
buffer.set_stringn(
frame.x,
frame.y,
label,
usize::from(frame.width),
label_style,
);
if frame.height >= 2 {
buffer.set_string(
frame.x,
frame.bottom() - 1,
"â–”".repeat(usize::from(frame.width)),
Style::default().fg(line),
);
}
Rect::new(
frame.x,
frame.y + 1,
frame.width,
frame.height.saturating_sub(2),
)
}
fn placeholder_style(theme: &Theme) -> Style {
Style::default()
.fg(theme.fg_dim)
.bg(theme.surface)
.add_modifier(Modifier::ITALIC)
}
fn paint(field: &mut TextArea<'static>, view: FieldView<'_>, buffer: &mut Buffer) -> Rect {
let FieldView {
node,
session,
area,
theme,
selected,
vim,
} = view;
let Node::Input {
key,
label,
rows,
placeholder,
hint,
rules,
} = node
else {
return Rect::default();
};
Clear.render(area, buffer);
buffer.set_style(area, theme.background_style());
let error = session
.input_error(key)
.filter(|_| !session.value(key).is_empty());
let required = if rules.get("required").and_then(serde_json::Value::as_bool) == Some(true) {
" *"
} else {
""
};
let frame = Rect::new(
area.x,
area.y,
area.width,
rows.saturating_add(2).min(area.height),
);
let body = field_frame(
buffer,
frame,
&format!("{}{required}", safe(label)),
(selected, error.is_some()),
theme,
);
field.set_style(Style::default().fg(theme.fg).bg(theme.surface));
field.set_cursor_line_style(Style::default());
field.set_selection_style(Style::default().fg(theme.fg).bg(theme.selection));
field.set_cursor_style(Style::default().add_modifier(Modifier::REVERSED));
let lines: Vec<_> = placeholder.lines().collect();
field.set_placeholder_text(safe(&lines.join(crate::ui::style::SEP)));
field.set_placeholder_style(placeholder_style(theme));
crate::editor::decorate(
field,
crate::editor::Decor {
syntax: node.is_textarea().then_some(("markdown", 0)),
colors: crate::ui::style::SyntaxColors::from_theme(theme),
vim,
selection: Style::default().fg(theme.fg).bg(theme.selection),
},
);
if body.width > 0 && body.height > 0 {
if !selected && field.is_empty() {
for (y, line) in (body.y..body.bottom()).zip(lines) {
let width = usize::from(body.width);
buffer.set_stringn(body.x, y, safe(line), width, placeholder_style(theme));
}
} else {
(&*field).render(body, buffer);
if !selected && let Some(caret) = caret(buffer, body) {
buffer[caret].modifier.remove(Modifier::REVERSED);
}
}
}
if frame.bottom() < area.bottom() {
let note = if hint.is_empty() && !required.is_empty() && session.value(key).is_empty() {
"Required"
} else {
hint.as_str()
};
Paragraph::new(safe(error.as_deref().unwrap_or(note)))
.style(
Style::default()
.fg(if error.is_some() {
theme.error
} else {
theme.fg_dim
})
.bg(theme.bg),
)
.render(Rect::new(area.x, frame.bottom(), area.width, 1), buffer);
}
body
}