gosuto 0.11.1

Gōsuto (ゴースト) — a cyberpunk terminal Matrix client with vim motions
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

use std::time::Instant;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConnectingPhase {
    DiscoveringService,
    NegotiatingHandshake,
    ExchangingKeys,
    EstablishingLink,
}

impl ConnectingPhase {
    pub fn label(&self) -> &'static str {
        match self {
            Self::DiscoveringService => "DISCOVERING SERVICE",
            Self::NegotiatingHandshake => "NEGOTIATING HANDSHAKE",
            Self::ExchangingKeys => "EXCHANGING KEYS",
            Self::EstablishingLink => "ESTABLISHING LINK",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CallState {
    /// Acquiring JWT + connecting to LiveKit
    Connecting(ConnectingPhase),
    /// Connected, audio flowing
    Active,
}

#[derive(Debug, Clone)]
pub struct CallInfo {
    pub room_id: String,
    pub room_name: Option<String>,
    pub state: CallState,
    pub is_incoming: bool,
    pub participants: Vec<String>,
    pub started_at: Option<Instant>,
}

impl CallInfo {
    pub fn new_outgoing(room_id: String, room_name: Option<String>) -> Self {
        Self {
            room_id,
            room_name,
            state: CallState::Connecting(ConnectingPhase::DiscoveringService),
            is_incoming: false,
            participants: Vec::new(),
            started_at: None,
        }
    }

    pub fn new_incoming(room_id: String, caller: String, room_name: Option<String>) -> Self {
        Self {
            room_id,
            room_name,
            state: CallState::Connecting(ConnectingPhase::DiscoveringService),
            is_incoming: true,
            participants: vec![caller],
            started_at: None,
        }
    }

    /// Returns elapsed seconds since call became active
    pub fn elapsed_secs(&self) -> Option<u64> {
        self.started_at.map(|t| t.elapsed().as_secs())
    }

    /// Format elapsed time as MM:SS
    pub fn elapsed_display(&self) -> String {
        match self.elapsed_secs() {
            Some(secs) => format!("{:02}:{:02}", secs / 60, secs % 60),
            None => "--:--".to_string(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn new_outgoing_fields() {
        let call = CallInfo::new_outgoing("!room:x".to_string(), Some("Room".to_string()));
        assert_eq!(call.room_id, "!room:x");
        assert_eq!(call.room_name.as_deref(), Some("Room"));
        assert_eq!(
            call.state,
            CallState::Connecting(ConnectingPhase::DiscoveringService)
        );
        assert!(!call.is_incoming);
        assert!(call.participants.is_empty());
        assert!(call.started_at.is_none());
    }

    #[test]
    fn new_outgoing_no_room_name() {
        let call = CallInfo::new_outgoing("!room:x".to_string(), None);
        assert!(call.room_name.is_none());
    }

    #[test]
    fn new_incoming_fields() {
        let call = CallInfo::new_incoming(
            "!room:x".to_string(),
            "@caller:x".to_string(),
            Some("Room".to_string()),
        );
        assert_eq!(call.room_id, "!room:x");
        assert!(call.is_incoming);
        assert_eq!(
            call.state,
            CallState::Connecting(ConnectingPhase::DiscoveringService)
        );
        assert_eq!(call.participants, vec!["@caller:x"]);
    }

    #[test]
    fn elapsed_display_no_start() {
        let call = CallInfo::new_outgoing("!room:x".to_string(), None);
        assert_eq!(call.elapsed_display(), "--:--");
    }

    #[test]
    fn elapsed_display_with_start() {
        let mut call = CallInfo::new_outgoing("!room:x".to_string(), None);
        call.started_at = Some(Instant::now());
        // Should show 00:00 or 00:01 depending on timing
        let display = call.elapsed_display();
        assert!(display.contains(':'));
        assert_eq!(display.len(), 5); // "MM:SS" format
    }

    #[test]
    fn elapsed_secs_none_when_not_started() {
        let call = CallInfo::new_outgoing("!room:x".to_string(), None);
        assert!(call.elapsed_secs().is_none());
    }
}