added remove_item() function to Queue

src/music_controller/queue.rs

@@ -1,7 +1,7 @@
 use uuid::Uuid;
 
-use crate::{music_player::Player, music_storage::library::{Album, Song}};
+use crate::{music_player::Player, music_storage::library::{Album, Song, URI}};
-use std::{error::Error, path::Path};
+use std::{error::Error, ops::Add, path::Path};
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum QueueState {
@@ -11,15 +11,31 @@ pub enum QueueState {
     None,
 }
 #[derive(Debug, Clone)]
+#[non_exhaustive]
 pub enum QueueItemType<'a> {
     Song(Uuid),
-    Album(Album<'a>)
+    ExternalSong(URI),
+    Album{
+        album: Album<'a>,
+        shuffled: bool,
+    }
+}
+
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub enum QueueSource {
+    Library,
+    Playlist(Uuid),
+    Search,
+    Queue,
+    File,
 }
 #[derive(Debug, Clone)]
 #[non_exhaustive]
 pub struct QueueItem<'a> {
     item: QueueItemType<'a>,
-    state: QueueState
+    state: QueueState,
+    source: QueueSource
 }
 
 
@@ -47,29 +63,34 @@ impl<'a> Queue<'a> {
         self.items.append(&mut tracks);
     }
 
-    pub fn current_index(&self) -> i16 {
+    pub fn current_index(&mut self) -> i16 {
-        let e  = self.items.iter().filter(|song| song.state == QueueState::Played ).collect::<Vec<&QueueItem>>().len();
+        let mut i = 1;
-        dbg!(&e);
+        let mut e  = self.items.iter().filter(|song| song.state == QueueState::Played ).collect::<Vec<&QueueItem>>().len();
-                e as i16 - 1
+        while e >= 51 {
+            self.items.remove(0);
+            e = self.items.iter().filter(|song| song.state == QueueState::Played ).collect::<Vec<&QueueItem>>().len();
+            i+=1;
+        }
+        e as i16 - 1
     }
 
-    pub fn add_item(&mut self, item: QueueItemType<'a>) -> Result<(), Box<dyn Error>> {
+    pub fn add_item(&mut self, item: QueueItemType<'a>, source: QueueSource) -> Result<(), Box<dyn Error>> {
         use QueueState::*;
         let ind = self.current_index();
         let mut i: i16 = 1;
-        self.items = self.items.iter().enumerate().map(|(j, item_)| {
+             self.items = self.items.iter().enumerate().map(|(j, item_)| {
             let mut item_ = item_.to_owned();
             if item_.state == AddHere {
-                i = j as i16 + 2;
+                i = j as i16 + 1 - ind;
                 item_.state = None;
             }
             if item_.state == Current {
-                i = j as i16 + 2;
+                i = j as i16 + 1 - ind;
             }
             item_
         }).collect::<Vec<QueueItem>>();
         let pos = (ind + i) as usize;
-        dbg!(&pos);
+        // dbg!(&pos, &i, &ind);
         self.items.insert(
             pos,
             QueueItem {
@@ -78,27 +99,48 @@ impl<'a> Queue<'a> {
                     Current
                 }else {
                     AddHere
-                }
+                },
+                source
             }
         );
         Ok(())
     }
+
+    pub fn remove_item(&mut self, index: usize) -> Result<(), Box<dyn Error>> {
+        use QueueState::*;
+        let ind = (self.current_index() + index as i16 + 1) as usize;
+
+        if ind < self.items.len() {
+            // update the state of the next item to replace the item being removed
+            if self.items.get(ind + 1).is_some() {
+                self.items[ind + 1].state = self.items[ind].state;
+            }
+            self.items[ind].state = None;
+            self.items.remove(ind);
+
+            Ok(())
+        }else {
+            Err("No Songs to remove!".into())
+        }
+    }
 }
 
 
 #[test]
-fn itemaddtest() {
+fn item_add_test() {
     let mut q = Queue::new().unwrap();
-    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    for _ in 0..5 {
-    dbg!(&q.items);
+        q.items.push(QueueItem { item: QueueItemType::Song(Uuid::new_v4()), state: QueueState::Played, source: QueueSource::Queue });
-    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    }
-    dbg!(&q.items);
+    for _ in 0..3 {
-    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+        q.add_item(QueueItemType::Song(Uuid::new_v4()), QueueSource::Library).unwrap();
-    dbg!(&q.items);
+    }
-    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    dbg!(&q.items, &q.items.len());
-    dbg!(&q.items);
+
-    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    for _ in 0..1 {
-    dbg!(&q.items);
+    q.remove_item(0).inspect_err(|e| println!("{e:?}"));
-    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    dbg!(&q.items.len());
-    dbg!(&q.items);
+    }
+
+    dbg!(&q.items, &q.items.len());
 }

src/music_storage/playlist.rs

@@ -24,6 +24,7 @@ pub enum SortOrder {
 }
 #[derive(Debug, Clone)]
 pub struct Playlist {
+    uuid: Uuid,
     title: String,
     cover: Option<AlbumArt>,
     tracks: Vec<Uuid>,
@@ -152,6 +153,7 @@ impl Playlist {
 impl Default for Playlist {
     fn default() -> Self {
         Playlist {
+            uuid: Uuid::new_v4(),
             title: String::default(),
             cover: None,
             tracks: Vec::default(),