mod common;
use common::*;
use descro_ext_resolvers::ResolverType;
use solana_keypair::Keypair;
use solana_signer::Signer;

#[test]
fn registers_entry_with_correct_state() {
    let (mut svm, authority) = setup();

    send(
        &mut svm,
        ix_register(
            &authority.pubkey(),
            ResolverType::CentralAuthority,
            "Acme Resolvers",
            "Fast and fair dispute resolution",
            100, // 1%
            authority.pubkey(),
            "ipfs://QmTest",
        ),
        &authority,
    );

    let entry = read_entry(&svm, &authority.pubkey());
    assert_eq!(entry.authority, authority.pubkey());
    assert_eq!(entry.resolver_type, ResolverType::CentralAuthority);
    assert_eq!(entry.name, "Acme Resolvers");
    assert_eq!(entry.fee_bps, 100);
    assert_eq!(entry.total_resolved, 0);
    assert_eq!(entry.ruled_for_buyer, 0);
    assert_eq!(entry.ruled_for_seller, 0);
}

#[test]
fn duplicate_register_fails() {
    let (mut svm, authority) = setup();

    send(
        &mut svm,
        ix_register(
            &authority.pubkey(),
            ResolverType::CentralAuthority,
            "Acme",
            "",
            0,
            authority.pubkey(),
            "",
        ),
        &authority,
    );
    assert!(!try_send(
        &mut svm,
        ix_register(
            &authority.pubkey(),
            ResolverType::CentralAuthority,
            "Acme Again",
            "",
            0,
            authority.pubkey(),
            "",
        ),
        &authority,
    ));
}

#[test]
fn register_empty_name_fails() {
    let (mut svm, authority) = setup();

    assert!(!try_send(
        &mut svm,
        ix_register(
            &authority.pubkey(),
            ResolverType::CentralAuthority,
            "",
            "",
            0,
            authority.pubkey(),
            "",
        ),
        &authority,
    ));
}

#[test]
fn register_invalid_fee_bps_fails() {
    let (mut svm, authority) = setup();

    assert!(!try_send(
        &mut svm,
        ix_register(
            &authority.pubkey(),
            ResolverType::CentralAuthority,
            "Acme",
            "",
            10_001, // > 100%
            authority.pubkey(),
            "",
        ),
        &authority,
    ));
}

#[test]
fn different_authorities_have_separate_entries() {
    let (mut svm, auth1) = setup();
    let auth2 = Keypair::new();
    svm.airdrop(&auth2.pubkey(), 10_000_000_000).unwrap();

    send(
        &mut svm,
        ix_register(&auth1.pubkey(), ResolverType::CentralAuthority, "Auth1", "", 0, auth1.pubkey(), ""),
        &auth1,
    );
    send(
        &mut svm,
        ix_register(&auth2.pubkey(), ResolverType::JuryDAO, "Auth2", "", 50, auth2.pubkey(), ""),
        &auth2,
    );

    let e1 = read_entry(&svm, &auth1.pubkey());
    let e2 = read_entry(&svm, &auth2.pubkey());
    assert_eq!(e1.name, "Auth1");
    assert_eq!(e2.name, "Auth2");
    assert_ne!(resolver_entry_pda(&auth1.pubkey()), resolver_entry_pda(&auth2.pubkey()));
}