pub(super) async fn run_get_account(

    caller: &mut Caller<'_, SessionData>,

    user_id: Uuid,

    key_arg: Option<String>,

) -> wasmtime::Result<Option<Rooted<StructRef>>> {

    let key = validate_lookup_key("get-account", key_arg)?;

    let mut runner = GetAccount::new().user_id(user_id);

    let result = match Uuid::parse_str(&key) {

        Ok(id) => runner.account_id(id).run().await,

            runner = runner.account_name(key);

            runner.run().await

    let entries = list_account_entries("get-account", result)?;

    match entries.into_iter().next() {

        Some((id, name, parent, type_val)) => Ok(Some(

            alloc_account_entity(

                caller,

                &id,

                name.as_deref(),

                parent.as_deref(),

                type_val.as_deref(),

            )

            .await?,

        None => Ok(None),

}

pub(super) fn validate_lookup_key(name: &str, key_arg: Option<String>) -> wasmtime::Result<String> {

    key_arg

        .filter(|s| !s.is_empty())

        .ok_or_else(|| wasmtime::Error::msg(format!("{name}: missing or empty lookup key")))

}

pub(super) async fn run_get_account_for_manage(

    caller: &mut Caller<'_, SessionData>,

    user_id: Uuid,

    id_arg: Option<String>,

) -> wasmtime::Result<Option<Rooted<StructRef>>> {

    let account_id = parse_get_account_for_manage_id(id_arg)?;

    let result = GetAccountForManage::new()

        .user_id(user_id)

        .account_id(account_id)

        .run()

        .await;

    let entries = list_account_entries("get-account-for-manage", result)?;

    match entries.into_iter().next() {

        Some((id, name, parent, type_val)) => Ok(Some(

            alloc_account_entity(

                caller,

                &id,

                name.as_deref(),

                parent.as_deref(),

                type_val.as_deref(),

            )

            .await?,

        None => Ok(None),

}

pub(super) fn parse_get_account_for_manage_id(id_arg: Option<String>) -> wasmtime::Result<Uuid> {

    let raw = id_arg.filter(|s| !s.is_empty()).ok_or_else(|| {

        wasmtime::Error::msg("get-account-for-manage: missing or empty :account-id arg")

    })?;

    Uuid::parse_str(&raw).map_err(|err| {

        wasmtime::Error::msg(format!(

    })

}

pub(super) async fn run_get_account_commodities(

    caller: &mut Caller<'_, SessionData>,

    user_id: Uuid,

    id_arg: Option<String>,

) -> wasmtime::Result<Option<Rooted<StructRef>>> {

    let account_id = parse_account_commodities_id(id_arg)?;

    let result = GetAccountCommodities::new()

        .user_id(user_id)

        .account_id(account_id)

        .run()

        .await;

    let items = match result {

        Ok(Some(CmdResult::CommodityInfoList(items))) => items,

    let mut anyrefs: Vec<Rooted<AnyRef>> = Vec::with_capacity(items.len());

    for info in items {

    alloc_pair_chain(caller, anyrefs).await

}

pub(super) fn parse_account_commodities_id(id_arg: Option<String>) -> wasmtime::Result<Uuid> {

    let raw = id_arg.filter(|s| !s.is_empty()).ok_or_else(|| {

        wasmtime::Error::msg("get-account-commodities: missing or empty :account-id arg")

    })?;

    Uuid::parse_str(&raw).map_err(|err| {

        wasmtime::Error::msg(format!(

    })

}

pub(super) fn list_account_entries(

    name: &str,

    result: Result<Option<CmdResult>, CmdError>,

) -> wasmtime::Result<Vec<AccountEntry>> {

    match result {

        Ok(Some(CmdResult::TaggedEntities { entities, .. })) => Ok(entities

            .into_iter()

            .filter_map(|(entity, tags)| match entity {

                FinanceEntity::Account(a) => Some((

                    a.id.to_string(),

                    tag_value_str(&tags, "name"),

                    a.parent.map(|u| u.to_string()),

                    tag_value_str(&tags, "type"),

            })

            .collect()),

}

pub(super) fn tag_value_str(

    tags: &std::collections::HashMap<String, FinanceEntity>,

    key: &str,

) -> Option<String> {

    tags.get(key).and_then(|t| match t {

        FinanceEntity::Tag(Tag { tag_value, .. }) => Some(tag_value.clone()),

    })

}

pub(super) async fn alloc_account_entity(

    caller: &mut Caller<'_, SessionData>,

    id: &str,

    name: Option<&str>,

    parent: Option<&str>,

    type_val: Option<&str>,

) -> wasmtime::Result<Rooted<StructRef>> {

    let id_ref = alloc_string_ref(caller, id.as_bytes())?;

    let name_ref = name

        .map(|s| alloc_string_ref(caller, s.as_bytes()))

        .transpose()?;

    let parent_ref = parent

        .map(|s| alloc_string_ref(caller, s.as_bytes()))

        .transpose()?;

    let type_ref = type_val

        .map(|s| alloc_string_ref(caller, s.as_bytes()))

        .transpose()?;

    let args = [

        Val::AnyRef(Some(id_ref.to_anyref())),

        Val::AnyRef(name_ref.map(|r| r.to_anyref())),

        Val::AnyRef(parent_ref.map(|r| r.to_anyref())),

        Val::AnyRef(type_ref.map(|r| r.to_anyref())),

    alloc_entity_via_export(caller, "alloc_account", &args).await

}

pub(super) async fn alloc_account_chain(

    caller: &mut Caller<'_, SessionData>,

    entries: Vec<AccountEntry>,

) -> wasmtime::Result<Option<Rooted<StructRef>>> {

    let mut anyrefs: Vec<Rooted<AnyRef>> = Vec::with_capacity(entries.len());

    for (id, name, parent, type_val) in entries {

        let entity_ref = alloc_account_entity(

            caller,

            &id,

            name.as_deref(),

            parent.as_deref(),

            type_val.as_deref(),

        )

        .await?;

        anyrefs.push(entity_ref.to_anyref());

    alloc_pair_chain(caller, anyrefs).await

}

pub(super) fn format_manage_tree(

    entities: &[(

        FinanceEntity,

        std::collections::HashMap<String, FinanceEntity>,

    )],

) -> String {

    let mut out = String::from("(:accounts-tree (");

    for (idx, (entity, tags)) in entities.iter().enumerate() {

        if idx > 0 {

        }

        match entity {

            FinanceEntity::Account(account) => {

                let parent = match account.parent {

                    Some(p) => format!("\"{p}\""),

                    None => "nil".to_string(),

                out.push_str(&format!("(:id \"{}\" :parent-id {}", account.id, parent));

                if let Some(name) = tags.get("name").and_then(|t| match t {

                    FinanceEntity::Tag(Tag { tag_value, .. }) => Some(tag_value.as_str()),

                }) {

                    out.push_str(&format!(" :name {}", super::quote_string(name)));

                }

                out.push(')');

    out.push_str("))");

    out

}

pub(super) fn format_tagged_entities(

    entities: &[(

        FinanceEntity,

        std::collections::HashMap<String, FinanceEntity>,

    )],

) -> String {

    let mut out = String::from("(:accounts (");

    for (idx, (entity, tags)) in entities.iter().enumerate() {

        if idx > 0 {

        }

        let id = match entity {

            FinanceEntity::Account(a) => a.id,

        let name = tags.get("name").and_then(|t| match t {

            FinanceEntity::Tag(Tag { tag_value, .. }) => Some(tag_value.as_str()),

        });

        out.push_str(&format!("(:id \"{id}\""));

        if let Some(name) = name {

            out.push_str(&format!(" :name {}", super::quote_string(name)));

        }

        out.push(')');

    out.push_str("))");

    out

}

pub(super) fn format_commodity_info_list(items: &[CommodityInfo]) -> String {

    let mut out = String::from("(:account-commodities (");

    for (idx, info) in items.iter().enumerate() {

        if idx > 0 {

            out.push(' ');

        }

        out.push_str(&format!(

            "(:commodity-id \"{}\" :symbol {} :name {})",

            info.commodity_id,

            super::quote_string(&info.symbol),

            super::quote_string(&info.name),

        ));

    out.push_str("))");

    out

}