156 refactor into workspaces (#157)

* chore: Major refactoring

Still needs a massive go-over because there shouldn't be anything referencing tauri in any of the workspaces except the original one. Process manager has been refactored as an example

Signed-off-by: quexeky <git@quexeky.dev>

* fix: Remote tauri dependency from process

Signed-off-by: quexeky <git@quexeky.dev>

* refactor: Improvements to src-tauri

Signed-off-by: quexeky <git@quexeky.dev>

* refactor: Builds, but some logic still left to move back

Signed-off-by: quexeky <git@quexeky.dev>

* refactor: Finish refactor

Signed-off-by: quexeky <git@quexeky.dev>

* chore: Run cargo clippy && cargo fmt

Signed-off-by: quexeky <git@quexeky.dev>

* refactor: Move everything into src-tauri

Signed-off-by: quexeky <git@quexeky.dev>

---------

Signed-off-by: quexeky <git@quexeky.dev>

src-tauri/download_manager/src/download_manager_frontend.rs

@@ -0,0 +1,186 @@
+use std::{
+    any::Any,
+    collections::VecDeque,
+    fmt::Debug,
+    sync::{
+        Mutex, MutexGuard,
+        mpsc::{SendError, Sender},
+    },
+    thread::JoinHandle,
+};
+
+use database::DownloadableMetadata;
+use log::{debug, info};
+use serde::Serialize;
+use utils::{lock, send};
+
+use crate::error::ApplicationDownloadError;
+
+use super::{
+    download_manager_builder::{CurrentProgressObject, DownloadAgent},
+    util::queue::Queue,
+};
+
+pub enum DownloadManagerSignal {
+    /// Resumes (or starts) the `DownloadManager`
+    Go,
+    /// Pauses the `DownloadManager`
+    Stop,
+    /// Called when a `DownloadAgent` has fully completed a download.
+    Completed(DownloadableMetadata),
+    /// Generates and appends a `DownloadAgent`
+    /// to the registry and queue
+    Queue(DownloadAgent),
+    /// Tells the Manager to stop the current
+    /// download, sync everything to disk, and
+    /// then exit
+    Finish,
+    /// Stops, removes, and tells a download to cleanup
+    Cancel(DownloadableMetadata),
+    /// Any error which occurs in the agent
+    Error(ApplicationDownloadError),
+    /// Pushes UI update
+    UpdateUIQueue,
+    UpdateUIStats(usize, usize), //kb/s and seconds
+}
+
+#[derive(Debug)]
+pub enum DownloadManagerStatus {
+    Downloading,
+    Paused,
+    Empty,
+    Error,
+}
+
+impl Serialize for DownloadManagerStatus {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&format!["{self:?}"])
+    }
+}
+
+#[derive(Serialize, Clone, Debug, PartialEq)]
+pub enum DownloadStatus {
+    Queued,
+    Downloading,
+    Validating,
+    Error,
+}
+
+/// Accessible front-end for the `DownloadManager`
+///
+/// The system works entirely through signals, both internally and externally,
+/// all of which are accessible through the `DownloadManagerSignal` type, but
+/// should not be used directly. Rather, signals are abstracted through this
+/// interface.
+///
+/// The actual download queue may be accessed through the .`edit()` function,
+/// which provides raw access to the underlying queue.
+/// THIS EDITING IS BLOCKING!!!
+#[derive(Debug)]
+pub struct DownloadManager {
+    terminator: Mutex<Option<JoinHandle<Result<(), ()>>>>,
+    download_queue: Queue,
+    progress: CurrentProgressObject,
+    command_sender: Sender<DownloadManagerSignal>,
+}
+
+#[allow(dead_code)]
+impl DownloadManager {
+    pub fn new(
+        terminator: JoinHandle<Result<(), ()>>,
+        download_queue: Queue,
+        progress: CurrentProgressObject,
+        command_sender: Sender<DownloadManagerSignal>,
+    ) -> Self {
+        Self {
+            terminator: Mutex::new(Some(terminator)),
+            download_queue,
+            progress,
+            command_sender,
+        }
+    }
+
+    pub fn queue_download(
+        &self,
+        download: DownloadAgent,
+    ) -> Result<(), SendError<DownloadManagerSignal>> {
+        info!("creating download with meta {:?}", download.metadata());
+        self.command_sender
+            .send(DownloadManagerSignal::Queue(download))?;
+        self.command_sender.send(DownloadManagerSignal::Go)
+    }
+    pub fn edit(&self) -> MutexGuard<'_, VecDeque<DownloadableMetadata>> {
+        self.download_queue.edit()
+    }
+    pub fn read_queue(&self) -> VecDeque<DownloadableMetadata> {
+        self.download_queue.read()
+    }
+    pub fn get_current_download_progress(&self) -> Option<f64> {
+        let progress_object = (*lock!(self.progress)).clone()?;
+        Some(progress_object.get_progress())
+    }
+    pub fn rearrange_string(&self, meta: &DownloadableMetadata, new_index: usize) {
+        let mut queue = self.edit();
+        let current_index =
+            get_index_from_id(&mut queue, meta).expect("Failed to get meta index from id");
+        let to_move = queue
+            .remove(current_index)
+            .expect("Failed to remove meta at index from queue");
+        queue.insert(new_index, to_move);
+        send!(self.command_sender, DownloadManagerSignal::UpdateUIQueue);
+    }
+    pub fn cancel(&self, meta: DownloadableMetadata) {
+        send!(self.command_sender, DownloadManagerSignal::Cancel(meta));
+    }
+    pub fn rearrange(&self, current_index: usize, new_index: usize) {
+        if current_index == new_index {
+            return;
+        }
+
+        let needs_pause = current_index == 0 || new_index == 0;
+        if needs_pause {
+            send!(self.command_sender, DownloadManagerSignal::Stop);
+        }
+
+        debug!("moving download at index {current_index} to index {new_index}");
+
+        let mut queue = self.edit();
+        let to_move = queue.remove(current_index).expect("Failed to get");
+        queue.insert(new_index, to_move);
+        drop(queue);
+
+        if needs_pause {
+            send!(self.command_sender, DownloadManagerSignal::Go);
+        }
+        send!(self.command_sender, DownloadManagerSignal::UpdateUIQueue);
+        send!(self.command_sender, DownloadManagerSignal::Go);
+    }
+    pub fn pause_downloads(&self) {
+        send!(self.command_sender, DownloadManagerSignal::Stop);
+    }
+    pub fn resume_downloads(&self) {
+        send!(self.command_sender, DownloadManagerSignal::Go);
+    }
+    pub fn ensure_terminated(&self) -> Result<Result<(), ()>, Box<dyn Any + Send>> {
+        send!(self.command_sender, DownloadManagerSignal::Finish);
+        let terminator = lock!(self.terminator).take();
+        terminator.unwrap().join()
+    }
+    pub fn get_sender(&self) -> Sender<DownloadManagerSignal> {
+        self.command_sender.clone()
+    }
+}
+
+/// Takes in the locked value from .`edit()` and attempts to
+/// get the index of whatever id is passed in
+fn get_index_from_id(
+    queue: &mut MutexGuard<'_, VecDeque<DownloadableMetadata>>,
+    meta: &DownloadableMetadata,
+) -> Option<usize> {
+    queue
+        .iter()
+        .position(|download_agent| download_agent == meta)
+}