pub fn register(linker: &mut Linker<SessionData>) -> wasmtime::Result<()> {

    register_readonly(linker)?;

    register_mutators(linker)?;

    Ok(())

}

pub fn register_readonly(linker: &mut Linker<SessionData>) -> wasmtime::Result<()> {

    linker.func_wrap_async(

        "nomi",

        "transaction_list_transactions",

        > {

            Box::new(async move {

                let user_id = caller.data().ctx().user_id;

                let result = ListTransactions::new().user_id(user_id).run().await;

                let entries = list_transaction_entries("list-transactions", result)?;

                alloc_transaction_chain(&mut caller, entries).await

            })

        },

    linker.func_wrap_async(

        "nomi",

        "transaction_get_transaction",

        > {

            Box::new(async move {

                let user_id = caller.data().ctx().user_id;

                let id = read_string_arg(&mut caller, id_arg)?;

                run_get_transaction(&mut caller, user_id, id).await

            })

        },

    linker.func_wrap_async(

        "nomi",

        "transaction_get_transaction_tag",

    Ok(())

}

pub fn register_mutators(linker: &mut Linker<SessionData>) -> wasmtime::Result<()> {

    linker.func_wrap_async(

        "nomi",

        "transaction_delete_transaction",

         -> Box<dyn std::future::Future<Output = wasmtime::Result<i32>> + Send> {

            Box::new(async move {

                let user_id = caller.data().ctx().user_id;

                let id = read_string_arg(&mut caller, id_arg)?;

                run_delete_transaction(user_id, id).await

            })

        },

    linker.func_wrap_async(

        "nomi",

        "transaction_create_transaction",

        > {

            Box::new(async move {

                let user_id = caller.data().ctx().user_id;

                let payload = read_string_arg(&mut caller, payload_arg)?;

                let id = run_create_transaction(user_id, payload).await?;

                Ok(Some(alloc_string_ref(&mut caller, id.as_bytes())?))

            })

        },

    linker.func_wrap_async(

        "nomi",

        "transaction_update_transaction",

        > {

            Box::new(async move {

                let user_id = caller.data().ctx().user_id;

                let payload = read_string_arg(&mut caller, payload_arg)?;

                let id = run_update_transaction(user_id, payload).await?;

            })

        },

    linker.func_wrap_async(

        "nomi",

        "transaction_set_transaction_tag",

    Ok(())

}

async fn run_update_transaction(

    user_id: Uuid,

    payload_arg: Option<String>,

) -> wasmtime::Result<String> {

    let payload = payload_arg

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

        .ok_or_else(|| wasmtime::Error::msg("update-transaction: missing or empty :payload arg"))?;

    let input = parse_update_transaction_payload(&payload)

        .map_err(|err| wasmtime::Error::msg(format!("update-transaction: {err}")))?;

    let mut runner = UpdateTransaction::new()

        .user_id(user_id)

        .transaction_id(input.transaction_id);

    if let Some(post_date) = input.post_date {

    }

    if let Some(enter_date) = input.enter_date {

    }

    if let Some(note) = input.note {

        runner = runner.note(note);

    }

    if let Some(splits) = input.splits {

    }

    match runner.run().await {

        Err(err) => Err(wasmtime::Error::msg(format!("update-transaction: {err}"))),

}

fn parse_update_transaction_payload(src: &str) -> Result<UpdateTransactionInput, String> {

    let program = Reader::parse(src).map_err(|err| format!("payload parse: {err}"))?;

    let first = program

        .exprs

        .into_iter()

        .next()

        .ok_or_else(|| "payload empty".to_string())?;

    let plist = expect_plist(first, "payload")?;

    let tx_raw = take_plist_string(&plist, "transaction-id")?

        .ok_or_else(|| "payload: missing :transaction-id".to_string())?;

    let transaction_id = Uuid::parse_str(&tx_raw)

        .map_err(|err| format!("payload: invalid :transaction-id '{tx_raw}': {err}"))?;

    let post_date = match take_plist_string(&plist, "post-date")? {

        Some(raw) => Some(

            DateTime::parse_from_rfc3339(&raw)

                .map(|d| d.with_timezone(&Utc))

                .map_err(|err| format!("payload: invalid :post-date '{raw}': {err}"))?,

        None => None,

    let enter_date = match take_plist_string(&plist, "enter-date")? {

        None => None,

    let note = take_plist_string(&plist, "note")?;

    let splits = match take_plist_list(&plist, "splits")? {

        None => None,

    Ok(UpdateTransactionInput {

        transaction_id,

        post_date,

        enter_date,

        note,

        splits,

    })

}

async fn run_create_transaction(

    user_id: Uuid,

    payload_arg: Option<String>,

) -> wasmtime::Result<String> {

    let payload = payload_arg

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

        .ok_or_else(|| wasmtime::Error::msg("create-transaction: missing or empty :payload arg"))?;

    let input = parse_create_transaction_payload(&payload)

        .map_err(|err| wasmtime::Error::msg(format!("create-transaction: {err}")))?;

    let mut splits: Vec<FinanceEntity> = input

        .splits

        .into_iter()

        .map(|mut s| {

            s.tx_id = input.id;

            FinanceEntity::Split(s)

        })

        .collect();

    let mut runner = CreateTransaction::new()

        .user_id(user_id)

        .id(input.id)

        .post_date(input.post_date)

        .enter_date(input.enter_date)

        .splits(std::mem::take(&mut splits));

    if let Some(note) = input.note {

        runner = runner.note(note);

    }

    match runner.run().await {

        Ok(Some(CmdResult::Entity(FinanceEntity::Transaction(tx)))) => Ok(tx.id.to_string()),

}

fn parse_create_transaction_payload(src: &str) -> Result<CreateTransactionInput, String> {

    let program = Reader::parse(src).map_err(|err| format!("payload parse: {err}"))?;

    let first = program

        .exprs

        .into_iter()

        .next()

        .ok_or_else(|| "payload empty".to_string())?;

    let plist = expect_plist(first, "payload")?;

    let post_date_raw = take_plist_string(&plist, "post-date")?

        .ok_or_else(|| "payload: missing :post-date".to_string())?;

    let post_date = DateTime::parse_from_rfc3339(&post_date_raw)

        .map(|d| d.with_timezone(&Utc))

        .map_err(|err| format!("payload: invalid :post-date '{post_date_raw}': {err}"))?;

    let enter_date = match take_plist_string(&plist, "enter-date")? {

        None => Utc::now(),

    let id = match take_plist_string(&plist, "id")? {

        None => Uuid::new_v4(),

    let note = take_plist_string(&plist, "note")?;

    let splits_list =

        take_plist_list(&plist, "splits")?.ok_or_else(|| "payload: missing :splits".to_string())?;

    if splits_list.len() < 2 {

        return Err("payload: :splits must have at least two entries".into());

    }

    let splits = splits_list

        .into_iter()

        .enumerate()

        .map(|(idx, expr)| parse_split_plist(expr, idx))

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

    Ok(CreateTransactionInput {

        id,

        post_date,

        enter_date,

        note,

        splits,

    })

}

fn parse_split_plist(expr: Expr, idx: usize) -> Result<Split, String> {

    let plist = expect_plist(expr, &format!("split[{idx}]"))?;

    let account_raw = take_plist_string(&plist, "account-id")?

        .ok_or_else(|| format!("split[{idx}]: missing :account-id"))?;

    let account_id = Uuid::parse_str(&account_raw)

        .map_err(|err| format!("split[{idx}]: invalid :account-id '{account_raw}': {err}"))?;

    let commodity_raw = take_plist_string(&plist, "commodity-id")?

        .ok_or_else(|| format!("split[{idx}]: missing :commodity-id"))?;

    let commodity_id = Uuid::parse_str(&commodity_raw)

        .map_err(|err| format!("split[{idx}]: invalid :commodity-id '{commodity_raw}': {err}"))?;

    let value = take_plist_number(&plist, "value")?

        .ok_or_else(|| format!("split[{idx}]: missing :value"))?;

    Ok(Split {

        id: Uuid::new_v4(),

        tx_id: Uuid::nil(),

        account_id,

        commodity_id,

        reconcile_state: None,

        reconcile_date: None,

        value_num: *value.numer(),

        value_denom: *value.denom(),

        lot_id: None,

    })

}

fn expect_plist(expr: Expr, context: &str) -> Result<Vec<(String, Expr)>, String> {

    let items = match expr {

        Expr::List(items) => items,

        other => return Err(format!("{context}: expected plist, got {other:?}")),

    if !items.len().is_multiple_of(2) {

    }

    let mut out = Vec::with_capacity(items.len() / 2);

    let mut iter = items.into_iter();

    while let Some(key) = iter.next() {

        let key_name = match key {

            Expr::Keyword(name) => name,

        let value = iter

            .next()

            .ok_or_else(|| format!("{context}: dangling :{key_name} without value"))?;

        out.push((key_name, value));

    Ok(out)

}

fn take_plist_string(plist: &[(String, Expr)], key: &str) -> Result<Option<String>, String> {

    let upper = key.to_ascii_uppercase();

    match plist.iter().find(|(k, _)| k.eq_ignore_ascii_case(&upper)) {

        Some((_, Expr::String(s))) => Ok(Some(s.clone())),

        None => Ok(None),

}

fn take_plist_number(plist: &[(String, Expr)], key: &str) -> Result<Option<Fraction>, String> {

    let upper = key.to_ascii_uppercase();

    match plist.iter().find(|(k, _)| k.eq_ignore_ascii_case(&upper)) {

        Some((_, Expr::Number(n))) => Ok(Some(*n)),

}

fn take_plist_list(plist: &[(String, Expr)], key: &str) -> Result<Option<Vec<Expr>>, String> {

    let upper = key.to_ascii_uppercase();

    match plist.iter().find(|(k, _)| k.eq_ignore_ascii_case(&upper)) {

        Some((_, Expr::List(items))) => Ok(Some(items.clone())),

        None => Ok(None),

}

async fn run_delete_transaction(user_id: Uuid, id_arg: Option<String>) -> wasmtime::Result<i32> {

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

        wasmtime::Error::msg("delete-transaction: missing or empty :transaction-id arg")

    })?;

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

        wasmtime::Error::msg(format!("delete-transaction: invalid uuid '{raw}': {err}"))

    })?;

    DeleteTransaction::new()

        .user_id(user_id)

        .transaction_id(transaction_id)

        .run()

        .await

        .map(|_| 1)

        .map_err(|err| wasmtime::Error::msg(format!("delete-transaction: {err}")))

}

async fn run_get_transaction(

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

    user_id: Uuid,

    id_arg: Option<String>,

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

    let transaction_id = parse_transaction_id_arg(id_arg)?;

    let result = GetTransaction::new()

        .user_id(user_id)

        .transaction_id(transaction_id)

        .run()

        .await;

    let entries = list_transaction_entries("get-transaction", result)?;

    match entries.into_iter().next() {

        Some((id, note, post_date)) => Ok(Some(

            alloc_transaction_entity(caller, &id, note.as_deref(), Some(&post_date)).await?,

        None => Ok(None),

}

fn parse_transaction_id_arg(id_arg: Option<String>) -> wasmtime::Result<Uuid> {

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

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

    })?;

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

        wasmtime::Error::msg(format!("get-transaction: invalid uuid '{raw}': {err}"))

    })

}

fn list_transaction_entries(

    name: &str,

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

) -> wasmtime::Result<Vec<(String, Option<String>, String)>> {

    match result {

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

            .into_iter()

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

                FinanceEntity::Transaction(tx) => Some((

                    tx.id.to_string(),

                    tag_value(&tags, "note").map(str::to_string),

                    tx.post_date.to_rfc3339(),

                )),

            })

            .collect()),

        Ok(None) => Ok(Vec::new()),

}

async fn alloc_transaction_entity(

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

    id: &str,

    note: Option<&str>,

    post_date: Option<&str>,

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

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

    let note_ref = match note {

        Some(s) => Some(alloc_string_ref(caller, s.as_bytes())?),

    let date_ref = match post_date {

        Some(s) => Some(alloc_string_ref(caller, s.as_bytes())?),

    let args = [

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

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

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

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

}

async fn alloc_transaction_chain(

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

    entries: Vec<(String, Option<String>, String)>,

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

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

    for (id, note, post_date) in entries {

        let entity_ref =

            alloc_transaction_entity(caller, &id, note.as_deref(), Some(&post_date)).await?;

        anyrefs.push(entity_ref.to_anyref());

    alloc_pair_chain(caller, anyrefs).await

}

fn format_tagged_transactions(

    entities: &[(

        FinanceEntity,

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

    )],

    pagination: Option<&PaginationInfo>,

) -> String {

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

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

        if idx > 0 {

        }

        match entity {

            FinanceEntity::Transaction(tx) => {

                out.push_str(&format!(

                    "(:id \"{}\" :post-date \"{}\" :enter-date \"{}\"",

                    tx.id,

                    tx.post_date.to_rfc3339(),

                    tx.enter_date.to_rfc3339()

                ));

                if let Some(note) = tag_value(tags, "note") {

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

                }

                out.push(')');

    out.push_str(") :pagination ");

    match pagination {

        Some(p) => out.push_str(&format!(

            if p.has_more { "t" } else { "nil" }

        None => out.push_str("nil"),

    out.push(')');

    out

}

fn tag_value<'a>(

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

    key: &str,

) -> Option<&'a str> {

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

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

    })

}

fn quote_string(s: &str) -> String {

    let mut q = String::with_capacity(s.len() + 2);

    q.push('"');

    for ch in s.chars() {

        match ch {

            other => q.push(other),

    q.push('"');

    q

}

    fn tx_entity(id: Uuid) -> FinanceEntity {

        let post = chrono::Utc.with_ymd_and_hms(2026, 5, 1, 12, 0, 0).unwrap();

        let enter = chrono::Utc.with_ymd_and_hms(2026, 5, 2, 9, 30, 0).unwrap();

        FinanceEntity::Transaction(Transaction {

            id,

            post_date: post,

            enter_date: enter,

        })

    }

    fn format_empty_list_with_no_pagination() {

        assert_eq!(

            format_tagged_transactions(&[], None),

    }

    fn format_single_transaction_with_note_and_pagination() {

        let id = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap();

        let mut tags = HashMap::new();

        tags.insert(

            "note".to_string(),

            FinanceEntity::Tag(Tag {

                id: Uuid::nil(),

                tag_name: "note".into(),

                tag_value: "groceries".into(),

                description: None,

            }),

        let pagination = PaginationInfo {

            total_count: 1,

            limit: 20,

            offset: 0,

            has_more: false,

        };

        let out = format_tagged_transactions(&[(tx_entity(id), tags)], Some(&pagination));

        assert!(out.contains(":id \"550e8400-e29b-41d4-a716-446655440000\""));

        assert!(out.contains(":post-date \"2026-05-01T12:00:00+00:00\""));

        assert!(out.contains(":enter-date \"2026-05-02T09:30:00+00:00\""));

        assert!(out.contains(":note \"groceries\""));

        assert!(out.contains(":pagination (:total 1 :limit 20 :offset 0 :has-more nil)"));

    }

    fn format_transaction_without_tags_omits_note() {

        let id = Uuid::nil();

        let out = format_tagged_transactions(&[(tx_entity(id), HashMap::new())], None);

        assert!(out.contains(":id \"00000000-0000-0000-0000-000000000000\""));

        assert!(!out.contains(":note"));

        assert!(out.ends_with(":pagination nil)"));

    }

    fn parse_transaction_id_rejects_missing_arg() {

        let err = parse_transaction_id_arg(None).unwrap_err();

        assert!(err.to_string().contains("missing or empty"), "got: {err}");

    }

    fn parse_transaction_id_rejects_invalid_uuid() {

        let err = parse_transaction_id_arg(Some("not-a-uuid".into())).unwrap_err();

        assert!(err.to_string().contains("invalid uuid"), "got: {err}");

    }

    async fn run_delete_transaction_with_no_arg_emits_error() {

        let err = run_delete_transaction(Uuid::nil(), None).await.unwrap_err();

        assert!(err.to_string().contains("missing or empty"), "got: {err}");

    }

    async fn run_delete_transaction_with_invalid_uuid_emits_error() {

        let err = run_delete_transaction(Uuid::nil(), Some("not-uuid".into()))

            .await

            .unwrap_err();

        assert!(err.to_string().contains("invalid uuid"), "got: {err}");

    }

    fn parse_payload_minimal_two_splits() {

        let src = r#"(:post-date "2026-01-15T00:00:00Z"

            :splits ((:account-id "11111111-1111-1111-1111-111111111111"

                      :commodity-id "22222222-2222-2222-2222-222222222222"

                      :value -5000/100)

                     (:account-id "33333333-3333-3333-3333-333333333333"

                      :commodity-id "22222222-2222-2222-2222-222222222222"

                      :value 5000/100)))"#;

        let parsed = parse_create_transaction_payload(src).expect("parse");

        assert_eq!(parsed.splits.len(), 2);

        assert_eq!(parsed.splits[0].value_num, -50);

        assert_eq!(parsed.splits[0].value_denom, 1);

        assert_eq!(parsed.splits[1].value_num, 50);

    }

    fn parse_payload_picks_up_note() {

        let src = r#"(:post-date "2026-01-15T00:00:00Z"

            :note "groceries"

            :splits ((:account-id "11111111-1111-1111-1111-111111111111"

                      :commodity-id "22222222-2222-2222-2222-222222222222"

                      :value -1)

                     (:account-id "33333333-3333-3333-3333-333333333333"

                      :commodity-id "22222222-2222-2222-2222-222222222222"

                      :value 1)))"#;

        let parsed = parse_create_transaction_payload(src).expect("parse");

        assert_eq!(parsed.note.as_deref(), Some("groceries"));

    }

    fn parse_payload_rejects_missing_post_date() {

        let src = r#"(:splits ((:account-id "x" :commodity-id "y" :value 1)

                                (:account-id "x" :commodity-id "y" :value -1)))"#;

        let err = parse_create_transaction_payload(src).unwrap_err();

        assert!(err.contains(":post-date"), "got: {err}");

    }

    fn parse_payload_rejects_single_split() {

        let src = r#"(:post-date "2026-01-15T00:00:00Z"

                      :splits ((:account-id "x" :commodity-id "y" :value 1)))"#;

        let err = parse_create_transaction_payload(src).unwrap_err();

        assert!(err.contains("at least two"), "got: {err}");

    }

    async fn run_create_transaction_with_no_payload_emits_error() {

        let err = run_create_transaction(Uuid::nil(), None).await.unwrap_err();

        assert!(err.to_string().contains("missing or empty"), "got: {err}");

    }

    async fn run_create_transaction_with_garbage_payload_surfaces_parse_error() {

        let err = run_create_transaction(Uuid::nil(), Some("not-an-sexpr".into()))

            .await

            .unwrap_err();

        assert!(err.to_string().contains("create-transaction"), "got: {err}");

    }

    fn parse_update_payload_minimum_just_id() {

        let src = r#"(:transaction-id "550e8400-e29b-41d4-a716-446655440000")"#;

        let parsed = parse_update_transaction_payload(src).expect("parse");

        assert_eq!(

            parsed.transaction_id.to_string(),

        assert!(parsed.note.is_none());

        assert!(parsed.splits.is_none());

    }

    fn parse_update_payload_rejects_missing_transaction_id() {

        let src = r#"(:note "x")"#;

        let err = parse_update_transaction_payload(src).unwrap_err();

        assert!(err.contains(":transaction-id"), "got: {err}");

    }

    fn parse_update_payload_carries_partial_fields() {

        let src = r#"(:transaction-id "550e8400-e29b-41d4-a716-446655440000"

                      :post-date "2026-05-11T12:00:00Z"

                      :note "edited")"#;

        let parsed = parse_update_transaction_payload(src).expect("parse");

        assert!(parsed.post_date.is_some());

        assert_eq!(parsed.note.as_deref(), Some("edited"));

        assert!(parsed.splits.is_none());

    }

    async fn run_update_transaction_with_no_payload_emits_error() {

        let err = run_update_transaction(Uuid::nil(), None).await.unwrap_err();

        assert!(err.to_string().contains("missing or empty"), "got: {err}");

    }

    fn format_pagination_has_more_emits_t() {

        let pagination = PaginationInfo {

            total_count: 100,

            limit: 20,

            offset: 0,

            has_more: true,

        };

        let out = format_tagged_transactions(&[], Some(&pagination));

        assert!(out.contains(":has-more t)"));

    }