cli/

main.rs

use clap::{Parser, Subcommand};
use cli_core::ssh_keys::{parse_authorized_keys_line, parse_public_key_file};
use cli_core::{CliSelectColumn, CliSshKeyAdd, CommandError, start_server};
use exitfailure::ExitFailure;
use log::LevelFilter;
use num_rational::Rational64;
use rpc::{ScriptCtx, Session};
use server::command::Argument;
use sqlx::types::Uuid;
use std::collections::HashMap;
use std::str::FromStr;

mod dispatch;
mod eval;

use cli_core::reports::coerce_date_arg;
use dispatch::run_and_print;
use eval::{RenderMode, build_create_transaction_form, escape_str, eval_print};

#[derive(Debug, Clone)]
struct FieldContentPair {
    field: String,
    content: String,
}

impl FromStr for FieldContentPair {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts: Vec<&str> = s.splitn(2, '=').collect();
        if parts.len() == 2 {
            Ok(FieldContentPair {
                field: parts[0].to_string(),
                content: parts[1].to_string(),
            })
        } else {
            Err("Expected format `field=content`".to_string())
        }
    }
}

fn parse_rational(s: &str) -> Result<Rational64, String> {
    if let Some((num, denom)) = s.split_once('/') {
        let n: i64 = num
            .parse()
            .map_err(|e: std::num::ParseIntError| e.to_string())?;
        let d: i64 = denom
            .parse()
            .map_err(|e: std::num::ParseIntError| e.to_string())?;
        if d == 0 {
            return Err("denominator cannot be zero".to_string());
        }
        Ok(Rational64::new(n, d))
    } else {
        let n: i64 = s
            .parse()
            .map_err(|e: std::num::ParseIntError| e.to_string())?;
        Ok(Rational64::new(n, 1))
    }
}

#[derive(Parser, Debug)]
#[command(name = "nomisync", about = "Nomisync automation CLI")]
struct Cli {
    #[arg(short = 'u', long)]
    userid: Uuid,

    #[arg(short = 'd', long)]
    database: Option<String>,

    #[arg(long)]
    setopt: Option<FieldContentPair>,

    #[arg(long, default_value = "warn")]
    loglevel: LevelFilter,

    #[command(subcommand)]
    cmd: Command,
}

#[derive(Subcommand, Debug)]
enum Command {
    /// Print the software version
    Version,

    /// Access to accounts
    #[command(subcommand)]
    Account(AccountCmd),

    /// Access to transactions
    #[command(subcommand)]
    Transaction(TransactionCmd),

    /// Access to commodities
    #[command(subcommand)]
    Commodity(CommodityCmd),

    /// Access to configuration
    #[command(subcommand)]
    Config(ConfigCmd),

    /// Access to SQL database
    #[command(subcommand)]
    Sql(SqlCmd),

    /// Text-rendered report charts
    #[command(subcommand)]
    Reports(ReportsCmd),

    /// Manage SSH public keys for remote TUI access
    #[command(subcommand, name = "ssh-key")]
    SshKey(SshKeyCmd),
}

#[derive(Subcommand, Debug)]
enum SshKeyCmd {
    /// Register a public key for the current user
    Add {
        /// Path to a `.pub` OpenSSH public-key file
        #[arg(
            long,
            conflicts_with = "public_key",
            required_unless_present = "public_key"
        )]
        key_file: Option<String>,
        /// OpenSSH `authorized_keys` line passed inline
        #[arg(
            long,
            conflicts_with = "key_file",
            required_unless_present = "key_file"
        )]
        public_key: Option<String>,
        /// Optional human-readable label
        #[arg(long)]
        annotation: Option<String>,
    },
    /// List all keys for the current user
    List,
    /// Remove a key by its SHA-256 fingerprint
    Remove {
        /// Fingerprint, e.g. `SHA256:abc…`
        #[arg(long)]
        fingerprint: String,
    },
}

#[derive(Subcommand, Debug)]
enum AccountCmd {
    /// List all accounts
    List,
    /// Get the current balance and currency of an account
    Balance {
        #[arg(long)]
        account: Uuid,
    },
    /// Create new account
    Create {
        #[arg(long)]
        name: String,
        #[arg(long)]
        parent: Option<Uuid>,
    },
}

#[derive(Subcommand, Debug)]
enum TransactionCmd {
    /// List all transactions
    List {
        #[arg(long)]
        account: Option<Uuid>,
    },
    /// Create new transaction
    Create {
        #[arg(long)]
        from: Uuid,
        #[arg(long)]
        to: Uuid,
        #[arg(long)]
        from_currency: Uuid,
        #[arg(long)]
        to_currency: Uuid,
        #[arg(long, value_parser = parse_rational)]
        value: Rational64,
        #[arg(long, value_parser = parse_rational)]
        to_amount: Option<Rational64>,
        #[arg(long)]
        note: Option<String>,
    },
}

#[derive(Subcommand, Debug)]
enum CommodityCmd {
    /// List all commodities
    List,
    /// Create new commodity
    Create {
        #[arg(long)]
        symbol: String,
        #[arg(long)]
        name: String,
    },
}

#[derive(Subcommand, Debug)]
enum ConfigCmd {
    /// Print the value from config
    Get {
        #[arg(long)]
        name: String,
    },
    /// Set the value in config
    Set {
        #[arg(long)]
        name: String,
        #[arg(long)]
        value: String,
    },
}

#[derive(Subcommand, Debug)]
enum SqlCmd {
    /// Raw select of SQL table
    Selcol {
        #[arg(long)]
        field: String,
        #[arg(long)]
        table: String,
    },
}

#[derive(Subcommand, Debug)]
enum ReportsCmd {
    /// Balance chart (top-level accounts by magnitude)
    Balance {
        #[arg(long, default_value = "bar")]
        chart: String,
    },
    /// Activity chart (Income vs Expense over a period)
    Activity {
        #[arg(long)]
        from: String,
        #[arg(long)]
        to: String,
        #[arg(long, default_value = "bar")]
        chart: String,
    },
    /// Category breakdown chart (top-N tag values)
    Breakdown {
        #[arg(long)]
        from: String,
        #[arg(long)]
        to: String,
        #[arg(long, default_value = "bar")]
        chart: String,
    },
}

#[tokio::main]
async fn main() -> Result<(), ExitFailure> {
    let cli = Cli::parse();

    env_logger::Builder::new()
        .filter_level(cli.loglevel)
        .target(env_logger::Target::Stderr)
        .init();

    let setopt = cli.setopt.map(|p| (p.field, p.content));
    start_server(cli.database, setopt).await?;

    let session_result = Session::new(ScriptCtx::new(cli.userid));
    let mut session = match session_result {
        Ok(s) => s,
        Err(e) => {
            eprintln!("Error: session init failed: {e}");
            std::process::exit(1);
        }
    };

    let outcome = dispatch_command(&mut session, cli.userid, cli.cmd).await;
    match outcome {
        Ok(()) => Ok(()),
        Err(err) => {
            eprintln!("Error: {err}");
            std::process::exit(1);
        }
    }
}

async fn dispatch_command(
    session: &mut Session,
    userid: Uuid,
    cmd: Command,
) -> Result<(), CommandError> {
    match cmd {
        Command::Version => eval_print(session, "(get-version)", RenderMode::Scalar).await,
        Command::Account(c) => run_account(session, userid, c).await,
        Command::Transaction(c) => run_transaction(session, c).await,
        Command::Commodity(c) => run_commodity(session, c).await,
        Command::Config(c) => run_config(session, c).await,
        Command::Sql(c) => run_sql(c).await,
        Command::Reports(c) => run_reports(session, c).await,
        Command::SshKey(c) => run_ssh_key(session, userid, c).await,
    }
}

fn user_args(userid: Uuid) -> HashMap<&'static str, Argument> {
    let mut args = HashMap::new();
    args.insert("user_id", Argument::Uuid(userid));
    args
}

async fn run_account(
    session: &mut Session,
    _userid: Uuid,
    cmd: AccountCmd,
) -> Result<(), CommandError> {
    match cmd {
        AccountCmd::List => eval_print(session, "(list-accounts)", RenderMode::AccountList).await,
        AccountCmd::Balance { account } => {
            let form = format!("(get-balances {})", escape_str(&account.to_string()));
            eval_print(session, &form, RenderMode::BalanceList).await
        }
        AccountCmd::Create { name, parent } => {
            let parent_str = parent.map_or_else(String::new, |p| p.to_string());
            let form = format!(
                "(create-account {} {})",
                escape_str(&name),
                escape_str(&parent_str)
            );
            eval_print(session, &form, RenderMode::Scalar).await
        }
    }
}

async fn run_transaction(session: &mut Session, cmd: TransactionCmd) -> Result<(), CommandError> {
    match cmd {
        TransactionCmd::List { account } => {
            let account_str = account.map_or_else(String::new, |a| a.to_string());
            let form = format!("(list-transactions {})", escape_str(&account_str));
            eval_print(session, &form, RenderMode::TransactionList).await
        }
        TransactionCmd::Create {
            from,
            to,
            from_currency,
            to_currency,
            value,
            to_amount,
            note,
        } => {
            let form = build_create_transaction_form(
                from,
                to,
                from_currency,
                to_currency,
                value,
                to_amount,
                note.as_deref(),
            )?;
            eval_print(session, &form, RenderMode::Scalar).await
        }
    }
}

async fn run_commodity(session: &mut Session, cmd: CommodityCmd) -> Result<(), CommandError> {
    match cmd {
        CommodityCmd::List => {
            eval_print(session, "(list-commodities)", RenderMode::CommodityList).await
        }
        CommodityCmd::Create { symbol, name } => {
            let form = format!(
                "(create-commodity {} {})",
                escape_str(&symbol),
                escape_str(&name)
            );
            eval_print(session, &form, RenderMode::Scalar).await
        }
    }
}

async fn run_config(session: &mut Session, cmd: ConfigCmd) -> Result<(), CommandError> {
    match cmd {
        ConfigCmd::Get { name } => {
            let form = format!("(get-config {})", escape_str(&name));
            eval_print(session, &form, RenderMode::ConfigValue).await
        }
        ConfigCmd::Set { name, value } => {
            let form = format!("(set-config {} {})", escape_str(&name), escape_str(&value));
            eval_print(session, &form, RenderMode::Silent).await
        }
    }
}

async fn run_sql(cmd: SqlCmd) -> Result<(), CommandError> {
    match cmd {
        SqlCmd::Selcol { field, table } => {
            let mut args: HashMap<&str, Argument> = HashMap::new();
            args.insert("field", Argument::String(field));
            args.insert("table", Argument::String(table));
            run_and_print(&CliSelectColumn, args).await
        }
    }
}

async fn run_reports(session: &mut Session, cmd: ReportsCmd) -> Result<(), CommandError> {
    match cmd {
        ReportsCmd::Balance { chart } => {
            eval_print(
                session,
                "(balance-report)",
                RenderMode::ReportBalance { chart },
            )
            .await
        }
        ReportsCmd::Activity { from, to, chart } => {
            let from = coerce_date_arg(&from, false)?;
            let to = coerce_date_arg(&to, true)?;
            let form = format!(
                "(activity-report {} {})",
                escape_str(&from),
                escape_str(&to)
            );
            eval_print(session, &form, RenderMode::ReportActivity { chart }).await
        }
        ReportsCmd::Breakdown { from, to, chart } => {
            let from = coerce_date_arg(&from, false)?;
            let to = coerce_date_arg(&to, true)?;
            let form = format!(
                "(category-breakdown {} {})",
                escape_str(&from),
                escape_str(&to)
            );
            eval_print(session, &form, RenderMode::ReportBreakdown { chart }).await
        }
    }
}

async fn run_ssh_key(
    session: &mut Session,
    userid: Uuid,
    cmd: SshKeyCmd,
) -> Result<(), CommandError> {
    match cmd {
        SshKeyCmd::Add {
            key_file,
            public_key,
            annotation,
        } => {
            let parsed = if let Some(path) = key_file {
                parse_public_key_file(&path)
                    .map_err(|e| CommandError::Argument(format!("ssh-key parse: {e}")))?
            } else if let Some(line) = public_key {
                parse_authorized_keys_line(&line)
                    .map_err(|e| CommandError::Argument(format!("ssh-key parse: {e}")))?
            } else {
                return Err(CommandError::Argument(
                    "either --key-file or --public-key is required".to_string(),
                ));
            };
            let mut args = user_args(userid);
            args.insert("key_type", Argument::String(parsed.key_type));
            args.insert("key_blob", Argument::Data(parsed.key_blob));
            args.insert("fingerprint", Argument::String(parsed.fingerprint));
            let label = annotation.unwrap_or(parsed.comment);
            if !label.is_empty() {
                args.insert("annotation", Argument::String(label));
            }
            run_and_print(&CliSshKeyAdd, args).await
        }
        SshKeyCmd::List => eval_print(session, "(list-ssh-keys)", RenderMode::SshKeyList).await,
        SshKeyCmd::Remove { fingerprint } => {
            let form = format!("(remove-ssh-key {})", escape_str(&fingerprint));
            eval_print(session, &form, RenderMode::BoolSuccess).await
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use clap::Parser;

    #[test]
    fn field_content_pair_parses_key_value() {
        let p: FieldContentPair = "locale=en".parse().unwrap();
        assert_eq!(p.field, "locale");
        assert_eq!(p.content, "en");
    }

    #[test]
    fn field_content_pair_rejects_missing_equals() {
        assert!("locale".parse::<FieldContentPair>().is_err());
    }

    #[test]
    fn field_content_pair_handles_value_with_equals() {
        let p: FieldContentPair = "sql=SELECT 1=1".parse().unwrap();
        assert_eq!(p.field, "sql");
        assert_eq!(p.content, "SELECT 1=1");
    }

    #[test]
    fn parse_rational_handles_integer() {
        let r = parse_rational("42").unwrap();
        assert_eq!(r, Rational64::new(42, 1));
    }

    #[test]
    fn parse_rational_handles_fraction() {
        let r = parse_rational("3/4").unwrap();
        assert_eq!(r, Rational64::new(3, 4));
    }

    #[test]
    fn parse_rational_rejects_zero_denominator() {
        assert!(parse_rational("1/0").is_err());
    }

    #[test]
    fn parse_rational_rejects_non_numeric() {
        assert!(parse_rational("abc").is_err());
    }

    #[test]
    fn cli_parses_version_subcommand() {
        let uuid = Uuid::new_v4();
        let parsed =
            Cli::try_parse_from(["nomisync", "--userid", &uuid.to_string(), "version"]).unwrap();
        assert!(matches!(parsed.cmd, Command::Version));
    }

    #[test]
    fn cli_parses_reports_balance_with_flags() {
        let uuid = Uuid::new_v4();
        let parsed = Cli::try_parse_from([
            "nomisync",
            "--userid",
            &uuid.to_string(),
            "reports",
            "balance",
            "--chart",
            "line",
        ])
        .unwrap();
        let Command::Reports(ReportsCmd::Balance { chart }) = parsed.cmd else {
            panic!("expected reports balance");
        };
        assert_eq!(chart, "line");
    }

    #[test]
    fn cli_parses_account_create_with_optional_parent() {
        let uuid = Uuid::new_v4();
        let parsed = Cli::try_parse_from([
            "nomisync",
            "--userid",
            &uuid.to_string(),
            "account",
            "create",
            "--name",
            "Cash",
        ])
        .unwrap();
        let Command::Account(AccountCmd::Create { name, parent }) = parsed.cmd else {
            panic!("expected account create");
        };
        assert_eq!(name, "Cash");
        assert!(parent.is_none());
    }

    #[test]
    fn cli_parses_transaction_create_rational() {
        let uuid = Uuid::new_v4();
        let from = Uuid::new_v4();
        let to = Uuid::new_v4();
        let fc = Uuid::new_v4();
        let tc = Uuid::new_v4();
        let parsed = Cli::try_parse_from([
            "nomisync",
            "--userid",
            &uuid.to_string(),
            "transaction",
            "create",
            "--from",
            &from.to_string(),
            "--to",
            &to.to_string(),
            "--from-currency",
            &fc.to_string(),
            "--to-currency",
            &tc.to_string(),
            "--value",
            "100/1",
        ])
        .unwrap();
        let Command::Transaction(TransactionCmd::Create { value, .. }) = parsed.cmd else {
            panic!("expected transaction create");
        };
        assert_eq!(value, Rational64::new(100, 1));
    }

    #[test]
    fn cli_rejects_missing_userid() {
        let res = Cli::try_parse_from(["nomisync", "version"]);
        assert!(res.is_err());
    }
}