1 files changed, 107 insertions, 0 deletions

diff --git a/src/manager.rs b/src/manager.rs
new file mode 100644
index 0000000..839c8dc
--- /dev/null
+++ b/src/manager.rs
@@ -0,0 +1,107 @@
+use crate::{
+    error::{AddError, Error, IOError, PullError},
+    feed::{Entry, Feed},
+    status::{PullStatus, StoreStatus},
+};
+
+use chrono::prelude::*;
+use url::Url;
+
+#[derive(Default)]
+pub struct Manager {
+    feeds: Vec<Feed>,
+}
+
+impl Manager {
+    pub async fn add_feed(&mut self, url: &str) -> Result<PullStatus, Error> {
+        let link = Url::parse(&url).map_err(|e| AddError::InvalidUrl(e.to_string()))?;
+
+        // check if this feed is already present
+        if self.feeds.iter().any(|f| f.link == link) {
+            return Err(AddError::DuplicateLink.into());
+        }
+
+        // construct a new feed
+        let mut feed = Feed::new(link.clone());
+
+        let status = feed
+            .pull()
+            .await
+            .map_err(|pull_err| Error::Pull(link, pull_err))?;
+
+        // add new feed
+        self.feeds.push(feed);
+
+        Ok(status)
+    }
+
+    pub async fn pull(&mut self) -> Vec<Result<PullStatus, PullError>> {
+        futures::future::join_all(self.feeds.iter_mut().map(Feed::pull)).await
+    }
+
+    pub fn list_entries(&self) -> impl Iterator<Item = &Entry> {
+        EntryIterator {
+            all_entries: self.feeds.iter().map(Feed::entries).collect(),
+        }
+    }
+
+    pub fn list_feeds(&self) -> impl Iterator<Item = &Feed> {
+        self.feeds.iter()
+    }
+
+    pub async fn store(&self) -> Result<StoreStatus, IOError> {
+        let path = crate::dirs::store_path().ok_or(IOError::MissingStorePath)?;
+        let content = serde_yaml::to_string(&self.feeds)?;
+        std::fs::write(path, content)?;
+
+        Ok(StoreStatus::new(self.feeds.len()))
+    }
+
+    pub async fn load() -> Result<Self, IOError> {
+        let path = crate::dirs::store_path().ok_or(IOError::MissingStorePath)?;
+        let content = std::fs::read_to_string(path)?;
+        let feeds = serde_yaml::from_str(&content)?;
+
+        Ok(Self { feeds })
+    }
+}
+
+struct EntryIterator<'e> {
+    all_entries: Vec<&'e [Entry]>,
+}
+
+impl<'e> Iterator for EntryIterator<'e> {
+    type Item = &'e Entry;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut min_index = None;
+        let mut last_date = DateTime::<Utc>::MIN_UTC;
+        for (idx, latest_entry) in self
+            .all_entries
+            .iter()
+            .map(|entries| entries.first())
+            .enumerate()
+        {
+            if let Some(entry) = latest_entry {
+                if last_date < entry.published {
+                    last_date = entry.published;
+                    min_index = Some(idx);
+                }
+            }
+        }
+
+        match min_index {
+            Some(idx) => {
+                let entries = self.all_entries.get_mut(idx).unwrap();
+                let e = &entries[0];
+                if entries.len() > 1 {
+                    *entries = &entries[1..];
+                } else {
+                    self.all_entries.remove(idx);
+                }
+                Some(e)
+            }
+            None => None,
+        }
+    }
+}