Added function to add items to the queue.

currently does not work with songs that have the `Played` State

src/music_controller/controller.rs

@@ -27,6 +27,8 @@ use crate::{
     music_controller::queue::Queue,
 };
 
+use super::queue::{QueueItem, QueueState};
+
 pub struct Controller {
     // queues: Vec<Queue>,
     config: Arc<RwLock<Config>>,
@@ -74,7 +76,7 @@ enum QueueCmd {
     Test,
     Play,
     Pause,
-    SetSongs(Vec<Song>),
+    // SetSongs(Vec<QueueItem<QueueState>>),
     // SetLocation(URI),
     Enqueue(URI),
     SetVolume(f64),
@@ -248,10 +250,10 @@ impl Controller {
                             Err(_) => todo!()
                         }
                     },
-                    SetSongs(songs) => {
-                        queue.set_tracks(songs);
-                        in_thread.send(QueueResponse::Default).unwrap();
-                    },
+                    // SetSongs(songs) => {
+                    //     queue.set_tracks(songs);
+                    //     in_thread.send(QueueResponse::Default).unwrap();
+                    // },
                     Enqueue(uri) => {
                         queue.player.enqueue_next(&uri).unwrap();
 
@@ -287,12 +289,12 @@ impl Controller {
         Ok(())
     }
 
-    fn q_set_songs(&self, index: usize, songs: Vec<Song>) -> Result<(), Box<dyn Error>> {
-        let mail = &self.queue_mail[index];
-        mail.send(QueueCmd::SetSongs(songs))?;
-        dbg!(mail.recv()?);
-        Ok(())
-    }
+    // fn q_set_songs(&self, index: usize, songs: Vec<QueueItem<QueueState>>) -> Result<(), Box<dyn Error>> {
+    //     let mail = &self.queue_mail[index];
+    //     mail.send(QueueCmd::SetSongs(songs))?;
+    //     dbg!(mail.recv()?);
+    //     Ok(())
+    // }
 
     fn q_enqueue(&self, index: usize, uri: URI) -> Result<(), Box<dyn Error>> {
         let mail = &self.queue_mail[index];

src/music_controller/queue.rs

@@ -1,25 +1,104 @@
-use crate::{music_player::Player, music_storage::library::Song};
-use std::error::Error;
+use uuid::Uuid;
 
-pub struct Queue {
+use crate::{music_player::Player, music_storage::library::{Album, Song}};
+use std::{error::Error, path::Path};
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum QueueState {
+    Played,
+    Current,
+    AddHere,
+    None,
+}
+#[derive(Debug, Clone)]
+pub enum QueueItemType<'a> {
+    Song(Uuid),
+    Album(Album<'a>)
+}
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub struct QueueItem<'a> {
+    item: QueueItemType<'a>,
+    state: QueueState
+}
+
+
+#[derive(Debug)]
+pub struct Queue<'a> {
     pub player: Player,
     pub name: String,
-    pub songs: Vec<Song>,
+    pub items: Vec<QueueItem<'a>>,
 }
-impl Queue {
+
+impl<'a> Queue<'a> {
     pub fn new() -> Result<Self, Box<dyn Error>> {
         Ok(
             Queue {
             player: Player::new()?,
             name: String::new(),
-            songs: Vec::new()
+            items: Vec::new()
             }
         )
     }
 
-    pub fn set_tracks(&mut self, tracks: Vec<Song>) {
+    pub fn set_items(&mut self, tracks: Vec<QueueItem<'a>>) {
         let mut tracks = tracks;
-        self.songs.clear();
-        self.songs.append(&mut tracks);
+        self.items.clear();
+        self.items.append(&mut tracks);
+    }
+
+    pub fn current_index(&self) -> i16 {
+        let e  = self.items.iter().filter(|song| song.state == QueueState::Played ).collect::<Vec<&QueueItem>>().len();
+        dbg!(&e);
+                e as i16 - 1
+    }
+
+    pub fn add_item(&mut self, item: QueueItemType<'a>) -> 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_)| {
+            let mut item_ = item_.to_owned();
+            if item_.state == AddHere {
+                i = j as i16 + 2;
+                item_.state = None;
+            }
+            if item_.state == Current {
+                i = j as i16 + 2;
+            }
+            item_
+        }).collect::<Vec<QueueItem>>();
+        let pos = (ind + i) as usize;
+        dbg!(&pos);
+        self.items.insert(
+            pos,
+            QueueItem {
+                item: item.clone(),
+                state: if pos == self.items.len() && i == 1 {
+                    Current
+                }else {
+                    AddHere
+                }
+            }
+        );
+        Ok(())
     }
 }
+
+
+#[test]
+fn itemaddtest() {
+    let mut q = Queue::new().unwrap();
+    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    dbg!(&q.items);
+    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    dbg!(&q.items);
+    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    dbg!(&q.items);
+    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    dbg!(&q.items);
+    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    dbg!(&q.items);
+    q.add_item(QueueItemType::Song(Uuid::new_v4())).unwrap();
+    dbg!(&q.items);
+}

src/music_player.rs

@@ -90,6 +90,7 @@ enum PlaybackStats {
 }
 
 /// An instance of a music player with a GStreamer backend
+#[derive(Debug)]
 pub struct Player {
     source:     Option<URI>,
     //pub message_tx: Sender<PlayerCmd>,