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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use crate::tui_events::TuiEvents;

use super::input_interface::InputInterfaceT;

pub trait ParseInput: InputInterfaceT {
    fn parse_input(&self, input_char: char) -> TuiEvents {
        match input_char {
            '\x1b' => {
                return self.handle_escape_input_s1();
            }
            '\x7F' => {
                return TuiEvents::Backspace;
            }
            '\n' | '\r' => {
                return TuiEvents::Enter;
            }
            ' ' => {
                return TuiEvents::Space;
            }
            '\t' => {
                return TuiEvents::Tab;
            }
            _ => match input_char as u32 {
                0x20..=0x7D => return TuiEvents::AsciiReadable(input_char),
                0 => TuiEvents::Ignore,
                1..=26 => return TuiEvents::Control((input_char as u8 + 0x40) as char),
                _ => return TuiEvents::Other(input_char),
            },
        }
    }
    fn handle_escape_input_s1(&self) -> TuiEvents {
        let input_char_option: Option<char> = self.read_raw_immediate();
        let result = match input_char_option {
            None => TuiEvents::Escape,
            Some('[') => self.handle_escape_input_s2(),
            Some(_) => TuiEvents::Error,
        };
        match result {
            TuiEvents::Error | TuiEvents::Ignore => loop {
                if let None = self.read_raw_immediate() {
                    return result;
                };
            },
            _ => return result,
        }
    }

    fn handle_escape_input_s2(&self) -> TuiEvents {
        let input_char = self.read_raw_immediate();
        return match input_char {
            Some('A') => TuiEvents::UpArrow,
            Some('B') => TuiEvents::DownArrow,
            Some('C') => TuiEvents::RightArrow,
            Some('D') => TuiEvents::LeftArrow,
            Some('3') => {
                if let Some('~') = self.read_raw_immediate() {
                    return TuiEvents::Delete;
                }
                TuiEvents::Error
            }
            Some('<') => self.handle_mouse_events(),
            Some(_) | None => TuiEvents::Error,
        };
    }
    fn handle_mouse_events(&self) -> TuiEvents {
        return match self.read_raw_immediate() {
            Some('0') => match self.get_coordinates() {
                Some((coordinates, 'M')) => TuiEvents::LeftClick(coordinates),
                Some((_, 'm')) => TuiEvents::Ignore,
                None | Some(_) => TuiEvents::Error,
            },
            Some('1') => match self.get_coordinates() {
                Some((coordinates, 'M')) => TuiEvents::MiddleClick(coordinates),
                Some((_, 'm')) => TuiEvents::Ignore,
                None | Some(_) => TuiEvents::Error,
            },
            Some('2') => match self.get_coordinates() {
                Some((coordinates, 'M')) => TuiEvents::RightClick(coordinates),
                Some((_, 'm')) => TuiEvents::Ignore,
                None | Some(_) => TuiEvents::Error,
            },
            Some('3') => self.handle_mouse_move_event(),
            Some('6') => self.handle_scroll_event(),
            None | Some(_) => return TuiEvents::Error,
        };
    }

    fn handle_mouse_move_event(&self) -> TuiEvents {
        return match self.read_raw_immediate() {
            Some('2') => match self.get_coordinates() {
                Some((coordinates, 'M')) => TuiEvents::LeftDrag(coordinates),
                Some(_) | None => TuiEvents::Error,
            },
            Some('3') => match self.get_coordinates() {
                Some((coordinates, 'M')) => TuiEvents::MiddleDrag(coordinates),
                Some(_) | None => TuiEvents::Error,
            },
            Some('4') => match self.get_coordinates() {
                Some((coordinates, 'M')) => TuiEvents::RightDrag(coordinates),
                Some(_) | None => TuiEvents::Error,
            },
            Some('5') => match self.get_coordinates() {
                Some((coordinates, 'm')) => TuiEvents::MouseMove(coordinates),
                Some(_) | None => TuiEvents::Error,
            },
            None | Some(_) => TuiEvents::Error,
        };
    }

    fn handle_scroll_event(&self) -> TuiEvents {
        return match self.read_raw_immediate() {
            Some('4') => match self.get_coordinates() {
                Some((coordinates, 'M')) => TuiEvents::ScrollUp(coordinates),
                None | Some(_) => TuiEvents::Error,
            },
            Some('5') => match self.get_coordinates() {
                Some((coordinates, 'M')) => TuiEvents::ScrollDown(coordinates),
                None | Some(_) => TuiEvents::Error,
            },
            None | Some(_) => TuiEvents::Error,
        };
    }

    fn get_u16(&self) -> Option<(u16, char)> {
        let mut num = 0;
        loop {
            let next = self.read_raw_immediate()?;
            match next as u16 {
                0x30..=0x39 => {
                    let digit = next as u16 - 0x30;
                    if num > u16::MAX {
                        return None;
                    }
                    num *= 10;
                    if digit > u16::MAX - num {
                        return None;
                    }
                    num += digit;
                }
                _ => return Some((num, next)),
            }
        }
    }

    fn get_coordinates(&self) -> Option<((u16, u16), char)> {
        let Some(';') = self.read_raw_immediate() else {
            return None;
        };
        let Some((x, ';')) = self.get_u16() else {
            return None;
        };
        return match self.get_u16() {
            Some((y, c)) => Some(((x, y), c)),
            None => None,
        };
    }
}