use crate::component::{Component, KeyResult, is_cancel};
use ratatui::{
buffer::Buffer,
crossterm::event::{KeyCode, KeyEvent},
layout::Rect,
style::{Color, Modifier, Style},
widgets::Widget,
};
pub use infinity_protocol::ModelInfo;
pub const MAX_VISIBLE_ROWS: u16 = 5;
pub enum ModelPickerResult {
Selected(usize),
Cancelled,
}
pub struct ModelPicker {
models: Vec<ModelInfo>,
selected: usize,
scroll_offset: usize,
result: Option<ModelPickerResult>,
}
impl ModelPicker {
pub fn new(models: Vec<ModelInfo>) -> Self {
Self {
models,
selected: 0,
scroll_offset: 0,
result: None,
}
}
pub fn take_result(&mut self) -> Option<ModelPickerResult> {
self.result.take()
}
pub fn visible_rows(&self) -> u16 {
(self.models.len() as u16).min(MAX_VISIBLE_ROWS)
}
pub fn preferred_height(&self) -> u16 {
self.visible_rows() + 1 }
fn move_up(&mut self) {
if self.selected > 0 {
self.selected -= 1;
if self.selected < self.scroll_offset {
self.scroll_offset = self.selected;
}
}
}
fn move_down(&mut self) {
if self.selected + 1 < self.models.len() {
self.selected += 1;
let visible = MAX_VISIBLE_ROWS as usize;
if self.selected >= self.scroll_offset + visible {
self.scroll_offset = self.selected + 1 - visible;
}
}
}
fn confirm(&mut self) {
if self.selected < self.models.len() {
self.result = Some(ModelPickerResult::Selected(self.selected));
}
}
fn cancel(&mut self) {
self.result = Some(ModelPickerResult::Cancelled);
}
pub fn render(&self, area: Rect, buf: &mut Buffer) {
if area.height == 0 || area.width == 0 {
return;
}
let visible = self.visible_rows() as usize;
let end = (self.scroll_offset + visible).min(self.models.len());
for (i, model) in self.models[self.scroll_offset..end].iter().enumerate() {
let y = area.y + i as u16;
if y >= area.bottom() {
break;
}
let abs_idx = self.scroll_offset + i;
let is_selected = abs_idx == self.selected;
let (fg, bg, modifier) = if is_selected {
(Color::Black, Color::White, Modifier::BOLD)
} else {
(Color::DarkGray, Color::Reset, Modifier::empty())
};
let ctx_str = if model.context_window >= 1_000_000 {
format!("{}m ctx", model.context_window / 1_000_000)
} else {
format!("{}k ctx", model.context_window / 1_000)
};
let line = format!(
" {:<10} {:<24} {:>10}",
model.provider_id, model.display_name, ctx_str
);
for x in area.x..area.right() {
buf[(x, y)].set_char(' ').set_bg(bg);
}
for (col, ch) in line.chars().enumerate() {
let x = area.x + col as u16;
if x >= area.right() {
break;
}
buf[(x, y)]
.set_char(ch)
.set_fg(fg)
.set_bg(bg)
.set_style(Style::default().add_modifier(modifier));
}
}
}
}
impl Component for ModelPicker {
fn handle_keystroke(&mut self, key: KeyEvent) -> KeyResult {
match key.code {
KeyCode::Up => {
self.move_up();
KeyResult::Captured
}
KeyCode::Down => {
self.move_down();
KeyResult::Captured
}
KeyCode::Enter => {
self.confirm();
KeyResult::Captured
}
_ if is_cancel(&key) => {
self.cancel();
KeyResult::Captured
}
_ => KeyResult::Captured, }
}
}
pub struct ModelPickerWidget<'a> {
picker: &'a ModelPicker,
}
impl<'a> ModelPickerWidget<'a> {
pub fn new(picker: &'a ModelPicker) -> Self {
Self { picker }
}
}
impl<'a> Widget for ModelPickerWidget<'a> {
fn render(self, area: Rect, buf: &mut Buffer) {
self.picker.render(area, buf);
}
}