use super::*;
use near_sdk::test_utils::{get_logs, VMContextBuilder};
use near_sdk::{testing_env, PromiseResult, RuntimeFeesConfig};

const DOC: &str = "aa00000000000000000000000000000000000000000000000000000000000001";
const DAY: u64 = 86_400_000;
const T0: u64 = 1_800_000_000_000; // ms

fn acc(s: &str) -> AccountId {
    s.parse().unwrap()
}
fn usdc() -> AccountId {
    acc("usdc.near")
}
fn intents() -> AccountId {
    acc("intents.near")
}
fn merchant() -> AccountId {
    acc("studio.near")
}
fn tax() -> AccountId {
    acc("tax.near")
}
fn designer() -> AccountId {
    acc("designer.near")
}

fn ctx(who: AccountId, deposit: NearToken, now_ms: u64) -> VMContextBuilder {
    let mut b = VMContextBuilder::new();
    b.current_account_id(acc("dulypay.near"))
        .signer_account_id(acc("relayer.near"))
        .predecessor_account_id(who)
        .attached_deposit(deposit)
        .prepaid_gas(Gas::from_tgas(300))
        .block_timestamp(now_ms * 1_000_000)
        .block_height(1000);
    b
}
fn call_as(who: AccountId, deposit: NearToken, now_ms: u64) {
    testing_env!(ctx(who, deposit, now_ms).build());
}
fn yocto1() -> NearToken {
    NearToken::from_yoctonear(1)
}
fn zero() -> NearToken {
    NearToken::from_yoctonear(0)
}

fn setup() -> Duly {
    call_as(merchant(), REGISTER_DEPOSIT, T0);
    let mut c = Duly::new(usdc(), intents());
    assert_eq!(c.register(), 1);
    c
}
fn invoice(c: &mut Duly, amount: u128) -> String {
    call_as(merchant(), INVOICE_DEPOSIT, T0);
    c.create_invoice(U128(amount), U64(T0 + 30 * DAY), DOC.into(), None, None).id
}
fn pay(c: &mut Duly, msg: &str, amount: u128) -> U128 {
    pay_at(c, msg, amount, T0 + DAY)
}
fn pay_at(c: &mut Duly, msg: &str, amount: u128, now: u64) -> U128 {
    call_as(usdc(), zero(), now);
    c.ft_on_transfer(intents(), U128(amount), msg.to_string())
}
fn with_tax_and_designer(c: &mut Duly) {
    call_as(merchant(), PAYEE_ROW_DEPOSIT.saturating_mul(2), T0);
    c.set_shares(vec![
        Share { to: tax(), bps: 2000, label: "Tax".into() },
        Share { to: designer(), bps: 1000, label: "Designer".into() },
    ]);
}
fn status(c: &Duly, id: &str) -> String {
    c.get_invoice(id.into()).unwrap().status
}
fn bal(c: &Duly, a: AccountId) -> u128 {
    c.balance_of(a).0
}

// ---------------------------------------------------------------- id handling

#[test]
fn ids_round_trip_and_reject_garbage() {
    let k = invoice_key(7, 42);
    assert_eq!(format_id(k), "7-42");
    assert_eq!(parse_id("7-42"), Some(k));
    for bad in ["", "7", "-", "7-", "-42", "a-b", "7-42-1", "99999999999-1", "1-99999999999"] {
        assert_eq!(parse_id(bad), None, "{bad}");
    }
}

#[test]
fn hex_is_strict() {
    assert!(hex_32(DOC).is_some());
    assert!(hex_32(&DOC[1..]).is_none());
    assert!(hex_32(&DOC.to_uppercase()).is_none());
    assert_eq!(to_hex(&hex_32(DOC).unwrap()), DOC);
}

// --------------------------------------------------------------- registration

#[test]
#[should_panic(expected = "Attach the register deposit")]
fn register_needs_deposit() {
    call_as(merchant(), zero(), T0);
    Duly::new(usdc(), intents()).register();
}

#[test]
#[should_panic(expected = "Already registered")]
fn register_twice_fails() {
    let mut c = setup();
    call_as(merchant(), REGISTER_DEPOSIT, T0);
    c.register();
}

#[test]
fn register_deposit_covers_full_merchant_record() {
    let mut c = setup();
    let before = env::storage_usage();
    // worst case: longest account ids, four shares, longest labels
    call_as(acc(&"a".repeat(64)), REGISTER_DEPOSIT, T0);
    c.register();
    let long = |i: u8| -> AccountId { acc(&format!("{}", (b'b' + i) as char).repeat(64)) };
    let shares: Vec<Share> = (0..4)
        .map(|i| Share { to: long(i), bps: 100, label: "x".repeat(MAX_LABEL_BYTES) })
        .collect();
    call_as(acc(&"a".repeat(64)), PAYEE_ROW_DEPOSIT.saturating_mul(4), T0);
    c.set_shares(shares);
    call_as(acc(&"a".repeat(64)), yocto1(), T0);
    c.set_agent(Some(long(4)), 100, Some(long(5)), U128(1));
    c.merchants.flush();
    c.mids.flush();
    c.balances.flush();
    let used = env::storage_usage() - before;
    let paid = (REGISTER_DEPOSIT.as_yoctonear() + 4 * PAYEE_ROW_DEPOSIT.as_yoctonear()) / 10u128.pow(19);
    assert!((used as u128) <= paid, "used {used} bytes, paid for {paid}");
}

#[test]
fn invoice_deposit_covers_invoice_with_all_payment_records() {
    let mut c = setup();
    let id = invoice(&mut c, 3_000_000);
    c.invoices.flush();
    let before = env::storage_usage();
    let longest = "x".repeat(MAX_REFUND_TO_BYTES);
    for _ in 0..MAX_PAYMENTS {
        pay(&mut c, &format!("{id}|{longest}"), 1_000_000);
    }
    c.invoices.flush();
    let grew = env::storage_usage() - before;
    // 40 bytes of trie overhead per key plus the key and the empty row
    let row = 40 + 64 + 8 + 200;
    let paid = INVOICE_DEPOSIT.as_yoctonear() / 10u128.pow(19);
    assert!(row + grew as u128 <= paid, "row {row} + grew {grew} > paid {paid}");
}

// ------------------------------------------------------------------- invoices

#[test]
fn numbers_are_sequential_per_merchant() {
    let mut c = setup();
    call_as(acc("other.near"), REGISTER_DEPOSIT, T0);
    c.register();
    assert_eq!(invoice(&mut c, 1_000_000), "1-1");
    assert_eq!(invoice(&mut c, 1_000_000), "1-2");
    call_as(acc("other.near"), INVOICE_DEPOSIT, T0);
    let v = c.create_invoice(U128(MIN_INVOICE), U64(T0 + 1), DOC.into(), None, None);
    assert_eq!((v.id.as_str(), v.number), ("2-1", 1));
    assert_eq!(invoice(&mut c, 1_000_000), "1-3");
}

#[test]
#[should_panic(expected = "Not a merchant")]
fn invoice_needs_merchant() {
    let mut c = setup();
    call_as(acc("stranger.near"), INVOICE_DEPOSIT, T0);
    c.create_invoice(U128(MIN_INVOICE), U64(T0 + 1), DOC.into(), None, None);
}

#[test]
#[should_panic(expected = "Attach the invoice deposit")]
fn invoice_needs_deposit() {
    let mut c = setup();
    call_as(merchant(), zero(), T0);
    c.create_invoice(U128(MIN_INVOICE), U64(T0 + 1), DOC.into(), None, None);
}

#[test]
#[should_panic(expected = "below the minimum")]
fn invoice_minimum() {
    let mut c = setup();
    call_as(merchant(), INVOICE_DEPOSIT, T0);
    c.create_invoice(U128(MIN_INVOICE - 1), U64(T0 + 1), DOC.into(), None, None);
}

#[test]
#[should_panic(expected = "above the maximum")]
fn invoice_maximum() {
    let mut c = setup();
    call_as(merchant(), INVOICE_DEPOSIT, T0);
    c.create_invoice(U128(MAX_INVOICE + 1), U64(T0 + 1), DOC.into(), None, None);
}

#[test]
#[should_panic(expected = "Due date is in the past")]
fn invoice_due_date_in_past() {
    let mut c = setup();
    call_as(merchant(), INVOICE_DEPOSIT, T0);
    c.create_invoice(U128(MIN_INVOICE), U64(T0 - 1), DOC.into(), None, None);
}

#[test]
#[should_panic(expected = "Bad document hash")]
fn invoice_bad_hash() {
    let mut c = setup();
    call_as(merchant(), INVOICE_DEPOSIT, T0);
    c.create_invoice(U128(MIN_INVOICE), U64(T0 + 1), "abc".into(), None, None);
}

#[test]
fn document_fingerprint_is_fixed_when_the_invoice_is_issued() {
    // The fingerprint (SHA-256 of the encrypted line items) is written once by
    // create_invoice. Paying, refunding and discounting never touch it, and no method
    // takes a new one, so the pay page can always compare the document against it.
    let mut c = setup();
    let id = invoice(&mut c, 100_000_000);
    assert_eq!(c.get_invoice(id.clone()).unwrap().doc_hash, DOC);
    call_as(merchant(), zero(), T0);
    c.offer_discount(id.clone(), 500, U64(T0 + DAY));
    pay(&mut c, &id, 40_000_000);
    pay(&mut c, &id, 60_000_000);
    call_as(merchant(), yocto1(), T0 + 2 * DAY);
    let _ = c.refund(id.clone(), U128(1_000_000), Dest::Near { account: acc("client.near") });
    assert_eq!(c.get_invoice(id).unwrap().doc_hash, DOC);
}

#[test]
#[should_panic(expected = "Bad document hash")]
fn document_fingerprint_must_be_64_lowercase_hex() {
    let mut c = setup();
    call_as(merchant(), INVOICE_DEPOSIT, T0);
    c.create_invoice(U128(MIN_INVOICE), U64(T0 + 1), DOC.to_uppercase(), None, None);
}

#[test]
fn list_pages_through_invoices() {
    let mut c = setup();
    for _ in 0..5 {
        invoice(&mut c, 1_000_000);
    }
    let page = c.list_invoices(merchant(), 2, 2);
    assert_eq!(page.iter().map(|v| v.number).collect::<Vec<_>>(), vec![2, 3]);
    assert_eq!(c.list_invoices(merchant(), 0, 100).len(), 5);
    assert!(c.list_invoices(acc("nobody.near"), 1, 10).is_empty());
}

// ----------------------------------------------------------------- settlement

#[test]
fn exact_payment_closes_invoice_in_the_same_call() {
    let mut c = setup();
    let id = invoice(&mut c, 100_000_000);
    assert_eq!(pay(&mut c, &id, 100_000_000).0, 0);
    let v = c.get_invoice(id.clone()).unwrap();
    assert_eq!(v.status, "paid");
    assert_eq!(v.due_now.0, 0);
    assert_eq!(v.closed_at_ms.0, T0 + DAY);
    assert_eq!(bal(&c, merchant()), 100_000_000);
    assert_eq!(c.get_totals().liabilities.0, 100_000_000);
    let log = get_logs().join("");
    assert!(log.contains("EVENT_JSON"));
    assert!(log.contains("\"closed\":true"));
}

#[test]
fn set_asides_happen_in_the_settlement_step() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 100_000_000);
    assert_eq!(bal(&c, tax()), 20_000_000);
    assert_eq!(bal(&c, designer()), 10_000_000);
    assert_eq!(bal(&c, merchant()), 70_000_000);
    assert_eq!(c.get_totals().liabilities.0, 100_000_000);
    let log = get_logs().join("");
    assert!(log.contains("\"label\":\"Tax\""));
    assert!(log.contains("\"net\":\"70000000\""));
}

#[test]
fn rounding_dust_stays_with_merchant_and_nothing_is_lost() {
    let mut c = setup();
    call_as(merchant(), PAYEE_ROW_DEPOSIT.saturating_mul(2), T0);
    c.set_shares(vec![
        Share { to: tax(), bps: 3333, label: "Tax".into() },
        Share { to: designer(), bps: 3333, label: "D".into() },
    ]);
    let id = invoice(&mut c, 10_001);
    pay(&mut c, &id, 10_001);
    assert_eq!(bal(&c, tax()), 3_333);
    assert_eq!(bal(&c, designer()), 3_333);
    assert_eq!(bal(&c, merchant()), 3_335);
}

#[test]
fn partial_payments_add_up_then_close() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 40_000_000);
    let v = c.get_invoice(id.clone()).unwrap();
    assert_eq!((v.status.as_str(), v.due_now.0), ("partial", 60_000_000));
    pay(&mut c, &id, 60_000_000);
    let v = c.get_invoice(id.clone()).unwrap();
    assert_eq!((v.status.as_str(), v.due_now.0), ("paid", 0));
    assert_eq!(bal(&c, tax()), 20_000_000);
    assert_eq!(bal(&c, merchant()), 70_000_000);
    assert_eq!(v.payments.len(), 2);
}

#[test]
fn overpayment_is_kept_apart_from_set_asides() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 130_000_000);
    let v = c.get_invoice(id).unwrap();
    assert_eq!((v.status.as_str(), v.excess.0), ("paid", 30_000_000));
    assert_eq!(bal(&c, tax()), 20_000_000);
    assert_eq!(bal(&c, designer()), 10_000_000);
    assert_eq!(bal(&c, merchant()), 100_000_000);
}

#[test]
fn double_payment_is_held_as_excess_not_split_twice() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 100_000_000);
    pay(&mut c, &id, 100_000_000);
    let v = c.get_invoice(id).unwrap();
    assert_eq!((v.status.as_str(), v.excess.0), ("paid", 100_000_000));
    assert_eq!(bal(&c, tax()), 20_000_000);
    assert_eq!(bal(&c, merchant()), 170_000_000);
}

#[test]
fn unknown_invoice_goes_straight_back() {
    let mut c = setup();
    for msg in ["", "garbage", "9-9", "1-1", "1-1|x", "{\"a\":1}", "-", "99999999999-1"] {
        assert_eq!(pay(&mut c, msg, 5_000_000).0, 5_000_000, "{msg}");
    }
    assert_eq!(c.get_totals().liabilities.0, 0);
}

#[test]
#[should_panic(expected = "Only USDC is accepted")]
fn other_tokens_are_refused() {
    let mut c = setup();
    let id = invoice(&mut c, 1_000_000);
    call_as(acc("fake-usdc.near"), zero(), T0);
    c.ft_on_transfer(intents(), U128(1_000_000), id);
}

#[test]
#[should_panic(expected = "Only USDC is accepted")]
fn a_direct_call_cannot_fake_a_payment() {
    let mut c = setup();
    let id = invoice(&mut c, 1_000_000);
    call_as(merchant(), zero(), T0);
    c.ft_on_transfer(merchant(), U128(1_000_000), id);
}

#[test]
fn payment_to_cancelled_invoice_is_kept_for_refund() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 1_000_000);
    call_as(merchant(), zero(), T0);
    c.cancel_invoice(id.clone());
    assert_eq!(pay(&mut c, &id, 1_000_000).0, 0);
    let v = c.get_invoice(id).unwrap();
    assert_eq!((v.status.as_str(), v.excess.0), ("cancelled", 1_000_000));
    assert_eq!(bal(&c, tax()), 0);
    assert_eq!(bal(&c, merchant()), 1_000_000);
}

#[test]
fn refund_destination_is_recorded_and_sanitised() {
    let mut c = setup();
    let id = invoice(&mut c, 3_000_000);
    pay(&mut c, &format!("{id}|base:USDC:0xAbC123"), 1_000_000);
    pay(&mut c, &format!("{id}|x\"}},{{\"evil\":\"<script>"), 1_000_000);
    pay(&mut c, &format!("{id}|{}", "y".repeat(MAX_REFUND_TO_BYTES + 1)), 1_000_000);
    let p = c.get_invoice(id).unwrap().payments;
    assert_eq!(p[0].refund_to, "base:USDC:0xAbC123");
    assert_eq!(p[1].refund_to, "");
    assert_eq!(p[2].refund_to, "");
}

#[test]
fn direct_near_payer_becomes_its_own_refund_destination() {
    let mut c = setup();
    let id = invoice(&mut c, 1_000_000);
    call_as(usdc(), zero(), T0);
    c.ft_on_transfer(acc("client.near"), U128(1_000_000), id.clone());
    assert_eq!(c.get_invoice(id).unwrap().payments[0].refund_to, "near:USDC:client.near");
}

#[test]
fn dust_cannot_fill_the_payment_records() {
    let mut c = setup();
    let id = invoice(&mut c, 100_000_000);
    for _ in 0..5 {
        pay(&mut c, &id, 1);
    }
    assert_eq!(c.get_invoice(id.clone()).unwrap().payments.len(), 0);
    pay(&mut c, &format!("{id}|base:USDC:0xabc"), 100_000_000);
    assert_eq!(c.get_invoice(id).unwrap().payments.len(), 1);
}

#[test]
fn overdue_status_flips_with_time() {
    let mut c = setup();
    let id = invoice(&mut c, 1_000_000);
    call_as(acc("reader.near"), zero(), T0 + 29 * DAY);
    assert_eq!(status(&c, &id), "open");
    call_as(acc("reader.near"), zero(), T0 + 31 * DAY);
    assert_eq!(status(&c, &id), "overdue");
}

// ------------------------------------------------------------------ discounts

#[test]
fn early_payment_discount_closes_at_the_lower_total() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    call_as(merchant(), INVOICE_DEPOSIT, T0);
    let id = c
        .create_invoice(
            U128(100_000_000),
            U64(T0 + 30 * DAY),
            DOC.into(),
            Some(200),
            Some(U64(T0 + 10 * DAY)),
        )
        .id;
    call_as(acc("reader.near"), zero(), T0 + 9 * DAY);
    assert_eq!(c.get_invoice(id.clone()).unwrap().due_now.0, 98_000_000);
    pay_at(&mut c, &id, 98_000_000, T0 + 9 * DAY);
    assert_eq!(status(&c, &id), "paid");
    assert_eq!(bal(&c, tax()), 19_600_000);
}

#[test]
fn discount_lapses_after_its_window() {
    let mut c = setup();
    call_as(merchant(), INVOICE_DEPOSIT, T0);
    let id = c
        .create_invoice(
            U128(100_000_000),
            U64(T0 + 30 * DAY),
            DOC.into(),
            Some(200),
            Some(U64(T0 + 10 * DAY)),
        )
        .id;
    pay_at(&mut c, &id, 98_000_000, T0 + 11 * DAY);
    let v = c.get_invoice(id).unwrap();
    assert_eq!((v.status.as_str(), v.due_now.0), ("partial", 2_000_000));
}

#[test]
fn agent_offer_works_inside_limits() {
    let mut c = setup();
    let agent = acc("agent.near");
    call_as(merchant(), yocto1(), T0);
    c.set_agent(Some(agent.clone()), 300, None, U128(0));
    let id = invoice(&mut c, 100_000_000);
    let late = T0 + 31 * DAY;
    call_as(agent, zero(), late);
    c.offer_discount(id.clone(), 300, U64(late + 2 * DAY));
    assert_eq!(c.get_invoice(id).unwrap().due_now.0, 97_000_000);
}

#[test]
#[should_panic(expected = "Above the limit you were given")]
fn agent_cannot_exceed_the_cap() {
    let mut c = setup();
    let agent = acc("agent.near");
    call_as(merchant(), yocto1(), T0);
    c.set_agent(Some(agent.clone()), 300, None, U128(0));
    let id = invoice(&mut c, 100_000_000);
    let late = T0 + 31 * DAY;
    call_as(agent, zero(), late);
    c.offer_discount(id, 301, U64(late + 2 * DAY));
}

#[test]
#[should_panic(expected = "Agent can only act on overdue invoices")]
fn agent_cannot_discount_a_current_invoice() {
    let mut c = setup();
    let agent = acc("agent.near");
    call_as(merchant(), yocto1(), T0);
    c.set_agent(Some(agent.clone()), 300, None, U128(0));
    let id = invoice(&mut c, 100_000_000);
    call_as(agent, zero(), T0 + DAY);
    c.offer_discount(id, 100, U64(T0 + 2 * DAY));
}

#[test]
#[should_panic(expected = "Not your invoice")]
fn strangers_cannot_discount() {
    let mut c = setup();
    let id = invoice(&mut c, 100_000_000);
    call_as(acc("stranger.near"), zero(), T0 + 31 * DAY);
    c.offer_discount(id, 100, U64(T0 + 32 * DAY));
}

#[test]
#[should_panic(expected = "Offer window too long")]
fn offer_window_is_bounded() {
    let mut c = setup();
    let id = invoice(&mut c, 100_000_000);
    call_as(merchant(), zero(), T0);
    c.offer_discount(id, 100, U64(T0 + MAX_OFFER_MS + 1));
}

#[test]
#[should_panic(expected = "Requires attached deposit of exactly 1 yoctoNEAR")]
fn agent_limits_cannot_be_changed_by_a_function_call_key() {
    let mut c = setup();
    call_as(merchant(), zero(), T0);
    c.set_agent(Some(acc("agent.near")), 5000, None, U128(0));
}

// -------------------------------------------------------------------- cancel

#[test]
#[should_panic(expected = "Invoice is already paid")]
fn cannot_cancel_a_paid_invoice() {
    let mut c = setup();
    let id = invoice(&mut c, 2_000_000);
    pay(&mut c, &id, 2_000_000);
    call_as(merchant(), zero(), T0);
    c.cancel_invoice(id);
}

#[test]
fn a_dust_payment_cannot_block_cancelling() {
    let mut c = setup();
    let id = invoice(&mut c, 2_000_000);
    pay(&mut c, &id, 1);
    call_as(merchant(), zero(), T0);
    c.cancel_invoice(id.clone());
    let v = c.get_invoice(id).unwrap();
    assert_eq!((v.status.as_str(), v.due_now.0), ("cancelled", 0));
}

#[test]
fn a_discount_can_complete_a_part_paid_invoice() {
    let mut c = setup();
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 90_000_000);
    call_as(merchant(), zero(), T0 + DAY);
    c.offer_discount(id.clone(), 1000, U64(T0 + 2 * DAY));
    let v = c.get_invoice(id.clone()).unwrap();
    assert_eq!((v.status.as_str(), v.due_now.0), ("paid", 0));
    call_as(acc("reader.near"), zero(), T0 + 3 * DAY);
    assert_eq!(status(&c, &id), "paid");
}

#[test]
fn a_failed_refund_of_excess_leaves_the_numbers_right() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    call_as(merchant(), zero(), T0);
    c.cancel_invoice(id.clone());
    pay(&mut c, &id, 5_000_000);
    let key = parse_id(&id).unwrap();
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id.clone(), U128(5_000_000), Dest::Near { account: acc("client.near") });
    callback(vec![PromiseResult::Failed]);
    c.on_transfer(merchant(), U128(5_000_000), Some(U64(key)), U128(0), Err(PromiseError::Failed));
    let v = c.get_invoice(id).unwrap();
    assert_eq!((v.applied.0, v.excess.0, v.refunded.0), (0, 5_000_000, 0));
    assert_eq!(bal(&c, merchant()), 5_000_000);
}

#[test]
fn a_failed_refund_of_a_part_payment_restores_what_was_applied() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 2_000_000);
    let key = parse_id(&id).unwrap();
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id.clone(), U128(2_000_000), Dest::Near { account: acc("client.near") });
    assert_eq!(c.get_invoice(id.clone()).unwrap().due_now.0, 5_000_000);
    callback(vec![PromiseResult::Failed]);
    c.on_transfer(merchant(), U128(2_000_000), Some(U64(key)), U128(2_000_000), Err(PromiseError::Failed));
    let v = c.get_invoice(id).unwrap();
    assert_eq!((v.applied.0, v.due_now.0, v.status.as_str()), (2_000_000, 3_000_000, "partial"));
}

#[test]
#[should_panic(expected = "Not your invoice")]
fn cannot_cancel_someone_elses_invoice() {
    let mut c = setup();
    let id = invoice(&mut c, 2_000_000);
    call_as(acc("stranger.near"), zero(), T0);
    c.cancel_invoice(id);
}

// ------------------------------------------------------------------ money out

#[test]
fn withdraw_debits_before_the_transfer() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.withdraw(U128(2_000_000), Dest::Near { account: acc("bank.near") });
    assert_eq!(bal(&c, merchant()), 3_000_000);
    assert_eq!(c.get_totals().liabilities.0, 3_000_000);
}

#[test]
#[should_panic(expected = "Not enough balance")]
fn cannot_withdraw_more_than_balance() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.withdraw(U128(5_000_001), Dest::Near { account: acc("bank.near") });
}

#[test]
#[should_panic(expected = "No balance")]
fn strangers_have_nothing_to_withdraw() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(acc("thief.near"), yocto1(), T0);
    let _ = c.withdraw(U128(1), Dest::Near { account: acc("thief.near") });
}

#[test]
#[should_panic(expected = "Requires attached deposit of exactly 1 yoctoNEAR")]
fn withdraw_requires_a_full_access_signature() {
    let mut c = setup();
    call_as(merchant(), zero(), T0);
    let _ = c.withdraw(U128(1), Dest::Near { account: acc("bank.near") });
}

#[test]
#[should_panic(expected = "Attach more gas")]
fn withdraw_refuses_too_little_gas() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    let mut b = ctx(merchant(), yocto1(), T0);
    b.prepaid_gas(Gas::from_tgas(30));
    testing_env!(b.build());
    let _ = c.withdraw(U128(1), Dest::Intents { deposit_address: acc("abcd.near") });
}

#[test]
fn set_aside_holder_can_withdraw_its_share() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 100_000_000);
    call_as(designer(), yocto1(), T0);
    let _ = c.withdraw(U128(10_000_000), Dest::Near { account: designer() });
    assert_eq!(bal(&c, designer()), 0);
}

fn callback(results: Vec<PromiseResult>) {
    testing_env!(
        ctx(acc("dulypay.near"), zero(), T0).build(),
        near_sdk::test_vm_config(),
        RuntimeFeesConfig::test(),
        Default::default(),
        results
    );
}

#[test]
fn failed_transfer_restores_the_balance() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.withdraw(U128(5_000_000), Dest::Near { account: acc("unregistered.near") });
    callback(vec![PromiseResult::Failed]);
    c.on_transfer(merchant(), U128(5_000_000), None, U128(0), Err(PromiseError::Failed));
    assert_eq!(bal(&c, merchant()), 5_000_000);
    assert_eq!(c.get_totals().liabilities.0, 5_000_000);
    assert!(get_logs().join("").contains("payout_failed"));
}

#[test]
fn successful_transfer_keeps_the_debit() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.withdraw(U128(5_000_000), Dest::Near { account: acc("bank.near") });
    callback(vec![PromiseResult::Successful(vec![])]);
    c.on_transfer(merchant(), U128(5_000_000), None, U128(0), Ok(()));
    assert_eq!(bal(&c, merchant()), 0);
}

#[test]
fn intents_payout_restores_only_the_unused_part() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.withdraw(U128(5_000_000), Dest::Intents { deposit_address: acc("abcd.near") });
    callback(vec![PromiseResult::Successful(b"\"3000000\"".to_vec())]);
    c.on_transfer_call(merchant(), U128(5_000_000), None, U128(0), Ok(U128(3_000_000)));
    assert_eq!(bal(&c, merchant()), 2_000_000);
}

#[test]
fn intents_payout_failure_restores_everything() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.withdraw(U128(5_000_000), Dest::Intents { deposit_address: acc("abcd.near") });
    callback(vec![PromiseResult::Failed]);
    c.on_transfer_call(merchant(), U128(5_000_000), None, U128(0), Err(PromiseError::Failed));
    assert_eq!(bal(&c, merchant()), 5_000_000);
}

#[test]
fn jar_can_release_to_the_merchant_without_any_token_call() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 100_000_000);
    call_as(tax(), yocto1(), T0);
    c.send(merchant(), U128(5_000_000));
    assert_eq!(bal(&c, tax()), 15_000_000);
    assert_eq!(bal(&c, merchant()), 75_000_000);
    assert_eq!(c.get_totals().liabilities.0, 100_000_000);
}

#[test]
#[should_panic(expected = "That account has no balance here yet")]
fn send_cannot_grow_storage_for_free() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    c.send(acc("new.near"), U128(1));
}

#[test]
#[should_panic(expected = "Not enough balance")]
fn send_is_limited_by_balance() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    call_as(tax(), yocto1(), T0);
    c.send(merchant(), U128(1));
}

#[test]
fn per_invoice_set_aside_total_is_recorded() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 40_000_000);
    pay(&mut c, &id, 90_000_000);
    let v = c.get_invoice(id).unwrap();
    assert_eq!(v.set_aside.0, 30_000_000);
    assert_eq!(v.excess.0, 30_000_000);
}

// -------------------------------------------------------------------- refunds

#[test]
fn full_refund_flips_status_and_failure_undoes_it() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let key = parse_id(&id).unwrap();
    let _ = c.refund(id.clone(), U128(5_000_000), Dest::Intents { deposit_address: acc("ab.near") });
    assert_eq!(status(&c, &id), "refunded");
    assert_eq!(bal(&c, merchant()), 0);
    callback(vec![PromiseResult::Failed]);
    c.on_transfer_call(merchant(), U128(5_000_000), Some(U64(key)), U128(0), Err(PromiseError::Failed));
    assert_eq!(status(&c, &id), "paid");
    assert_eq!(bal(&c, merchant()), 5_000_000);
}

#[test]
fn partial_refund_of_a_closed_invoice() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id.clone(), U128(1_000_000), Dest::Near { account: acc("client.near") });
    let v = c.get_invoice(id).unwrap();
    assert_eq!((v.status.as_str(), v.refunded.0), ("partially_refunded", 1_000_000));
}

#[test]
fn refund_of_a_part_payment_reopens_what_is_owed() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 2_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id.clone(), U128(2_000_000), Dest::Near { account: acc("client.near") });
    let v = c.get_invoice(id).unwrap();
    assert_eq!(v.due_now.0, 5_000_000);
    assert_eq!(v.status, "refunded");
}

#[test]
fn refunding_an_overpayment_clears_the_excess() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 7_000_000);
    assert_eq!(c.get_invoice(id.clone()).unwrap().excess.0, 2_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id.clone(), U128(2_000_000), Dest::Near { account: acc("client.near") });
    let v = c.get_invoice(id).unwrap();
    assert_eq!(v.excess.0, 0);
    assert_eq!(v.status, "partially_refunded");
}

#[test]
#[should_panic(expected = "Refund above what was paid")]
fn cannot_refund_more_than_paid() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id, U128(5_000_001), Dest::Near { account: acc("client.near") });
}

#[test]
#[should_panic(expected = "Refund above what was paid")]
fn cannot_refund_twice() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id.clone(), U128(5_000_000), Dest::Near { account: acc("client.near") });
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id, U128(1), Dest::Near { account: acc("client.near") });
}

#[test]
#[should_panic(expected = "Not your invoice")]
fn strangers_cannot_refund() {
    let mut c = setup();
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(acc("thief.near"), yocto1(), T0);
    let _ = c.refund(id, U128(1), Dest::Near { account: acc("thief.near") });
}

#[test]
#[should_panic(expected = "Not enough balance")]
fn refund_needs_the_money_in_the_merchant_balance() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let id = invoice(&mut c, 100_000_000);
    pay(&mut c, &id, 100_000_000);
    call_as(merchant(), yocto1(), T0);
    let _ = c.refund(id, U128(100_000_000), Dest::Near { account: acc("client.near") });
}

// ---------------------------------------------------------------------- sweep

#[test]
fn agent_sweep_goes_only_to_the_named_account_above_the_floor() {
    let mut c = setup();
    let agent = acc("agent.near");
    call_as(merchant(), yocto1(), T0);
    c.set_agent(Some(agent.clone()), 0, Some(acc("vault.near")), U128(1_000_000));
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(agent, zero(), T0);
    let _ = c.agent_sweep(merchant());
    assert_eq!(bal(&c, merchant()), 1_000_000);
    assert!(get_logs().join("").contains("vault.near"));
}

#[test]
#[should_panic(expected = "Not the appointed agent")]
fn only_the_agent_can_sweep() {
    let mut c = setup();
    call_as(merchant(), yocto1(), T0);
    c.set_agent(Some(acc("agent.near")), 0, Some(acc("vault.near")), U128(0));
    call_as(acc("thief.near"), zero(), T0);
    let _ = c.agent_sweep(merchant());
}

#[test]
#[should_panic(expected = "Nothing above the floor")]
fn sweep_respects_the_floor() {
    let mut c = setup();
    let agent = acc("agent.near");
    call_as(merchant(), yocto1(), T0);
    c.set_agent(Some(agent.clone()), 0, Some(acc("vault.near")), U128(5_000_000));
    let id = invoice(&mut c, 5_000_000);
    pay(&mut c, &id, 5_000_000);
    call_as(agent, zero(), T0);
    let _ = c.agent_sweep(merchant());
}

// -------------------------------------------------------------------- set_shares

#[test]
#[should_panic(expected = "Set-asides add up to more than 100%")]
fn shares_cannot_exceed_everything() {
    let mut c = setup();
    call_as(merchant(), PAYEE_ROW_DEPOSIT.saturating_mul(2), T0);
    c.set_shares(vec![
        Share { to: tax(), bps: 6000, label: "Tax".into() },
        Share { to: designer(), bps: 4001, label: "D".into() },
    ]);
}

#[test]
#[should_panic(expected = "Duplicate set-aside")]
fn shares_cannot_repeat_a_payee() {
    let mut c = setup();
    call_as(merchant(), PAYEE_ROW_DEPOSIT.saturating_mul(2), T0);
    c.set_shares(vec![
        Share { to: tax(), bps: 100, label: "A".into() },
        Share { to: tax(), bps: 100, label: "B".into() },
    ]);
}

#[test]
#[should_panic(expected = "Attach the deposit for new payees")]
fn new_payee_rows_are_paid_for() {
    let mut c = setup();
    call_as(merchant(), zero(), T0);
    c.set_shares(vec![Share { to: tax(), bps: 100, label: "A".into() }]);
}

#[test]
#[should_panic(expected = "Label may use letters")]
fn labels_are_plain_text() {
    let mut c = setup();
    call_as(merchant(), PAYEE_ROW_DEPOSIT, T0);
    c.set_shares(vec![Share { to: tax(), bps: 100, label: "<b>".into() }]);
}

// ------------------------------------------------------------------ invariant

/// Deterministic pseudo-random walk over every money path. After every step the
/// sum of balances must equal what came in minus what left.
#[test]
fn balances_always_add_up() {
    let mut c = setup();
    with_tax_and_designer(&mut c);
    let holders = [merchant(), tax(), designer()];
    let mut x: u64 = 0x9e3779b97f4a7c15;
    let mut rnd = |m: u64| {
        x ^= x << 13;
        x ^= x >> 7;
        x ^= x << 17;
        x % m
    };
    let mut ids: Vec<String> = vec![];
    let mut inflow: u128 = 0;
    let mut outflow: u128 = 0;
    for _ in 0..1500 {
        match rnd(5) {
            0 => ids.push(invoice(&mut c, 10_000 + rnd(50_000_000) as u128)),
            1 | 2 if !ids.is_empty() => {
                let id = ids[rnd(ids.len() as u64) as usize].clone();
                let amount = 1 + rnd(30_000_000) as u128;
                pay(&mut c, &id, amount);
                inflow += amount;
            }
            3 => {
                let who = holders[rnd(3) as usize].clone();
                let have = bal(&c, who.clone());
                if have > 0 {
                    let amount = 1 + rnd(have as u64) as u128;
                    call_as(who.clone(), yocto1(), T0);
                    let _ = c.withdraw(U128(amount), Dest::Near { account: acc("bank.near") });
                    if rnd(4) == 0 {
                        callback(vec![PromiseResult::Failed]);
                        c.on_transfer(who, U128(amount), None, U128(0), Err(PromiseError::Failed));
                    } else {
                        outflow += amount;
                    }
                }
            }
            _ if !ids.is_empty() => {
                let id = ids[rnd(ids.len() as u64) as usize].clone();
                let v = c.get_invoice(id.clone()).unwrap();
                let room = v.paid.0 - v.refunded.0;
                let have = bal(&c, merchant());
                let max = room.min(have);
                if max > 0 {
                    let amount = 1 + rnd(max as u64) as u128;
                    call_as(merchant(), yocto1(), T0);
                    let _ = c.refund(id, U128(amount), Dest::Near { account: acc("client.near") });
                    outflow += amount;
                }
            }
            _ => {}
        }
        let sum: u128 = holders.iter().map(|h| bal(&c, h.clone())).sum();
        assert_eq!(sum, inflow - outflow);
        assert_eq!(c.get_totals().liabilities.0, sum);
    }
    assert!(inflow > 0 && outflow > 0);
}