path: root/src/commands/file_operations.rs

use lazy_static::lazy_static;
use std::path;
use std::sync::{atomic, mpsc, Mutex};
use std::thread;
use std::time;

use crate::commands::{self, JoshutoCommand, JoshutoRunnable, ProgressInfo};
use crate::context::JoshutoContext;
use crate::structs::JoshutoDirList;

lazy_static! {
    static ref selected_files: Mutex<Vec<path::PathBuf>> = Mutex::new(vec![]);
    static ref fileop: Mutex<FileOp> = Mutex::new(FileOp::Copy);
    static ref tab_src: atomic::AtomicUsize = atomic::AtomicUsize::new(0);
}

pub struct FileOperationThread {
    pub tab_src: usize,
    pub tab_dest: usize,
    pub handle: thread::JoinHandle<i32>,
    pub recv: mpsc::Receiver<ProgressInfo>,
}

impl FileOperationThread {
    pub fn recv_timeout(
        &self,
        wait_duration: &time::Duration,
    ) -> Result<ProgressInfo, mpsc::RecvTimeoutError> {
        self.recv.recv_timeout(*wait_duration)
    }
}

fn set_file_op(operation: FileOp) {
    let mut data = fileop.lock().unwrap();
    *data = operation;
}

fn set_tab_src(tab_index: usize) {
    tab_src.store(tab_index, atomic::Ordering::Release);
}

fn repopulated_selected_files(dirlist: &JoshutoDirList) -> bool {
    if let Some(contents) = commands::collect_selected_paths(dirlist) {
        let mut data = selected_files.lock().unwrap();
        *data = contents;
        return true;
    }
    false
}

enum FileOp {
    Cut,
    Copy,
}

#[derive(Clone, Debug)]
pub struct CopyOptions {
    pub overwrite: bool,
    pub skip_exist: bool,
}

#[derive(Clone, Debug)]
pub struct CutFiles;

impl CutFiles {
    pub fn new() -> Self {
        CutFiles
    }
    pub const fn command() -> &'static str {
        "cut_files"
    }
}

impl JoshutoCommand for CutFiles {}

impl std::fmt::Display for CutFiles {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(Self::command())
    }
}

impl JoshutoRunnable for CutFiles {
    fn execute(&self, context: &mut JoshutoContext) {
        let curr_tab = context.curr_tab_ref();
        if let Some(s) = curr_tab.curr_list.as_ref() {
            if repopulated_selected_files(s) {
                set_file_op(FileOp::Cut);
                set_tab_src(context.curr_tab_index);
            }
        }
    }
}

#[derive(Clone, Debug)]
pub struct CopyFiles;

impl CopyFiles {
    pub fn new() -> Self {
        CopyFiles
    }
    pub const fn command() -> &'static str {
        "copy_files"
    }
}

impl JoshutoCommand for CopyFiles {}

impl std::fmt::Display for CopyFiles {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(Self::command())
    }
}

impl JoshutoRunnable for CopyFiles {
    fn execute(&self, context: &mut JoshutoContext) {
        let curr_tab = context.curr_tab_ref();
        if let Some(s) = curr_tab.curr_list.as_ref() {
            if repopulated_selected_files(s) {
                set_file_op(FileOp::Copy);
                set_tab_src(context.curr_tab_index);
            }
        }
    }
}

pub struct PasteFiles {
    options: fs_extra::dir::CopyOptions,
}

impl PasteFiles {
    pub fn new(options: fs_extra::dir::CopyOptions) -> Self {
        PasteFiles { options }
    }
    pub const fn command() -> &'static str {
        "paste_files"
    }

    #[cfg(target_os = "linux")]
    fn cut(&self, context: &mut JoshutoContext) -> Result<FileOperationThread, std::io::Error> {
        use std::os::linux::fs::MetadataExt;

        let tab_dest = context.curr_tab_index;
        let tab_src_index = tab_src.load(atomic::Ordering::SeqCst);

        let options = self.options.clone();
        let mut destination = context.tabs[tab_dest].curr_path.clone();

        let dest_ino = destination.metadata()?.st_dev();
        let path_ino;
        {
            let paths = selected_files.lock().unwrap();
            if paths.len() == 0 {
                return Err(std::io::Error::new(
                    std::io::ErrorKind::Other,
                    "no files selected",
                ));
            }
            path_ino = paths[0].metadata()?.st_dev();
        }

        let (tx, rx) = mpsc::channel();
        let handle = if dest_ino == path_ino {
            thread::spawn(move || {
                let mut paths = selected_files.lock().unwrap();
                let mut progress_info = ProgressInfo {
                    bytes_finished: 1,
                    total_bytes: paths.len() as u64 + 1,
                };

                for path in (*paths).iter() {
                    let file_name = path.file_name().unwrap().to_os_string();

                    destination.push(file_name.clone());

                    if destination.exists() {
                        if !options.skip_exist {
                            for i in 0.. {
                                if !destination.exists() {
                                    break;
                                }
                                destination.pop();
                                let mut file_name = file_name.clone();
                                file_name.push(&format!("_{}", i));
                                destination.push(file_name);
                            }
                            std::fs::rename(&path, &destination);
                        }
                    } else {
                        std::fs::rename(&path, &destination);
                    }
                    destination.pop();
                    progress_info.bytes_finished += 1;
                    tx.send(progress_info.clone()).unwrap();
                }
                paths.clear();
                0
            })
        } else {
            thread::spawn(move || {
                let mut paths = selected_files.lock().unwrap();

                let handle = |process_info: fs_extra::TransitProcess| {
                    let progress_info = ProgressInfo {
                        bytes_finished: process_info.copied_bytes,
                        total_bytes: process_info.total_bytes,
                    };
                    tx.send(progress_info).unwrap();
                    fs_extra::dir::TransitProcessResult::ContinueOrAbort
                };

                fs_extra::move_items_with_progress(&paths, &destination, &options, handle).unwrap();
                paths.clear();
                0
            })
        };
        let thread = FileOperationThread {
            tab_src: tab_src_index,
            tab_dest,
            handle,
            recv: rx,
        };
        Ok(thread)
    }

    #[cfg(not(target_os = "linux"))]
    fn cut(&self, context: &mut JoshutoContext) -> Result<FileOperationThread, std::io::Error> {
        let tab_dest = context.curr_tab_index;
        let tab_src_index = tab_src.load(atomic::Ordering::SeqCst);

        let mut destination = context.tabs[tab_dest].curr_path.clone();
        let options = self.options.clone();

        {
            let paths = selected_files.lock().unwrap();
            if paths.len() == 0 {
                return Err(std::io::Error::new(
                    std::io::ErrorKind::Other,
                    "no files selected",
                ));
            }
        }
        let (tx, rx) = mpsc::channel();

        let handle = thread::spawn(move || {
            let mut paths = selected_files.lock().unwrap();

            let handle = |process_info: fs_extra::TransitProcess| {
                let progress_info = ProgressInfo {
                    bytes_finished: process_info.copied_bytes,
                    total_bytes: process_info.total_bytes,
                };