Update README.md

Made the program a lot more configurable and also cleaned up the parser
struct

.vscode/launch.json

@@ -0,0 +1,7 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [],
+}

Cargo.lock

@@ -462,7 +462,7 @@ dependencies = [
 
 [[package]]
 name = "ilovetv"
-version = "1.0.0"
+version = "1.1.0"
 dependencies = [
  "async-recursion",
  "bytes",

Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "ilovetv"
-version = "1.0.0"
+authors = ["Love Billenius <lovebillenius@disroot.org>"]
+version = "1.1.0"
 edition = "2021"
 
 [dependencies]

README.md

@@ -1,10 +1,10 @@
-# Iptvnator
+# I Love TV
 
 An iptvclient that is capable of parsing and reading m3uplaylists of essentially arbitrary sizes _blazingly fast_
 
 ## Install
 
-Just clone the repo and run `cargo build --release` to compile the project. Then put it in your `$PATH` or make a shortcut to the binary (target/release/iptvnator_rs)
+Just clone the repo and run `cargo build --release` to compile the project. Then put it in your `$PATH` or make a shortcut to the binary (target/release/ilovetv)
 You will need to install mpv, and have it in your path, otherwise it wont work
 
 ## Left to do

src/downloader.rs

@@ -1,6 +1,6 @@
 use std::{
-    fmt,
+    error, fmt,
-    fs::File,
+    fs::{File, OpenOptions},
     io::{self, Read, Write},
 };
 
@@ -31,7 +31,44 @@ impl DualWriter {
         Ok(())
     }
 
-    pub fn get_string(self) -> Result<String, String> {
+    pub fn len(&self) -> u64 {
+        match self {
+            DualWriter::File(f) => f.metadata().and_then(|x| Ok(x.len())).unwrap_or_else(|e| {
+                println!("Could not get metadata from file {:?}", e);
+                0
+            }),
+            DualWriter::Buffer(buf) => buf.len() as u64,
+        }
+    }
+}
+
+impl TryFrom<Option<&str>> for DualWriter {
+    type Error = io::Error;
+
+    fn try_from(file_name: Option<&str>) -> Result<Self, Self::Error> {
+        Ok(if let Some(file_name) = file_name {
+            let file = match OpenOptions::new().append(true).open(&file_name) {
+                Ok(f) => f,
+                Err(e) => {
+                    let e = e as io::Error;
+                    if e.kind() == io::ErrorKind::NotFound {
+                        File::create(&file_name)?
+                    } else {
+                        return Err(e);
+                    }
+                }
+            };
+            Self::File(file)
+        } else {
+            Self::Buffer(Vec::<u8>::new())
+        })
+    }
+}
+
+impl TryInto<String> for DualWriter {
+    type Error = String;
+
+    fn try_into(self) -> Result<String, Self::Error> {
         Ok(match self {
             Self::Buffer(buffer) => {
                 String::from_utf8(buffer).or(Err("Failed to decode buffer".to_owned()))?
@@ -47,41 +84,30 @@ impl DualWriter {
             }
         })
     }
-
-    pub fn new(file_name: Option<&str>) -> Result<Self, io::Error> {
-        Ok(if let Some(file_name) = file_name {
-            Self::File(File::create(&file_name)?)
-        } else {
-            Self::Buffer(Vec::<u8>::new())
-        })
-    }
 }
 
 pub async fn download_with_progress(
     link: &str,
     file_name: Option<&str>,
-) -> Result<DualWriter, String> {
+) -> Result<DualWriter, Box<dyn error::Error>> {
-    let mut dual_writer = DualWriter::new(file_name).or(Err("Failed to create file".to_owned()))?;
+    let mut dual_writer: DualWriter = file_name.try_into()?;
 
-    let client = Client::builder()
+    let client = Client::builder().gzip(true).deflate(true).build()?;
-        .gzip(true)
+    let builder = client
-        .deflate(true)
-        .build()
-        .or(Err("Failed to create client".to_owned()))?;
-    let resp = client
         .get(link)
-        .send()
+        .header("Range", format!("bytes={}-", dual_writer.len()));
-        .await
+
-        .or(Err("Failed to connect server".to_owned()))?;
+    let resp = builder.send().await?;
-    let content_length = if let Some(got_content_length) = resp.content_length() {
+
-        got_content_length
+    let content_length = resp.content_length().unwrap_or_default();
-    } else {
+    if content_length == 0 {
-        panic!("Could not retrive content length from server. {:?}", &resp);
+        println!("File was already downloaded");
-    };
+        return Ok(dual_writer);
+    }
 
     let progress_bar = ProgressBar::new(content_length);
     progress_bar.set_style(ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} ({eta})").unwrap()
-        .with_key("eta", |state: &ProgressState, w: &mut dyn fmt::Write| write!(w, "{:.1}s", state.eta().as_secs_f64()).unwrap())
+        .with_key("eta", |state: &ProgressState, w: &mut dyn fmt::Write| write!(w, "{:.1}m", state.eta().as_secs_f64() / 60.0 ).unwrap())
         .progress_chars("#>-"));
 
     let mut downloaded: u64 = 0;
@@ -90,9 +116,7 @@ pub async fn download_with_progress(
     while let Some(item) = stream.next().await {
         let bytes = item.unwrap();
         downloaded = cmp::min(downloaded + (bytes.len() as u64), content_length);
-        dual_writer
+        dual_writer.write(bytes)?;
-            .write(bytes)
-            .or(Err("Failed to write to file".to_owned()))?;
 
         progress_bar.set_position(downloaded);
     }

src/grandmother.rs

@@ -1,6 +1,7 @@
 #[allow(unused_imports)]
 use crate::GetM3u8;
 use crate::{
+    get_mut_ref,
     parser::{Parser, WatchedFind},
     Configuration, OfflineParser, OnlineParser, Playlist, MAX_TRIES,
 };
@@ -30,6 +31,11 @@ impl GrandMother {
         })
     }
 
+    pub fn demote_to_offline(&mut self) {
+        let offline_mother = GrandMother::new_offline(self.config.clone());
+        (self.parser, self.playlist) = (offline_mother.parser, offline_mother.playlist);
+    }
+
     pub async fn promote_to_online(&mut self) -> Result<(), Error> {
         let online_mother = GrandMother::new_online(self.config.clone()).await?;
         (self.parser, self.playlist) = (online_mother.parser, online_mother.playlist);
@@ -47,8 +53,7 @@ impl GrandMother {
     }
 
     pub async fn refresh_dirty(&self) -> Result<(), Error> {
-        let ptr = self as *const Self as *mut Self;
+        unsafe { get_mut_ref(self) }.refresh().await
-        unsafe { &mut *ptr }.refresh().await
     }
 
     pub async fn refresh(&mut self) -> Result<(), Error> {
@@ -70,19 +75,15 @@ impl GrandMother {
             println!("Retrying {}/{}", counter, MAX_TRIES);
         };
 
-        let watched_links = self
+        let watched_links = self.parser.get_watched_links();
-            .parser
+        let watched_links = watched_links.iter().map(|x| x.as_str()).collect();
-            .get_watched()
-            .iter()
-            .map(|x| x.link.as_str())
-            .collect();
         self.parser = Box::new(OnlineParser::new(&content, &watched_links).await);
 
         Ok(())
     }
 
     pub fn save_watched(&self) {
-        let watched_items = self.parser.get_watched();
+        let watched_items = self.parser.get_watched_links();
 
         let resp = fs::write(
             &self.config.seen_links_path,

src/lib.rs

@@ -8,7 +8,10 @@ mod opt;
 pub mod parser;
 mod playlist;
 
-use std::{io::{stdin, stdout, Stdin, StdoutLock, Write}, rc::Rc};
+use std::{
+    io::{stdin, stdout, Stdin, StdoutLock, Write},
+    rc::Rc,
+};
 
 use async_recursion::async_recursion;
 pub use config::Configuration;
@@ -65,10 +68,10 @@ pub async fn get_gm(
     mode: Mode,
     readline: &mut Readline<'_>,
     config: Rc<Configuration>,
-) -> Result<GrandMother, String> {
+) -> Result<(GrandMother, bool), String> {
     match mode {
-        Mode::Online => GrandMother::new_online(config).await,
+        Mode::Online => Ok((GrandMother::new_online(config).await?, true)),
-        Mode::Offline => Ok(GrandMother::new_offline(config)),
+        Mode::Offline => Ok((GrandMother::new_offline(config), false)),
         Mode::Ask => loop {
             let input = readline
                 .input("Online/Offline mode? [1/2] ")

src/main.rs

@@ -31,7 +31,7 @@ async fn main() {
             " {} is to make entries availibe for offline use later on in the program",
             "o".bold()
         ),
-        format!(" {} is to switch to online mode", "m".bold()),
+        format!(" {} is to switch between modes (toggle)", "m".bold()),
         format!(" {} is to perform a new search", "s".bold()),
         format!(" {} is to select all", "a".bold()),
         format!(" {} is to toggtle fullscreen for mpv", "f".bold()),
@@ -44,15 +44,10 @@ async fn main() {
     .iter()
     .for_each(|s| println!("{}", &s));
 
-    // let gm = GrandMother::new(Configuration::new().expect("Failed to write to configfile"))
-    //     .await
-    //     .unwrap();
-    // let parser = Parser::new(config.clone()).await;
-
     let mut mpv_fs = false;
     let mut search_result: Option<Rc<Vec<&M3u8>>> = None;
     let mut readline = Readline::new();
-    let gm = get_gm(
+    let (gm, mut in_online) = get_gm(
         opt.mode,
         &mut readline,
         Rc::new(Configuration::new().expect("Failed to write to configfile")),
@@ -105,10 +100,19 @@ async fn main() {
                     continue;
                 }
                 "m" => {
+                    if in_online {
+                        unsafe { get_mut_ref(&gm) }.demote_to_offline();
+                        println!("Switched to offline mode");
+                    } else {
                         let result = unsafe { get_mut_ref(&gm) }.promote_to_online().await;
                         if let Err(e) = result {
                             println!("Failed to switch to onlinemode {:?}", e);
+                        } else {
+                            println!("Switched to online mode");
+                            continue;
                         }
+                    }
+                    in_online = !in_online;
                     continue;
                 }
                 _ => {}
@@ -178,7 +182,22 @@ async fn main() {
                     ask_which_to_download(&mut readline, &search_result.as_ref().unwrap());
 
                 for to_download in download_selections.iter() {
-                    let path = gm.config.data_dir.join(&to_download.name);
+                    let file_ending = to_download
+                        .name
+                        .rfind(".")
+                        .map(|dot_idx| {
+                            if dot_idx < 6 {
+                                &to_download.name[dot_idx..]
+                            } else {
+                                ".mkv"
+                            }
+                        })
+                        .unwrap_or_else(|| ".mkv");
+
+                    let path = gm
+                        .config
+                        .data_dir
+                        .join(format!("{}{}", &to_download.name, file_ending));
                     let path = Rc::new(path.to_string_lossy().to_string());
                     download_m3u8(to_download, Some(&path)).await;
                     let data_entry = OfflineEntry::new((*to_download).clone(), path);
@@ -214,7 +233,6 @@ async fn main() {
                     println!("Not possible to refresh playlist while in offlinemode");
                     continue;
                 };
-
                 stream(to_play, &*path_link, mpv_fs);
                 gm.save_watched();
             }

src/offlineparser.rs

@@ -6,12 +6,12 @@ use crate::{m3u8::M3u8, Configuration, GetM3u8, GetPlayPath, OfflineEntry};
 
 #[derive(Serialize)]
 pub struct OfflineParser {
-    m3u8_items: Rc<Vec<OfflineEntry>>,
+    offline_entries: Rc<Vec<OfflineEntry>>,
 }
 impl OfflineParser {
     pub fn new(config: &Configuration) -> Self {
         Self {
-            m3u8_items: config.offlinefile_content.clone(),
+            offline_entries: config.offlinefile_content.clone(),
         }
     }
 }
@@ -20,13 +20,13 @@ impl Deref for OfflineParser {
     type Target = Vec<OfflineEntry>;
 
     fn deref(&self) -> &Self::Target {
-        &*self.m3u8_items
+        &*self.offline_entries
     }
 }
 
 impl GetPlayPath for OfflineParser {
     fn get_path_to_play(&self, link: Rc<String>) -> Result<Rc<String>, String> {
-        for offline_entry in &*self.m3u8_items {
+        for offline_entry in &*self.offline_entries {
             if *offline_entry.link == *link {
                 return Ok(offline_entry.path.clone());
             }
@@ -37,6 +37,8 @@ impl GetPlayPath for OfflineParser {
 
 impl GetM3u8 for OfflineParser {
     fn get_m3u8(&self) -> Vec<&M3u8> {
-        self.m3u8_items.iter().map(|x| &**x).collect()
+        let mut items: Vec<&M3u8> = self.offline_entries.iter().map(|x| &**x).collect();
+        items.sort_by_key(|x| &x.link);
+        items
     }
 }

src/parser.rs

@@ -8,7 +8,7 @@ pub trait GetM3u8 {
 
 pub trait WatchedFind {
     fn find(&self, name: &str) -> Vec<&M3u8>;
-    fn get_watched(&self) -> Vec<&M3u8>;
+    fn get_watched_links(&self) -> Vec<Rc<String>>;
 }
 
 impl<T: ?Sized + GetM3u8> WatchedFind for T {
@@ -20,8 +20,12 @@ impl<T: ?Sized + GetM3u8> WatchedFind for T {
             .collect()
     }
 
-    fn get_watched(&self) -> Vec<&M3u8> {
+    fn get_watched_links(&self) -> Vec<Rc<String>> {
-        self.get_m3u8().into_iter().filter(|x| x.watched).collect()
+        self.get_m3u8()
+            .into_iter()
+            .filter(|x| x.watched)
+            .map(|x| x.link.clone())
+            .collect()
     }
 }
 pub trait GetPlayPath {

src/playlist.rs

@@ -1,6 +1,8 @@
 use std::{fs, ops::Deref, path::PathBuf, rc::Rc};
 
-use crate::{download_with_progress, downloader::DualWriter, MAX_TRIES};
+use crate::{download_with_progress, MAX_TRIES};
+
+type Error = String;
 
 pub struct Playlist {
     pub content: String,
@@ -31,24 +33,23 @@ impl Playlist {
         fs::metadata(&*self.path_to_playlist)
             .and_then(|metadata| {
                 Ok({
-                    let seconds = metadata.modified()?;
+                    metadata
-                    seconds
+                        .modified()?
                         .elapsed()
-                        .expect("Failed to get systemtime")
+                        .map(|x| x.as_secs() > 60 * 60 * 24 * 3)
-                        .as_secs()
+                        .unwrap_or_else(|_| {
-                        > 60 * 60 * 24 * 3
+                            println!("Could not get systemtime, trying to download new file");
+                            true
                         })
                 })
-            .map_or_else(
+            })
-                |_| {
+            .unwrap_or_else(|_| {
-                    println!("Could not find playlist-file, Downloading a new one");
+                println!("Could not find a saved playlist, Downloading a new one");
                 false
-                },
+            })
-                |x| x,
-            )
     }
 
-    pub async fn get_saved_or_download(&self) -> Result<String, String> {
+    pub async fn get_saved_or_download(&self) -> Result<String, Error> {
         let content = if let Some(content) = self.get_saved() {
             content
         } else {
@@ -66,7 +67,7 @@ impl Playlist {
         Ok(content)
     }
 
-    pub async fn download(&self) -> Result<String, String> {
+    pub async fn download(&self) -> Result<String, Error> {
         let mut counter: u8 = 0;
         loop {
             counter += 1;
@@ -79,8 +80,9 @@ impl Playlist {
 
             let downloaded = download_with_progress(&url, None)
                 .await
-                .and_then(DualWriter::get_string);
+                .map(TryInto::try_into);
-            if let Ok(content) = downloaded {
+
+            if let Ok(Ok(content)) = downloaded {
                 break Ok(content);
             } else if counter > MAX_TRIES {
                 break Err("Failed to download playlist".to_owned());