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

/// ## Log rotation
/// From version 1.0.39, you can create a `log rotator` instance which allows you to split logs by their size and duration.
/// - log_path: path to log directory;
/// - max_size (`u64`): maximum size of log file;
/// - max_life (`std::time::Duration`): maximum lifetime of log file;
/// 
/// Here's an example:
/// ```rust
/// use logger_rust::*; // importing 
/// use std::{
///     path::PathBuf,
///     time::Duration
/// };
/// 
/// fn main() {
///     set_log_level(LogLevel::File);
///     set_log_path(LogConfig::Rotator(LogRotatorConfig::new(
///         PathBuf::from("C:/Users/JK/Desktop"),
///         5 * 1024 * 1024,
///         Duration::from_secs(3600),
///     )));
/// }
/// ```

use std::{
    time::Duration,
    path::PathBuf,
};
pub enum LogConfig {
    /// # LogConfig enum
    /// Defines the Path variable as std::PathBuf for path
    /// And a Rotator variable linked to the LogRotatorConfig implementor
    Path(LogPath),
    Rotator(LogRotatorConfig),
}

pub enum LogPath {
    /// # LogPath enum
    /// Defines the Path variable as std::PathBuf for path
    /// What should i even write here and why?
    Path(PathBuf),
}

pub struct LogRotatorConfig {
    /// # LogRotatorConfig struct
    /// Defines the public variables for LogRotator instanse
    /// `log_path` = string
    /// `max-size` = u64 (e.g 5 * 1024 * 1024)
    /// `max_time` = time::Duration
    pub log_path: PathBuf,
    pub max_size: u64,
    pub max_time: Duration,
}

impl LogRotatorConfig {
    pub fn new(log_path: PathBuf, max_size: u64, max_time: Duration) -> Self {
        //! # LogRotatorConfig::New
        //! The inializer for configuration of log rotator:
        //! ```rust
        //! use logger_rust::*;
        //! use std::time::Duration;
        //! use std::path::PathBuf;
        //! 
        //! fn main() {
        //!     set_log_level(LogLevel::File);
        //!     set_log_path(LogConfig::Rotator(LogRotatorConfig::new(
        //!         PathBuf::from("C:/Users/qruie/Documents"), // Logging directory
        //!         5 * 1024 * 1024, // 5MB
        //!         Duration::from_secs(2), // Duration for log splits
        //!     )));
        //! }
        //! ```
        Self {
            log_path,
            max_size,
            max_time,
        }
    }
}

impl From<&str> for LogPath {
/// `From` trait implementation for `LogPath` that allows it to be constructed from a string slice.
///
/// # Examples
///
/// ```
/// use logger_rust::*;
///
/// fn main() {
///     set_log_level(LogLevel::File);
///     set_log_path(LogConfig::Path(LogPath::from("C:/Users/qruie/Documents")));
///     // ..
/// }
/// ```
    fn from(s: &str) -> Self {
        Self::Path(PathBuf::from(s))
    }
}

impl From<PathBuf> for LogPath {
/// `From` trait implementation for `LogPath` that allows it to be constructed from a `PathBuf`.
///
/// # Examples
///
/// ```
/// use logger_rust::*;
/// use std::path::PathBuf;
///
/// fn main() {
///     set_log_level(LogLevel::File);
///     set_log_path(LogConfig::Path(LogPath::from("C:/Users/qruie/Documents")));
///     // ..
/// }
/// ```
    fn from(path: PathBuf) -> Self {
        Self::Path(path)
    }
}