feat(queue): swap indices rpc

proto/player.proto

@@ -15,6 +15,7 @@ service Player {
 	rpc SetVolume(SetVolumeRequest) returns (SetVolumeResponse);
 	rpc PlayTrackNext(TrackRequest) returns (Queue);
 	rpc AddTrackToQueue(TrackRequest) returns (Queue);
+	rpc SwapQueueIndices(SwapQueueIndicesRequest) returns (Queue);
 	rpc SkipTrack(google.protobuf.Empty) returns (PlayerStatus);
 	rpc SkipToQueueIndex(SkipToQueueIndexRequest) returns (PlayerStatus);
 }
@@ -63,3 +64,8 @@ message SetVolumeResponse  {
 message SkipToQueueIndexRequest {
 	uint32 index = 1;
 }
+
+message SwapQueueIndicesRequest {
+	uint32 a = 1;
+	uint32 b = 2;
+}

src/music/player.rs

@@ -171,6 +171,20 @@ impl AudioPlayer {
             .await
     }
 
+    pub async fn swap_queue_indices(&mut self, a: usize, b: usize) -> bool {
+        let mut queue = self.queue.lock().await;
+
+        let len = queue.len();
+
+        if a >= len || b >= len {
+            return false;
+        }
+
+        queue.swap(a, b);
+
+        true
+    }
+
     pub async fn resume(&self) {
         self.sink.lock().await.play();
     }

src/player.rs

@@ -12,7 +12,7 @@ use crate::{
         player::{
             player_server::Player, PauseState, PlayTrackResponse, PlayerStatus, Queue,
             SeekPositionRequest, SeekPositionResponse, SetVolumeRequest, SetVolumeResponse,
-            SkipToQueueIndexRequest, TrackRequest,
+            SkipToQueueIndexRequest, SwapQueueIndicesRequest, TrackRequest,
         },
     },
     state::GrooveState,
@@ -283,4 +283,34 @@ impl Player for PlayerService {
 
         Ok(tonic::Response::new(response))
     }
+
+    async fn swap_queue_indices(
+        &self,
+        request: tonic::Request<SwapQueueIndicesRequest>,
+    ) -> Result<tonic::Response<Queue>, tonic::Status> {
+        let input = request.get_ref();
+
+        let Ok(a) = input.a.try_into() else {
+            return Err(tonic::Status::internal(""));
+        };
+
+        let Ok(b) = input.b.try_into() else {
+            return Err(tonic::Status::internal(""));
+        };
+
+        let state = self.state.lock().await;
+        let mut player = state.player.lock().await;
+
+        if !player.swap_queue_indices(a, b).await {
+            return Err(tonic::Status::internal(""));
+        };
+
+        let queue = player.queue().await;
+
+        let response = Queue {
+            tracks: queue_to_track_vec(queue),
+        };
+
+        Ok(tonic::Response::new(response))
+    }
 }