pub(crate) fn parse_renderer_hint(s: &str) -> RendererHint {

    match s.to_ascii_lowercase().as_str() {

        "text" | "ascii" => RendererHint::Text,

        "kitty" | "graphic" => RendererHint::Kitty,

        _ => RendererHint::Auto,

}

pub fn parse_chart_shape(s: &str) -> ChartKind {

    match s.to_ascii_lowercase().as_str() {

        "line" => ChartKind::Line,

        "stacked" | "stackedbar" => ChartKind::StackedBar,

        _ => ChartKind::Bar,

}

pub(crate) fn probe_terminal_kitty() -> bool {

    if !std::io::stdout().is_terminal() {

        return false;

}

pub fn coerce_date_arg(s: &str, end_of_day: bool) -> Result<String, CommandError> {

    if chrono::DateTime::parse_from_rfc3339(s).is_ok() {

        return Ok(s.to_string());

    }

    let date = NaiveDate::parse_from_str(s, "%Y-%m-%d")

        .map_err(|e| CommandError::Argument(format!("invalid date '{s}': {e}")))?;

    let (h, m, sec) = if end_of_day { (23, 59, 59) } else { (0, 0, 0) };

    let naive = date

        .and_hms_opt(h, m, sec)

        .ok_or_else(|| CommandError::Argument(format!("invalid time for date '{s}'")))?;

    Ok(Utc.from_utc_datetime(&naive).to_rfc3339())

}

fn parse_rational(s: &str) -> Result<Rational64, CommandError> {

    if let Some((num, denom)) = s.split_once('/') {

        let n: i64 = num

            .parse()

            .map_err(|e| CommandError::Command(format!("rational numerator parse '{s}': {e}")))?;

        let d: i64 = denom

            .parse()

            .map_err(|e| CommandError::Command(format!("rational denominator parse '{s}': {e}")))?;

        if d == 0 {

            return Err(CommandError::Command(format!(

                "rational zero denominator: {s}"

            )));

        }

        Ok(Rational64::new(n, d))

        let n: i64 = s

            .parse()

            .map_err(|e| CommandError::Command(format!("rational parse '{s}': {e}")))?;

        Ok(Rational64::new(n, 1))

}

fn reparse(raw: &str, ctx: &str) -> Result<Value, CommandError> {

    reparse_list(raw).map_err(|e| CommandError::Command(format!("{ctx}: reparse failed: {e}")))

}

fn extract_string(value: &Value, ctx: &str) -> Result<String, CommandError> {

    match value {

        Value::String(s) => Ok(s.clone()),

}

fn field_str(plist: &Value, key: &str, ctx: &str) -> Result<String, CommandError> {

    plist_field(plist, key).ok_or_else(|| CommandError::Command(format!("{ctx}: missing {key}")))

}

fn field_usize(plist: &Value, key: &str, ctx: &str) -> Result<usize, CommandError> {

    let s = field_str(plist, key, ctx)?;

    usize::from_str(&s).map_err(|e| CommandError::Command(format!("{ctx}: {key} parse error: {e}")))

}

fn field_bool_sym(plist: &Value, key: &str) -> bool {

    match plist_field_raw(plist, key) {

        Some(Value::Bool(b)) => b,

        Some(Value::Nil) | None => false,

}

fn field_list(plist: &Value, key: &str, ctx: &str) -> Result<Vec<Value>, CommandError> {

    match plist_field_raw(plist, key) {

        Some(Value::Nil) | None => Ok(vec![]),

        Some(v) => list_to_vec(&v)

            .ok_or_else(|| CommandError::Command(format!("{ctx}: {key} is not a list"))),

}

fn parse_amounts(amounts_val: &Value, ctx: &str) -> Result<Vec<AmountView>, CommandError> {

    let items = match amounts_val {

        v => list_to_vec(v)

            .ok_or_else(|| CommandError::Command(format!("{ctx}: amounts not a list")))?,

    items

        .iter()

        .map(|item| {

            let symbol = field_str(item, ":symbol", ctx)?;

            let amount_s = field_str(item, ":amount", ctx)?;

            let amount = parse_rational(&amount_s)?;

            Ok(AmountView {

                commodity_symbol: symbol,

                amount,

            })

        })

        .collect()

}

fn parse_report_node(

    node: &Value,

    parent_id: Option<Uuid>,

    out: &mut Vec<ReportRowView>,

) -> Result<(), CommandError> {

    let ctx = "balance-report node";

    let account_id_s = field_str(node, ":account-id", ctx)?;

    let account_id = Uuid::parse_str(&account_id_s)

        .map_err(|e| CommandError::Command(format!("{ctx}: account-id parse: {e}")))?;

    let account_name = field_str(node, ":account-name", ctx)?;

    let depth = field_usize(node, ":depth", ctx)?;

    let amounts_val = plist_field_raw(node, ":amounts").unwrap_or(Value::Nil);

    let amounts = parse_amounts(&amounts_val, ctx)?;

    let children_val = plist_field_raw(node, ":children").unwrap_or(Value::Nil);

    let children = match &children_val {

        Value::Nil => vec![],

    out.push(ReportRowView {

        account_id,

        parent_id,

        account_name,

        depth,

        has_children: !children.is_empty(),

        amounts,

    });

    for child in &children {

    Ok(())

}

pub fn value_to_balance_rows(value: &Value) -> Result<Vec<ReportRowView>, CommandError> {

    let raw = extract_string(value, "balance-report")?;

    let plist = reparse(&raw, "balance-report")?;

    let periods = field_list(&plist, ":periods", "balance-report")?;

    let mut rows = Vec::new();

    for period in &periods {

        let roots = field_list(period, ":roots", "balance-report period")?;

        for root in &roots {

            parse_report_node(root, None, &mut rows)?;

    Ok(rows)

}

fn sum_into(dest: &mut Vec<AmountView>, src: &[AmountView], negate: bool) {

    for a in src {

        let contribution = if negate { -a.amount } else { a.amount };

        match dest

            .iter_mut()

            .find(|d| d.commodity_symbol == a.commodity_symbol)

            None => dest.push(AmountView {

                commodity_symbol: a.commodity_symbol.clone(),

                amount: contribution,

            }),

}

fn top_level_totals(rows: &[ReportRowView]) -> Vec<AmountView> {

    let mut out = Vec::new();

    for row in rows.iter().filter(|r| r.depth == 0) {

        sum_into(&mut out, &row.amounts, false);

    }

    out

}

pub fn value_to_activity_periods(value: &Value) -> Result<Vec<PeriodActivityView>, CommandError> {

    let raw = extract_string(value, "activity-report")?;

    let plist = reparse(&raw, "activity-report")?;

    let period_vals = field_list(&plist, ":periods", "activity-report")?;

    period_vals

        .iter()

        .map(|period| {

            let label = plist_field(period, ":label").unwrap_or_default();

            let group_vals = field_list(period, ":groups", "activity period")?;

            let groups: Vec<GroupView> = group_vals

                .iter()

                .map(|g| {

                    let g_label = field_str(g, ":label", "activity group")?;

                    let flip_sign = field_bool_sym(g, ":flip-sign");

                    let root_vals = field_list(g, ":roots", "activity group")?;

                    let mut rows = Vec::new();

                    for root in &root_vals {

                        parse_report_node(root, None, &mut rows)?;

                    if flip_sign {

                        for row in &mut rows {

                            for a in &mut row.amounts {

                                a.amount = -a.amount;

                            }

                    let total = top_level_totals(&rows);

                    Ok(GroupView {

                        label: g_label,

                        flip_sign,

                        rows,

                        total,

                    })

                })

                .collect::<Result<_, CommandError>>()?;

            let mut net: Vec<AmountView> = Vec::new();

            for g in &groups {

                sum_into(&mut net, &g.total, !g.flip_sign);

            }

            Ok(PeriodActivityView { label, groups, net })

        })

        .collect()

}

pub fn value_to_breakdown_periods(value: &Value) -> Result<Vec<BreakdownPeriodView>, CommandError> {

    let raw = extract_string(value, "category-breakdown")?;

    let plist = reparse(&raw, "category-breakdown")?;

    let period_vals = field_list(&plist, ":periods", "category-breakdown")?;

    period_vals

        .iter()

        .map(|period| {

            let label = plist_field(period, ":label").unwrap_or_default();

            let row_vals = field_list(period, ":rows", "breakdown period")?;

            let rows: Vec<BreakdownRowView> = row_vals

                .iter()

                .map(|row| {

                    let tag_value = field_str(row, ":tag-value", "breakdown row")?;

                    let is_uncategorized = field_bool_sym(row, ":uncategorized");

                    let amounts_val = plist_field_raw(row, ":amounts").unwrap_or(Value::Nil);

                    let amounts = parse_amounts(&amounts_val, "breakdown row")?;

                    Ok(BreakdownRowView {

                        tag_value,

                        is_uncategorized,

                        amounts,

                    })

                })

                .collect::<Result<_, CommandError>>()?;

            Ok(BreakdownPeriodView { label, rows })

        })

        .collect()

}

    fn parse(s: &str) -> Value {

        Value::String(s.to_string())

    }

    fn coerce_date_arg_yyyy_mm_dd_start_of_day() {

        let s = coerce_date_arg("2024-03-15", false).expect("valid date");

        assert_eq!(s, "2024-03-15T00:00:00+00:00");

    }

    fn coerce_date_arg_yyyy_mm_dd_end_of_day() {

        let s = coerce_date_arg("2024-03-15", true).expect("valid date");

        assert_eq!(s, "2024-03-15T23:59:59+00:00");

    }

    fn coerce_date_arg_rfc3339_passes_through() {

        let rfc = "2024-03-15T12:34:56+00:00";

        assert_eq!(coerce_date_arg(rfc, false).expect("valid"), rfc);

        assert_eq!(coerce_date_arg(rfc, true).expect("valid"), rfc);

    }

    fn coerce_date_arg_invalid_is_error() {

        assert!(coerce_date_arg("not-a-date", false).is_err());

        assert!(coerce_date_arg("2024-99-01", false).is_err());

    }

    fn parse_rational_integer() {

        assert_eq!(parse_rational("42").unwrap(), Rational64::new(42, 1));

    }

    fn parse_rational_fraction() {

        assert_eq!(parse_rational("3/4").unwrap(), Rational64::new(3, 4));

    }

    fn parse_rational_negative() {

        assert_eq!(parse_rational("-5/2").unwrap(), Rational64::new(-5, 2));

    }

    fn parse_rational_zero_denom_is_error() {

        assert!(parse_rational("1/0").is_err());

    }

    fn parse_chart_shape_defaults_to_bar() {

        assert_eq!(parse_chart_shape("anything"), ChartKind::Bar);

        assert_eq!(parse_chart_shape("bar"), ChartKind::Bar);

    }

    fn parse_chart_shape_line() {

        assert_eq!(parse_chart_shape("line"), ChartKind::Line);

    }

    fn parse_chart_shape_stacked() {

        assert_eq!(parse_chart_shape("stacked"), ChartKind::StackedBar);

        assert_eq!(parse_chart_shape("stackedbar"), ChartKind::StackedBar);

    }

    fn parse_renderer_hint_text() {

        assert!(matches!(parse_renderer_hint("text"), RendererHint::Text));

        assert!(matches!(parse_renderer_hint("ascii"), RendererHint::Text));

    }

    fn parse_renderer_hint_kitty() {

        assert!(matches!(parse_renderer_hint("kitty"), RendererHint::Kitty));

        assert!(matches!(

            parse_renderer_hint("graphic"),

    }

    fn parse_renderer_hint_auto() {

        assert!(matches!(parse_renderer_hint("bar"), RendererHint::Auto));

        assert!(matches!(parse_renderer_hint("line"), RendererHint::Auto));

    }

    fn probe_terminal_kitty_returns_false_in_tests() {

        if !std::io::stdout().is_terminal() {

            assert!(!probe_terminal_kitty());

    }

    fn value_to_balance_rows_single_node_two_amounts() {

        let wire = r#"(:balance-report :periods ((:label nil :roots ((:account-id "00000000-0000-0000-0000-000000000000" :account-name "Assets" :account-path "Assets" :depth 0 :account-type "asset" :amounts ((:commodity-id "00000000-0000-0000-0000-000000000000" :symbol "USD" :amount 100) (:commodity-id "00000000-0000-0000-0000-000000000000" :symbol "EUR" :amount 50)) :children ())))))"#;

        let rows = value_to_balance_rows(&parse(wire)).expect("parse ok");

        assert_eq!(rows.len(), 1);

        assert_eq!(rows[0].account_name, "Assets");

        assert_eq!(rows[0].amounts.len(), 2, "both commodities must be present");

        assert!(rows[0].amounts.iter().any(|a| a.commodity_symbol == "USD"));

        assert!(rows[0].amounts.iter().any(|a| a.commodity_symbol == "EUR"));

    }

    fn value_to_balance_rows_empty_periods() {

        let wire = "(:balance-report :periods ())";

        let rows = value_to_balance_rows(&parse(wire)).expect("empty ok");

        assert!(rows.is_empty());

    }

    fn value_to_activity_periods_parses_groups() {

        let wire = r#"(:activity-report :meta nil :periods ((:label "2026-Q1" :groups ((:label "Income" :flip-sign t :roots ((:account-id "00000000-0000-0000-0000-000000000000" :account-name "Salary" :account-path "Income:Salary" :depth 0 :account-type nil :amounts ((:commodity-id "00000000-0000-0000-0000-000000000000" :symbol "USD" :amount 1000)) :children ())))))))"#;

        let periods = value_to_activity_periods(&parse(wire)).expect("parse ok");

        assert_eq!(periods.len(), 1);

        assert_eq!(periods[0].label, "2026-Q1");

        assert_eq!(periods[0].groups.len(), 1);

        assert_eq!(periods[0].groups[0].label, "Income");

        assert_eq!(

            periods[0].groups[0].rows[0].amounts[0].amount,

            Rational64::new(-1000, 1)

    }

    fn value_to_breakdown_periods_parses_rows() {

        let wire = r#"(:category-breakdown :meta nil :tag-name "category" :periods ((:label nil :rows ((:tag-value "Food" :uncategorized nil :amounts ((:commodity-id "00000000-0000-0000-0000-000000000000" :symbol "USD" :amount 200)))))))"#;

        let periods = value_to_breakdown_periods(&parse(wire)).expect("parse ok");

        assert_eq!(periods.len(), 1);

        assert_eq!(periods[0].rows.len(), 1);

        assert_eq!(periods[0].rows[0].tag_value, "Food");

        assert_eq!(

            periods[0].rows[0].amounts[0].amount,

            Rational64::new(200, 1)

    }