use solana_program_test::*;

mod metadata_tests {
    use anchor_lang::{InstructionData,  ToAccountMetas};
    use libreplex::{
        accounts::CreateMetadata,
        Asset, CreateMetadataInput,
    };
    use inscriptions::{
        accounts::AppendToOrdinal,
        accounts::CreateOrdinal,
        instructions::{AppendToOrdinalInput, CreateOrdinalInput}, Inscription,
    };
    use solana_program::{instruction::Instruction, pubkey::Pubkey, system_program, system_instruction, program::invoke, rent::Rent};
    use solana_sdk::{signature::Keypair, signer::Signer, transaction::Transaction};

    use super::*;
    #[tokio::test]
    async fn create_metadata_ordinal_test() {
        let initial_data = vec![
            66, 77, 246, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 40, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 1,
            0, 24, 0, 0, 0, 0, 0, 192, 0, 0, 0, 232, 3, 0, 0, 232, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            184, 184, 56, 112, 80, 0, 96, 232, 104, 128, 128, 16, 32, 24, 248, 144, 176, 128, 56,
            72, 152, 64, 224, 240, 184, 136, 56, 16, 48, 0, 16, 216, 104, 192, 128, 16, 80, 40,
            248, 192, 208, 128, 232, 120, 152, 192, 32, 240, 184, 224, 56, 192, 64, 0, 24, 160,
            104, 0, 0, 16, 24, 96, 248, 80, 192, 128, 224, 32, 152, 64, 128, 240, 184, 152, 56, 48,
            144, 0, 136, 136, 104, 192, 128, 16, 24, 120, 248, 208, 112, 128, 112, 104, 152, 0, 96,
            240, 184, 24, 56, 48, 144, 0, 216, 8, 104, 128, 128,
        ];
        let append_data = vec![
            16, 112, 248, 248, 128, 112, 128, 144, 232, 152, 0, 96, 240, 184, 88, 56, 176, 16, 0,
            136, 200, 104, 160, 128, 16, 56, 56, 248, 176, 240, 128, 208, 168, 152, 0, 96, 240,
            184, 0, 56, 0, 0, 0, 200, 0, 104, 224, 0, 16, 56, 0, 248, 64, 0, 128, 248, 0, 152, 64,
            0, 240, 184, 120, 56, 240, 208, 0, 40, 40, 104, 96, 128, 16, 152, 216, 248, 208, 48,
            128, 8, 136, 152, 64, 224, 240,
        ];
        let program = ProgramTest::new("metadata", libreplex::ID, processor!(libreplex::entry));

        let mut context = program.start_with_context().await;
        let authority = context.payer.pubkey();

        let mint = Keypair::new();
     
        let ordinal = Keypair::new();

        let ordinal_input = inscriptions::instruction::CreateOrdinal {
            ordinal_input: CreateOrdinalInput {
                max_data_length: 500,
                initial_data: initial_data.clone(),
            },
        };

        let ordinal_account = CreateOrdinal {
            root: 
            payer: context.payer.pubkey(),
            ordinal: ordinal.pubkey(),
            system_program: system_program::id(),
        };



        // CREATE MINT
        let rent = context.banks_client.get_rent().await.unwrap();

        let create_account_tx = Transaction::new_signed_with_payer(
            &[system_instruction::create_account(
                &context.payer.pubkey(),
                &ordinal.pubkey(),
                rent.minimum_balance(Inscription::BASE_SIZE + ordinal_input.ordinal_input.max_data_length as usize),
                
                Inscription::BASE_SIZE as u64 + ordinal_input.ordinal_input.max_data_length as u64,
                &libreplex::id(),
            )],
            Some(&context.payer.pubkey()),
            &[&context.payer, &ordinal],
            context.last_blockhash
        );

        
        context.banks_client.process_transaction(create_account_tx).await.unwrap();
     
        let ordinal_ix = Instruction {
            program_id: libreplex::id(),
            data: ordinal_input.data(),
            accounts: ordinal_account.to_account_metas(None),
        };

        let ordinal_tx = Transaction::new_signed_with_payer(
            &[ordinal_ix],
            Some(&authority),
            &[&context.payer],
            context.last_blockhash,
        );

        let result = context
            .banks_client
            .process_transaction(ordinal_tx)
            .await
            .unwrap();

        // append a bit more data to the ordinal

        let append_to_ordinal_accounts = AppendToOrdinal {
            signer: authority,
            ordinal: ordinal.pubkey(),
            system_program: system_program::id(),
        };

        let append_to_ordinal_input = inscriptions::instruction::AppendToOrdinal {
            input: AppendToOrdinalInput {
                append_data: append_data.clone(),
            },
        };

        let append_to_ordinal_ix = Instruction {
            program_id: libreplex::id(),
            data: append_to_ordinal_input.data(),
            accounts: append_to_ordinal_accounts.to_account_metas(None),
        };

        let append_to_ordinal_tx = Transaction::new_signed_with_payer(
            &[append_to_ordinal_ix],
            Some(&authority),
            &[&context.payer],
            context.last_blockhash,
        );

        let result = context
            .banks_client
            .process_transaction(append_to_ordinal_tx)
            .await
            .unwrap();

        let metadata =
            Pubkey::find_program_address(&[b"metadata", mint.pubkey().as_ref()], &libreplex::ID).0;

        let permissions = Pubkey::find_program_address(
            &[b"permissions", metadata.as_ref(), authority.as_ref()],
            &libreplex::ID,
        )
        .0;

        let metadata_account = CreateMetadata {
            signer: authority,
            permissions,
            metadata,
            mint: mint.pubkey(),
            system_program: system_program::id(),
        };

        let name = "ordinal".to_owned();
        let symbol = "ORD".to_owned();
        let asset = Asset::Inscription {
            account_id: ordinal.pubkey(),
        };

        let metadata_input = libreplex::instruction::CreateMetadata {
            metadata_input: CreateMetadataInput {
                name,
                symbol,
                asset,
                description: None,
            },
        };

        let metadata_ix = Instruction {
            data: metadata_input.data(),
            program_id: libreplex::ID,
            accounts: metadata_account.to_account_metas(None),
        };

        let create_metadata_tx = Transaction::new_signed_with_payer(
            &[metadata_ix],
            Some(&authority),
            &[&context.payer, &mint],
            context.last_blockhash,
        );

        let result = context
            .banks_client
            .process_transaction(create_metadata_tx)
            .await
            .unwrap();

        let final_account = context
            .banks_client
            .get_account(ordinal.pubkey())
            .await
            .unwrap();

        let expected_data: Vec<u8> = [&initial_data[..], &append_data[..]].concat();

        match final_account {
            Some(x) => {
                let l = u32::from_le_bytes(x.data[40..44].try_into().unwrap());
                let endidx = 48 + l;
                assert_eq!(
                    expected_data.as_slice(),
                    // first 80 bytes are
                    // 8 - discriminant
                    // 32 - authority
                    // 32 - root
                    // 4 - data length (current)
                    // 4 - data length (max)
                    &x.data[48..endidx as usize]
                );
            }
            None => {
                assert_eq!(true, false);
            }
        }
    }
}