#![allow(dead_code, unused_imports)]

pub use anchor_lang::prelude::Pubkey;
use {
    anchor_lang::{
        solana_program::{instruction::Instruction, system_program},
        AccountDeserialize, InstructionData, ToAccountMetas,
    },
    descro_ext_resolvers::{ResolverEntry, ResolverType},
    litesvm::LiteSVM,
    solana_keypair::Keypair,
    solana_message::{Message, VersionedMessage},
    solana_signer::Signer,
    solana_transaction::versioned::VersionedTransaction,
};

pub fn setup() -> (LiteSVM, Keypair) {
    let program_id = descro_ext_resolvers::id();
    let mut svm = LiteSVM::new();
    let bytes = include_bytes!("../../../../target/deploy/descro_ext_resolvers.so");
    svm.add_program(program_id, bytes).unwrap();

    let authority = Keypair::new();
    svm.airdrop(&authority.pubkey(), 10_000_000_000).unwrap();

    (svm, authority)
}

pub fn resolver_entry_pda(authority: &Pubkey) -> Pubkey {
    Pubkey::find_program_address(
        &[b"resolver", authority.as_ref()],
        &descro_ext_resolvers::id(),
    )
    .0
}

pub fn send(svm: &mut LiteSVM, ix: Instruction, payer: &Keypair) {
    let blockhash = svm.latest_blockhash();
    let msg = Message::new_with_blockhash(&[ix], Some(&payer.pubkey()), &blockhash);
    let tx = VersionedTransaction::try_new(VersionedMessage::Legacy(msg), &[payer]).unwrap();
    svm.send_transaction(tx).expect("transaction failed");
}

pub fn try_send(svm: &mut LiteSVM, ix: Instruction, payer: &Keypair) -> bool {
    let blockhash = svm.latest_blockhash();
    let msg = Message::new_with_blockhash(&[ix], Some(&payer.pubkey()), &blockhash);
    let tx = VersionedTransaction::try_new(VersionedMessage::Legacy(msg), &[payer]).unwrap();
    svm.send_transaction(tx).is_ok()
}

pub fn ix_register(
    authority: &Pubkey,
    resolver_type: ResolverType,
    name: &str,
    description: &str,
    fee_bps: u16,
    fee_recipient: Pubkey,
    metadata_uri: &str,
) -> Instruction {
    let entry = resolver_entry_pda(authority);
    Instruction::new_with_bytes(
        descro_ext_resolvers::id(),
        &descro_ext_resolvers::instruction::RegisterResolver {
            resolver_type,
            name: name.to_string(),
            description: description.to_string(),
            fee_bps,
            fee_recipient,
            metadata_uri: metadata_uri.to_string(),
        }
        .data(),
        descro_ext_resolvers::accounts::RegisterResolver {
            authority: *authority,
            resolver_entry: entry,
            system_program: system_program::ID,
        }
        .to_account_metas(None),
    )
}

pub fn ix_update(
    authority: &Pubkey,
    name: &str,
    description: &str,
    fee_bps: u16,
    metadata_uri: &str,
) -> Instruction {
    let entry = resolver_entry_pda(authority);
    Instruction::new_with_bytes(
        descro_ext_resolvers::id(),
        &descro_ext_resolvers::instruction::UpdateResolver {
            name: name.to_string(),
            description: description.to_string(),
            fee_bps,
            metadata_uri: metadata_uri.to_string(),
        }
        .data(),
        descro_ext_resolvers::accounts::UpdateResolver {
            authority: *authority,
            resolver_entry: entry,
        }
        .to_account_metas(None),
    )
}

pub fn read_entry(svm: &LiteSVM, authority: &Pubkey) -> ResolverEntry {
    let pda = resolver_entry_pda(authority);
    let account = svm.get_account(&pda).expect("resolver entry not found");
    ResolverEntry::try_deserialize(&mut account.data.as_slice()).unwrap()
}