1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use crossterm::event::{KeyCode, KeyEvent};
use tty_interface::{Interface, Position, Style};

use crate::{
    dependency::{DependencyId, DependencyState, Evaluation},
    style::{help_style, muted_style},
    text::{DrawerContents, Segment, Text},
    Form,
};

use super::{InputResult, Step};

pub struct YesNoStep {
    prompt: String,
    prefix: String,
    omit_if_no: bool,
    value: bool,
    evaluation: Option<(DependencyId, Evaluation)>,
}

impl YesNoStep {
    pub fn new(prompt: &str, prefix: &str) -> Self {
        Self {
            prompt: prompt.to_string(),
            prefix: prefix.to_string(),
            omit_if_no: true,
            value: false,
            evaluation: None,
        }
    }

    pub fn set_omit_if_no(&mut self, omit: bool) {
        self.omit_if_no = omit;
    }

    pub fn set_evaluation(&mut self, evaluation: Evaluation) -> DependencyId {
        let id = DependencyId::new();
        self.evaluation = Some((id, evaluation));
        id
    }

    fn value_as_string(&self) -> &str {
        if self.value {
            "Yes"
        } else {
            "No"
        }
    }
}

impl Step for YesNoStep {
    fn initialize(&mut self, _dependency_state: &mut DependencyState, _index: usize) {}

    fn render(
        &self,
        interface: &mut Interface,
        _dependency_state: &DependencyState,
        position: Position,
        is_focused: bool,
    ) -> u16 {
        if self.value || is_focused || !self.omit_if_no {
            let style = if is_focused && self.omit_if_no && !self.value {
                muted_style()
            } else {
                Style::new()
            };

            if is_focused {
                interface.set_cursor(Some(position));
            }

            interface.set_styled(
                position,
                &format!("{}: {}", self.prefix, self.value_as_string()),
                style,
            );

            return 1;
        }

        0
    }

    fn update(
        &mut self,
        dependency_state: &mut DependencyState,
        input: KeyEvent,
    ) -> Option<InputResult> {
        match input.code {
            KeyCode::Enter | KeyCode::Tab => return Some(InputResult::AdvanceForm),
            KeyCode::Esc => return Some(InputResult::RetreatForm),
            KeyCode::Up | KeyCode::Down => self.value = !self.value,
            _ => {}
        };

        if let Some((id, evaluation)) = &self.evaluation {
            let value = match evaluation {
                Evaluation::Equals(value) => value == self.value_as_string(),
                Evaluation::IsEmpty => false,
            };

            dependency_state.update_evaluation(&id, value);
        }

        None
    }

    fn help(&self) -> Segment {
        Text::new_styled(self.prompt.to_string(), help_style()).as_segment()
    }

    fn drawer(&self) -> Option<DrawerContents> {
        None
    }

    fn result(&self, _dependency_state: &DependencyState) -> String {
        format!("{}: {}", self.prefix, self.value_as_string())
    }

    fn add_to(self, form: &mut Form) {
        form.add_step(Box::new(self));
    }
}