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

use std::{
    fs::File,
    io::{BufRead, BufReader},
};

use clap::parser::ValuesRef;

/// Viewer struct used to perform view operations on file buffers.
pub struct Viewer {
    keywords: Option<Vec<String>>,
    line_range: Option<Vec<u32>>,
    date_range: Option<Vec<String>>,
}

impl Viewer {
    // TODO: Certain parameters cannot be used together.
    pub fn new(
        keywords: Option<ValuesRef<'_, String>>,
        line_range: Option<ValuesRef<'_, u32>>,
        date_range: Option<ValuesRef<'_, String>>,
    ) -> Viewer {
        match (keywords, line_range, date_range) {
            (Some(kw), Some(lr), None) => Viewer {
                keywords: Some(kw.into_iter().cloned().collect()),
                line_range: Some(lr.into_iter().copied().collect()),
                date_range: None,
            },
            (Some(kw), None, Some(dr)) => Viewer {
                keywords: Some(kw.into_iter().cloned().collect()),
                line_range: None,
                date_range: Some(dr.into_iter().cloned().collect()),
            },
            (Some(kw), None, None) => Viewer {
                keywords: Some(kw.into_iter().cloned().collect()),
                line_range: None,
                date_range: None,
            },
            (None, None, None) => Viewer {
                keywords: None,
                line_range: None,
                date_range: None,
            },
            (None, None, Some(dr)) => Viewer {
                keywords: None,
                line_range: None,
                date_range: Some(dr.into_iter().cloned().collect()),
            },
            (None, Some(lr), None) => Viewer {
                keywords: None,
                line_range: Some(lr.into_iter().copied().collect()),
                date_range: None,
            },
            (None, Some(_), Some(_)) => unreachable!(), // Invalid
            (Some(_), Some(_), Some(_)) => unreachable!(), // Invalid
        }
    }

    /// Display all lines within line range (inclusive).
    fn _display_with_lines(&self, _buffer: &mut BufReader<File>) {
        if self.line_range.is_none() {
            return;
        }
        // for line in buffer.lines().flatten() {
        //     println!("{}", line);
        // }
        unimplemented!()
    }

    /// Display all lines within date range (inlcusive).
    fn _display_with_dates(&self, _buffer: &mut BufReader<File>) {
        if self.date_range.is_none() {
            return;
        }

        // for line in buffer.lines().flatten() {
        //     println!("{}", line);
        // }
        unimplemented!()
    }

    /// Display all lines that contain any keyword.
    fn display_with_keywords(&self, buffer: &mut BufReader<File>) {
        if self.keywords.is_none() {
            return;
        }

        // Filter lines for lines that contain any of the keywords indicated by caller.
        let lines = buffer.lines().flatten().filter(|ln| {
            self.keywords
                .clone()
                .unwrap()
                .iter()
                .any(|kw| ln.contains(kw))
        });

        for line in lines {
            println!("{}", line);
        }
    }

    /// Display the entire file.
    fn display_all(&self, buffer: &mut BufReader<File>) {
        for line in buffer.lines().flatten() {
            println!("{}", line);
        }
    }

    /// Display with viewer function to display the file via its `BufReader`.
    // TODO:
    //       - Use `Result`
    //       - Validation and error handling.
    pub fn display_with(&self, buffer: &mut BufReader<File>) {
        if self.line_range.is_some() {
            return self._display_with_lines(buffer);
        }
        if self.date_range.is_some() {
            return self._display_with_dates(buffer);
        }

        if self.keywords.is_some() {
            return self.display_with_keywords(buffer);
        }

        self.display_all(buffer);
    }
}

#[test]
// TODO: More robust testing.
fn test_viewer() {
    let viewer_none = Viewer::new(None, None, None);

    assert_eq!(viewer_none.line_range, None);
    assert_eq!(viewer_none.date_range, None);
    assert_eq!(viewer_none.keywords, None);
}