web/pages/transaction/

util.rs

//web/src/pages/transaction/util.rs - Shared utility functions for transaction operations

use axum::{Json, http::StatusCode};
use chrono::{Local, NaiveDateTime};
use finance::price::Price;
use num_rational::Rational64;
use serde::Deserialize;
use server::command::{CmdResult, FinanceEntity, commodity::GetCommodity};
use sqlx::types::Uuid;

/// Common `SplitData` structure used by both create and edit
#[derive(Deserialize, Debug)]
pub struct SplitData {
    pub amount: String,
    pub amount_converted: String,
    pub from_account: String,
    pub to_account: String,
    pub from_commodity: String,
    pub to_commodity: String,
    pub from_tags: Option<Vec<TagData>>,
    pub to_tags: Option<Vec<TagData>>,
}

#[derive(Deserialize, Debug)]
pub struct TagData {
    pub name: String,
    pub value: String,
    pub description: Option<String>,
}

/// Result of processing a single split
pub struct ProcessedSplit {
    pub from_split: finance::split::Split,
    pub to_split: finance::split::Split,
    pub price: Option<Price>,
    pub from_split_tags: Option<Vec<TagData>>,
    pub to_split_tags: Option<Vec<TagData>>,
}

/// Get account name by ID
pub async fn get_account_name(
    user_id: Uuid,
    account_id: Uuid,
) -> Result<String, Box<dyn std::error::Error>> {
    match server::command::account::GetAccount::new()
        .user_id(user_id)
        .account_id(account_id)
        .run()
        .await?
    {
        Some(CmdResult::TaggedEntities { entities, .. }) => {
            if let Some((FinanceEntity::Account(_account), tags)) = entities.first() {
                if let Some(FinanceEntity::Tag(name_tag)) = tags.get("name") {
                    Ok(name_tag.tag_value.clone())
                } else {
                    Ok("Unnamed Account".to_string())
                }
            } else {
                Ok("Unknown Account".to_string())
            }
        }
        _ => Ok("Unknown Account".to_string()),
    }
}

/// Get commodity symbol (or name as fallback) by ID
pub async fn get_commodity_name(
    user_id: Uuid,
    commodity_id: Uuid,
) -> Result<String, Box<dyn std::error::Error>> {
    match GetCommodity::new()
        .user_id(user_id)
        .commodity_id(commodity_id)
        .run()
        .await?
    {
        Some(CmdResult::TaggedEntities { entities, .. }) => {
            if let Some((FinanceEntity::Commodity(_commodity), tags)) = entities.first() {
                if let Some(FinanceEntity::Tag(symbol_tag)) = tags.get("symbol") {
                    Ok(symbol_tag.tag_value.clone())
                } else if let Some(FinanceEntity::Tag(name_tag)) = tags.get("name") {
                    Ok(name_tag.tag_value.clone())
                } else {
                    Ok("Unknown Currency".to_string())
                }
            } else {
                Ok("Unknown Currency".to_string())
            }
        }
        _ => Ok("Unknown Currency".to_string()),
    }
}

/// Parses a transaction date submitted by the create/edit form.
///
/// The browser's `datetime-local` control (and the default-date helper's
/// `toISOString().slice(0,16)`) submit `YYYY-MM-DDTHH:MM` — NOT RFC3339 — so
/// accepting only RFC3339 silently dropped every entered date to "now". Accept
/// the `datetime-local` shapes AND RFC3339; only a genuinely absent/empty/
/// unparseable value falls back to the current time.
#[must_use]
pub fn parse_transaction_date(date_str: Option<&str>) -> NaiveDateTime {
    date_str
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .and_then(parse_form_datetime)
        .unwrap_or_else(|| Local::now().naive_utc())
}

/// Parses the date shapes the form can submit, in order of likelihood:
/// `datetime-local` (`YYYY-MM-DDTHH:MM[:SS]`), a bare date, or RFC3339.
fn parse_form_datetime(s: &str) -> Option<NaiveDateTime> {
    use chrono::{NaiveDate, NaiveDateTime};
    for fmt in ["%Y-%m-%dT%H:%M", "%Y-%m-%dT%H:%M:%S"] {
        if let Ok(dt) = NaiveDateTime::parse_from_str(s, fmt) {
            return Some(dt);
        }
    }
    if let Ok(d) = NaiveDate::parse_from_str(s, "%Y-%m-%d") {
        return d.and_hms_opt(0, 0, 0);
    }
    chrono::DateTime::parse_from_rfc3339(s)
        .ok()
        .map(|dt| dt.naive_utc())
}

/// Parse and validate UUID with custom error message
pub fn parse_uuid(
    uuid_str: &str,
    field_name: &str,
) -> Result<Uuid, (StatusCode, Json<serde_json::Value>)> {
    Uuid::parse_str(uuid_str).map_err(|_| {
        let error_response = serde_json::json!({
            "status": "fail",
            "message": format!("Invalid {}: {}", field_name, uuid_str),
        });
        (StatusCode::BAD_REQUEST, Json(error_response))
    })
}

/// Validate basic amount parsing and positivity (without precision checking)
pub fn validate_basic_amount(
    amount_str: &str,
) -> Result<f64, (StatusCode, Json<serde_json::Value>)> {
    let amount_value = amount_str.parse::<f64>().map_err(|_| {
        let error_response = serde_json::json!({
            "status": "fail",
            "message": format!("Invalid amount: {}", amount_str),
        });
        (StatusCode::BAD_REQUEST, Json(error_response))
    })?;

    if amount_value <= 0.0 {
        let error_response = serde_json::json!({
            "status": "fail",
            "message": t!("Split amount must be positive"),
        });
        return Err((StatusCode::BAD_REQUEST, Json(error_response)));
    }

    Ok(amount_value)
}

/// Parse a decimal string directly into an exact rational (numerator, denominator).
///
/// `"153.81"` becomes `(15381, 100)` — no floating-point intermediary.
pub fn parse_amount_to_rational(
    amount_str: &str,
) -> Result<(i64, i64), (StatusCode, Json<serde_json::Value>)> {
    validate_basic_amount(amount_str)?;

    let trimmed = amount_str.trim();
    let (numer, denom) = if let Some(dot_pos) = trimmed.find('.') {
        let decimals = trimmed.len() - dot_pos - 1;
        let without_dot: String = trimmed.chars().filter(|c| *c != '.').collect();
        let n = without_dot.parse::<i64>().map_err(|_| {
            let error_response = serde_json::json!({
                "status": "fail",
                "message": format!("Cannot represent amount as rational: {}", amount_str),
            });
            (StatusCode::BAD_REQUEST, Json(error_response))
        })?;
        (n, 10_i64.pow(decimals as u32))
    } else {
        let n = trimmed.parse::<i64>().map_err(|_| {
            let error_response = serde_json::json!({
                "status": "fail",
                "message": format!("Cannot represent amount as rational: {}", amount_str),
            });
            (StatusCode::BAD_REQUEST, Json(error_response))
        })?;
        (n, 1)
    };

    let r = Rational64::new(numer, denom);
    Ok((*r.numer(), *r.denom()))
}

/// Process a single split data into finance entities
pub async fn process_split_data(
    tx_id: Uuid,
    split_data: SplitData,
) -> Result<ProcessedSplit, (StatusCode, Json<serde_json::Value>)> {
    validate_basic_amount(&split_data.amount)?;

    let from_account_id = parse_uuid(&split_data.from_account, "from account ID")?;
    let to_account_id = parse_uuid(&split_data.to_account, "to account ID")?;
    let from_commodity = parse_uuid(&split_data.from_commodity, "from commodity ID")?;
    let to_commodity = parse_uuid(&split_data.to_commodity, "to commodity ID")?;

    // Only validate amount_converted if currency conversion is needed
    let conversion = from_commodity != to_commodity;
    if conversion {
        validate_basic_amount(&split_data.amount_converted)?;
    }

    let (from_num, from_denom) = parse_amount_to_rational(&split_data.amount)?;

    let from_split_id = Uuid::new_v4();
    let to_split_id = Uuid::new_v4();

    let (to_num, to_denom, price) = if conversion {
        let (to_num, to_denom) = parse_amount_to_rational(&split_data.amount_converted)?;

        let price = build_conversion_price(
            &ConversionSide {
                split_id: from_split_id,
                commodity: from_commodity,
                num: from_num,
                denom: from_denom,
            },
            &ConversionSide {
                split_id: to_split_id,
                commodity: to_commodity,
                num: to_num,
                denom: to_denom,
            },
        );

        (to_num, to_denom, Some(price))
    } else {
        (from_num, from_denom, None)
    };

    // Create split entities
    let from_split = finance::split::Split {
        id: from_split_id,
        tx_id,
        account_id: from_account_id,
        commodity_id: from_commodity,
        value_num: -from_num,
        value_denom: from_denom,
        reconcile_state: None,
        reconcile_date: None,
        lot_id: None,
    };

    let to_split = finance::split::Split {
        id: to_split_id,
        tx_id,
        account_id: to_account_id,
        commodity_id: to_commodity,
        value_num: to_num,
        value_denom: to_denom,
        reconcile_state: None,
        reconcile_date: None,
        lot_id: None,
    };

    Ok(ProcessedSplit {
        from_split,
        to_split,
        price,
        from_split_tags: split_data.from_tags,
        to_split_tags: split_data.to_tags,
    })
}

/// Build a Price for a multi-currency split from rational components.
///
/// `from` is the spent amount (will be negated in the split),
/// `to` is the received amount in a different commodity.
/// Returns a Price whose rate converts `to` back to `from` units.
/// One side of a multi-currency conversion: which split, in which commodity,
/// for how much. The two sides are symmetric, which is why they share a type.
pub struct ConversionSide {
    pub split_id: Uuid,
    pub commodity: Uuid,
    pub num: i64,
    pub denom: i64,
}

#[must_use]
pub fn build_conversion_price(from: &ConversionSide, to: &ConversionSide) -> Price {
    Price {
        id: Uuid::new_v4(),
        date: chrono::Utc::now(),
        commodity_id: to.commodity,
        currency_id: from.commodity,
        commodity_split: Some(to.split_id),
        currency_split: Some(from.split_id),
        value_num: from.num * to.denom,
        value_denom: from.denom * to.num,
    }
}

/// Validate that splits are not empty
pub fn validate_splits_not_empty<T>(
    splits: &[T],
) -> Result<(), (StatusCode, Json<serde_json::Value>)> {
    if splits.is_empty() {
        let error_response = serde_json::json!({
            "status": "fail",
            "message": t!("At least one split is required for a transaction"),
        });
        return Err((StatusCode::BAD_REQUEST, Json(error_response)));
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use num_rational::Rational64;

    #[test]
    fn test_parse_amount_integer() {
        let (num, denom) = parse_amount_to_rational("25584").unwrap();
        assert_eq!(Rational64::new(num, denom), Rational64::from_integer(25584));
    }

    #[test]
    fn parse_transaction_date_accepts_datetime_local() {
        // The datetime-local control submits this shape; it must NOT fall back
        // to "now" (the pre-existing RFC3339-only bug).
        let dt = parse_transaction_date(Some("2026-06-15T09:30"));
        assert_eq!(dt.format("%Y-%m-%dT%H:%M").to_string(), "2026-06-15T09:30");
        let with_secs = parse_transaction_date(Some("2026-06-15T09:30:45"));
        assert_eq!(with_secs.format("%H:%M:%S").to_string(), "09:30:45");
    }

    #[test]
    fn parse_transaction_date_accepts_bare_date_and_rfc3339() {
        let bare = parse_transaction_date(Some("2026-06-15"));
        assert_eq!(
            bare.format("%Y-%m-%dT%H:%M").to_string(),
            "2026-06-15T00:00"
        );
        let rfc = parse_transaction_date(Some("2026-06-15T09:30:00+00:00"));
        assert_eq!(rfc.format("%Y-%m-%dT%H:%M").to_string(), "2026-06-15T09:30");
    }

    #[test]
    fn parse_transaction_date_empty_or_missing_uses_now() {
        // Only a genuinely absent/blank value falls back; a parseable date never
        // silently becomes "now".
        let a = parse_transaction_date(None);
        let b = parse_transaction_date(Some("   "));
        let now = Local::now().naive_utc();
        assert!((now - a).num_seconds().abs() < 5);
        assert!((now - b).num_seconds().abs() < 5);
    }

    #[test]
    fn test_parse_amount_fractional() {
        let (num, denom) = parse_amount_to_rational("153.81").unwrap();
        let r = Rational64::new(num, denom);
        assert_eq!(r, Rational64::new(15381, 100));
    }

    #[test]
    fn test_conversion_price_jpy_usd() {
        let from_id = Uuid::new_v4();
        let to_id = Uuid::new_v4();
        let from_commodity = Uuid::new_v4();
        let to_commodity = Uuid::new_v4();

        let (from_num, from_denom) = parse_amount_to_rational("25584").unwrap();
        let (to_num, to_denom) = parse_amount_to_rational("153.81").unwrap();

        let price = build_conversion_price(
            &ConversionSide {
                split_id: from_id,
                commodity: from_commodity,
                num: from_num,
                denom: from_denom,
            },
            &ConversionSide {
                split_id: to_id,
                commodity: to_commodity,
                num: to_num,
                denom: to_denom,
            },
        );

        let from_val = Rational64::new(-from_num, from_denom);
        let to_val = Rational64::new(to_num, to_denom);
        let conv_rate = Rational64::new(price.value_num, price.value_denom);

        // commodity_split is to_split, so to_val * conv_rate must cancel from_val
        assert_eq!(from_val + to_val * conv_rate, Rational64::from_integer(0));
    }

    #[test]
    fn test_conversion_price_integer_amounts() {
        let from_id = Uuid::new_v4();
        let to_id = Uuid::new_v4();
        let from_commodity = Uuid::new_v4();
        let to_commodity = Uuid::new_v4();

        let (from_num, from_denom) = parse_amount_to_rational("1000").unwrap();
        let (to_num, to_denom) = parse_amount_to_rational("7").unwrap();

        let price = build_conversion_price(
            &ConversionSide {
                split_id: from_id,
                commodity: from_commodity,
                num: from_num,
                denom: from_denom,
            },
            &ConversionSide {
                split_id: to_id,
                commodity: to_commodity,
                num: to_num,
                denom: to_denom,
            },
        );

        let from_val = Rational64::new(-from_num, from_denom);
        let to_val = Rational64::new(to_num, to_denom);
        let conv_rate = Rational64::new(price.value_num, price.value_denom);

        assert_eq!(from_val + to_val * conv_rate, Rational64::from_integer(0));
    }

    #[test]
    fn test_conversion_price_both_fractional() {
        let from_id = Uuid::new_v4();
        let to_id = Uuid::new_v4();
        let from_commodity = Uuid::new_v4();
        let to_commodity = Uuid::new_v4();

        let (from_num, from_denom) = parse_amount_to_rational("99.50").unwrap();
        let (to_num, to_denom) = parse_amount_to_rational("85.23").unwrap();

        let price = build_conversion_price(
            &ConversionSide {
                split_id: from_id,
                commodity: from_commodity,
                num: from_num,
                denom: from_denom,
            },
            &ConversionSide {
                split_id: to_id,
                commodity: to_commodity,
                num: to_num,
                denom: to_denom,
            },
        );

        let from_val = Rational64::new(-from_num, from_denom);
        let to_val = Rational64::new(to_num, to_denom);
        let conv_rate = Rational64::new(price.value_num, price.value_denom);

        assert_eq!(from_val + to_val * conv_rate, Rational64::from_integer(0));
    }
}