use anyhow::Result;
use clap::{Parser, Subcommand};
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::Mutex;

#[derive(Parser)]
#[command(name = "markbase-fuse", about = "MarkBase FUSE Mount Tool")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    Mount {
        #[arg(short, long)]
        user: String,
        #[arg(short, long)]
        dir: PathBuf,
        #[arg(short, long, default_value = "untitled folder")]
        tree_type: String,
    },
    Unmount {
        #[arg(short, long)]
        dir: PathBuf,
    },
}

fn main() -> Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Commands::Mount { user, dir, tree_type } => {
            mount_user(user, tree_type, dir)?;
        }
        Commands::Unmount { dir } => {
            unmount_user(dir)?;
        }
    }

    Ok(())
}

fn mount_user(user: String, tree_type: String, dir: PathBuf) -> Result<()> {
    use fuse::mount;
    use markbase_fuse::MarkBaseFs;
    use std::env::current_dir;

    let mut db_path = current_dir()?;
    db_path.push(format!("data/users/{}.sqlite", user));

    if !db_path.exists() {
        return Err(anyhow::anyhow!(
            "User database not found: {}",
            db_path.display()
        ));
    }

    if !dir.exists() {
        std::fs::create_dir_all(&dir)?;
    }

    println!("=== MarkBase FUSE (fuse crate + FUSE-T) ===");
    println!("User: {}", user);
    println!("Tree Type: {}", tree_type);
    println!("Database: {}", db_path.display());
    println!("Mount point: {}", dir.display());
    println!("");

    let fs = MarkBaseFs::new(&db_path.to_string_lossy(), &tree_type)?;
    let fs = Arc::new(Mutex::new(fs));

    let options = vec![
        "-o",
        "rw",
        "-o",
        "allow_other",
        "-o",
        "noatime",
        "-o",
        "local",
        "-o",
        "big_writes",
        "-o",
        "max_read=524288",
        "-o",
        "max_write=524288",
        "-o",
        "kernel_cache",
    ];

    mount(fs, &dir, &options)?;

    println!("Mounted successfully!");
    println!("Press Ctrl+C to unmount...");

    Ok(())
}
fn unmount_user(dir: PathBuf) -> Result<()> {
    println!("Unmounting: {}", dir.display());

    std::process::Command::new("umount").arg(&dir).status()?;

    println!("Unmounted successfully");
    Ok(())
}