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

#[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_backend_rs::api::server::Server;
    use fuse_backend_rs::transport::FuseSession;
    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-backend-rs + 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 server = Arc::new(Server::new(fs));

    let mut session = FuseSession::new(&dir, "markbase", "markbase-fuse", false)?;
    session.mount()?;

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

    let mut channel = session.new_channel()?;

    let ebadf = std::io::Error::from_raw_os_error(libc::EBADF);
    loop {
        if let Some((reader, writer)) = channel.get_request()? {
            if let Err(e) = server.handle_message(reader, writer.into(), None, None) {
                match e {
                    fuse_backend_rs::Error::EncodeMessage(e)
                        if e.kind() == std::io::ErrorKind::Other =>
                    {
                        break;
                    }
                    _ => {
                        eprintln!("Handling fuse message failed: {:?}", e);
                        continue;
                    }
                }
            }
        } else {
            println!("fuse server exits");
            break;
        }
    }

    session.umount()?;
    println!("Unmounted successfully");

    Ok(())
}

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

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

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