summaryrefslogtreecommitdiffstats
path: root/src/display/components/header_details.rs
blob: a3b07664c647325f7e7390bb71ea45738a59d7d7 (plain)
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
use ::tui::backend::Backend;
use ::tui::layout::{Alignment, Rect};
use ::tui::style::{Color, Modifier, Style};
use ::tui::terminal::Frame;
use ::tui::widgets::{Paragraph, Text, Widget};

use crate::display::{DisplayBandwidth, UIState};

const SECONDS_IN_DAY: u64 = 86400;

pub struct HeaderDetails<'a> {
    pub state: &'a UIState,
    pub elapsed_time: std::time::Duration,
    pub paused: bool,
}

impl<'a> HeaderDetails<'a> {
    #[allow(clippy::int_plus_one)]
    pub fn render(&self, frame: &mut Frame<impl Backend>, rect: Rect) {
        let bandwidth = self.bandwidth_string();
        let mut elapsed_time = None;
        let print_elapsed_time = if self.state.cumulative_mode {
            elapsed_time = Some(self.elapsed_time_string());
            bandwidth.len() + elapsed_time.as_ref().unwrap().len() + 1 <= rect.width as usize
        } else {
            false
        };

        let color = if self.paused {
            Color::Yellow
        } else {
            Color::Green
        };

        if print_elapsed_time {
            self.render_elapsed_time(frame, rect, elapsed_time.as_ref().unwrap(), color);
        }
        self.render_bandwidth(frame, rect, &bandwidth, color);
    }

    fn render_bandwidth(
        &self,
        frame: &mut Frame<impl Backend>,
        rect: Rect,
        bandwidth: &str,
        color: Color,
    ) {
        let bandwidth_text = {
            [Text::styled(
                bandwidth,
                Style::default().fg(color).modifier(Modifier::BOLD),
            )]
        };

        Paragraph::new(bandwidth_text.iter())
            .alignment(Alignment::Left)
            .render(frame, rect);
    }

    fn bandwidth_string(&self) -> String {
        let c_mode = self.state.cumulative_mode;
        format!(
            " Total Up / Down: {} / {}{}",
            DisplayBandwidth {
                bandwidth: self.state.total_bytes_uploaded as f64,
                as_rate: !c_mode,
            },
            DisplayBandwidth {
                bandwidth: self.state.total_bytes_downloaded as f64,
                as_rate: !c_mode,
            },
            if self.paused { " [PAUSED]" } else { "" }
        )
    }

    fn render_elapsed_time(
        &self,
        frame: &mut Frame<impl Backend>,
        rect: Rect,
        elapsed_time: &str,
        color: Color,
    ) {
        let elapsed_time_text = [Text::styled(
            elapsed_time,
            Style::default().fg(color).modifier(Modifier::BOLD),
        )];
        Paragraph::new(elapsed_time_text.iter())
            .alignment(Alignment::Right)
            .render(frame, rect);
    }

    fn days_string(&self) -> String {
        match self.elapsed_time.as_secs() / SECONDS_IN_DAY {
            0 => "".to_string(),
            1 => "1 day, ".to_string(),
            n => format!("{} days, ", n),
        }
    }

    fn elapsed_time_string(&self) -> String {
        format!(
            "{}{:02}:{:02}:{:02} ",
            self.days_string(),
            (self.elapsed_time.as_secs() % SECONDS_IN_DAY) / 3600,
            (self.elapsed_time.as_secs() % 3600) / 60,
            self.elapsed_time.as_secs() % 60
        )
    }
}