use rand::RngCore;

use monero_serai::transaction::Transaction;

mod runner;

test!(
  scan_standard_address,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner =
        Scanner::from_view(runner::random_address().1, Network::Mainnet, Some(HashSet::new()));
      builder.add_payment(scanner.address(AddressSpec::Standard), 5);
      (builder.build().unwrap(), (scanner,))
    },
    |_, tx: Transaction, _, mut state: (Scanner,)| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
    },
  ),
);

test!(
  scan_subaddress,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner =
        Scanner::from_view(runner::random_address().1, Network::Mainnet, Some(HashSet::new()));
      let subaddress_index = (0, 1);
      builder.add_payment(
        scanner.address(AddressSpec::Subaddress(subaddress_index.0, subaddress_index.1)),
        5,
      );
      (builder.build().unwrap(), (scanner, subaddress_index))
    },
    |_, tx: Transaction, _, mut state: (Scanner, (u32, u32))| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.metadata.subaddress, state.1);
    },
  ),
);

test!(
  scan_integrated_address,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner =
        Scanner::from_view(runner::random_address().1, Network::Mainnet, Some(HashSet::new()));
      let mut payment_id = [0u8; 8];
      OsRng.fill_bytes(&mut payment_id);

      builder.add_payment(scanner.address(AddressSpec::Integrated(payment_id)), 5);
      (builder.build().unwrap(), (scanner, payment_id))
    },
    |_, tx: Transaction, _, mut state: (Scanner, [u8; 8])| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.metadata.payment_id, state.1);
    },
  ),
);

test!(
  scan_featured_standard,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner =
        Scanner::from_view(runner::random_address().1, Network::Mainnet, Some(HashSet::new()));
      builder.add_payment(scanner.address(AddressSpec::Featured(None, None, false)), 5);
      (builder.build().unwrap(), (scanner,))
    },
    |_, tx: Transaction, _, mut state: (Scanner,)| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
    },
  ),
);

test!(
  scan_featured_subaddress,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner =
        Scanner::from_view(runner::random_address().1, Network::Mainnet, Some(HashSet::new()));
      let subaddress_index = (0, 2);
      builder.add_payment(
        scanner.address(AddressSpec::Featured(Some(subaddress_index), None, false)),
        5,
      );
      (builder.build().unwrap(), (scanner, subaddress_index))
    },
    |_, tx: Transaction, _, mut state: (Scanner, (u32, u32))| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.metadata.subaddress, state.1);
    },
  ),
);

test!(
  scan_featured_integrated,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner =
        Scanner::from_view(runner::random_address().1, Network::Mainnet, Some(HashSet::new()));
      let mut payment_id = [0u8; 8];
      OsRng.fill_bytes(&mut payment_id);

      builder.add_payment(scanner.address(AddressSpec::Featured(None, Some(payment_id), false)), 5);
      (builder.build().unwrap(), (scanner, payment_id))
    },
    |_, tx: Transaction, _, mut state: (Scanner, [u8; 8])| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.metadata.payment_id, state.1);
    },
  ),
);

test!(
  scan_featured_integrated_subaddress,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner =
        Scanner::from_view(runner::random_address().1, Network::Mainnet, Some(HashSet::new()));
      let subaddress_index = (0, 3);

      let mut payment_id = [0u8; 8];
      OsRng.fill_bytes(&mut payment_id);

      builder.add_payment(
        scanner.address(AddressSpec::Featured(Some(subaddress_index), Some(payment_id), false)),
        5,
      );
      (builder.build().unwrap(), (scanner, payment_id, subaddress_index))
    },
    |_, tx: Transaction, _, mut state: (Scanner, [u8; 8], (u32, u32))| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.metadata.payment_id, state.1);
      assert_eq!(output.metadata.subaddress, state.2);
    },
  ),
);

test!(
  scan_guaranteed_standard,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner = Scanner::from_view(runner::random_address().1, Network::Mainnet, None);

      builder.add_payment(scanner.address(AddressSpec::Featured(None, None, true)), 5);
      (builder.build().unwrap(), (scanner,))
    },
    |_, tx: Transaction, _, mut state: (Scanner,)| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
    },
  ),
);

test!(
  scan_guaranteed_subaddress,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner = Scanner::from_view(runner::random_address().1, Network::Mainnet, None);
      let subaddress_index = (0, 1);

      builder
        .add_payment(scanner.address(AddressSpec::Featured(Some(subaddress_index), None, true)), 5);
      (builder.build().unwrap(), (scanner, subaddress_index))
    },
    |_, tx: Transaction, _, mut state: (Scanner, (u32, u32))| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.metadata.subaddress, state.1);
    },
  ),
);

test!(
  scan_guaranteed_integrated,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner = Scanner::from_view(runner::random_address().1, Network::Mainnet, None);
      let mut payment_id = [0u8; 8];
      OsRng.fill_bytes(&mut payment_id);

      builder.add_payment(scanner.address(AddressSpec::Featured(None, Some(payment_id), true)), 5);
      (builder.build().unwrap(), (scanner, payment_id))
    },
    |_, tx: Transaction, _, mut state: (Scanner, [u8; 8])| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.metadata.payment_id, state.1);
    },
  ),
);

test!(
  scan_guaranteed_integrated_subaddress,
  (
    |_, mut builder: Builder, _| async move {
      let mut scanner = Scanner::from_view(runner::random_address().1, Network::Mainnet, None);
      let subaddress_index = (0, 2);

      let mut payment_id = [0u8; 8];
      OsRng.fill_bytes(&mut payment_id);

      builder.add_payment(
        scanner.address(AddressSpec::Featured(Some(subaddress_index), Some(payment_id), true)),
        5,
      );
      (builder.build().unwrap(), (scanner, payment_id, subaddress_index))
    },
    |_, tx: Transaction, _, mut state: (Scanner, [u8; 8], (u32, u32))| async move {
      let output = state.0.scan_transaction(&tx).not_locked().swap_remove(0);
      assert_eq!(output.commitment().amount, 5);
      assert_eq!(output.metadata.payment_id, state.1);
      assert_eq!(output.metadata.subaddress, state.2);
    },
  ),
);