#![allow(deprecated)]

use anchor_lang::prelude::*;
use light_compressible::CreateAccountsProof;
use light_sdk::derive_light_cpi_signer;
use light_sdk_macros::{light_program, LightAccounts};
use light_sdk_types::CpiSigner;
use light_token::instruction::{COMPRESSIBLE_CONFIG_V1, RENT_SPONSOR as LIGHT_TOKEN_RENT_SPONSOR};

declare_id!("9p5BUDtVmRRJqp2sN73ZUZDbaYtYvEWuxzrHH3A2ni9y");

pub const LIGHT_CPI_SIGNER: CpiSigner =
    derive_light_cpi_signer!("9p5BUDtVmRRJqp2sN73ZUZDbaYtYvEWuxzrHH3A2ni9y");

pub const VAULT_AUTH_SEED: &[u8] = b"vault_auth";
pub const VAULT_SEED: &[u8] = b"vault";

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct CreateTokenVaultParams {
    pub create_accounts_proof: CreateAccountsProof,
    pub vault_bump: u8,
}

#[derive(Accounts, LightAccounts)]
#[instruction(params: CreateTokenVaultParams)]
pub struct CreateTokenVault<'info> {
    #[account(mut)]
    pub fee_payer: Signer<'info>,

    /// CHECK: Token mint for the vault
    pub mint: AccountInfo<'info>,

    /// CHECK: Validated by seeds constraint
    #[account(
        seeds = [VAULT_AUTH_SEED],
        bump,
    )]
    pub vault_authority: UncheckedAccount<'info>,

    /// CHECK: Validated by seeds constraint and light_account macro
    #[account(
        mut,
        seeds = [VAULT_SEED, mint.key().as_ref()],
        bump,
    )]
    #[light_account(
        init,
        token::authority = [VAULT_SEED, self.mint.key()],
        token::mint = mint,
        token::owner = vault_authority,
        token::bump = params.vault_bump
    )]
    pub vault: UncheckedAccount<'info>,

    /// CHECK: Validated by address constraint
    #[account(address = COMPRESSIBLE_CONFIG_V1)]
    pub light_token_compressible_config: AccountInfo<'info>,

    /// CHECK: Validated by address constraint
    #[account(mut, address = LIGHT_TOKEN_RENT_SPONSOR)]
    pub light_token_rent_sponsor: AccountInfo<'info>,

    /// CHECK: Light token CPI authority
    pub light_token_cpi_authority: AccountInfo<'info>,

    /// CHECK: Light token program for CPI
    pub light_token_program: AccountInfo<'info>,

    pub system_program: Program<'info, System>,
}

#[light_program]
#[program]
pub mod light_token_macro_create_token_account {
    use super::*;

    #[allow(unused_variables)]
    pub fn create_token_vault<'info>(
        ctx: Context<'_, '_, '_, 'info, CreateTokenVault<'info>>,
        params: CreateTokenVaultParams,
    ) -> Result<()> {
        Ok(())
    }
}

use anchor_lang::{InstructionData, ToAccountMetas};
use light_client::interface::get_create_accounts_proof;
use light_program_test::{LightProgramTest, ProgramTestConfig, Rpc};
use light_token::instruction::LIGHT_TOKEN_PROGRAM_ID;
use solana_instruction::Instruction;
use solana_pubkey::Pubkey;
use solana_signer::Signer;
use test_utils::create_mint;

/// Test creating a token vault using the `#[light_account(init, token, ...)]` macro.
///
/// This test verifies:
/// 1. The macro-annotated program compiles correctly
/// 2. A token vault can be created via the generated CPI
/// 3. The vault has the correct owner and mint
#[tokio::test]
async fn test_create_token_vault() {
    use light_token::instruction::{COMPRESSIBLE_CONFIG_V1, RENT_SPONSOR};
    use light_token_macro_create_token_account::{
        CreateTokenVaultParams, VAULT_AUTH_SEED, VAULT_SEED,
    };
    use light_token_types::CPI_AUTHORITY_PDA;

    let program_id = light_token_macro_create_token_account::ID;
    let config = ProgramTestConfig::new_v2(
        true,
        Some(vec![("light_token_macro_create_token_account", program_id)]),
    );

    let mut rpc = LightProgramTest::new(config).await.unwrap();
    let payer = rpc.get_payer().insecure_clone();

    let (mint, _mint_seed) = create_mint(&mut rpc, &payer, None).await;

    // Derive PDAs
    let (vault_authority, _auth_bump) =
        Pubkey::find_program_address(&[VAULT_AUTH_SEED], &program_id);
    let (vault, vault_bump) =
        Pubkey::find_program_address(&[VAULT_SEED, mint.as_ref()], &program_id);

    // Get proof for token-only instruction (empty inputs)
    let proof_result = get_create_accounts_proof(&rpc, &program_id, vec![])
        .await
        .unwrap();

    // Build instruction accounts
    let accounts = light_token_macro_create_token_account::accounts::CreateTokenVault {
        fee_payer: payer.pubkey(),
        mint,
        vault_authority,
        vault,
        light_token_compressible_config: COMPRESSIBLE_CONFIG_V1,
        light_token_rent_sponsor: RENT_SPONSOR,
        light_token_cpi_authority: CPI_AUTHORITY_PDA.into(),
        light_token_program: LIGHT_TOKEN_PROGRAM_ID,
        system_program: solana_sdk::system_program::ID,
    };

    // Build instruction data
    let instruction_data = light_token_macro_create_token_account::instruction::CreateTokenVault {
        params: CreateTokenVaultParams {
            create_accounts_proof: proof_result.create_accounts_proof,
            vault_bump,
        },
    };

    let instruction = Instruction {
        program_id,
        accounts: [
            accounts.to_account_metas(None),
            proof_result.remaining_accounts,
        ]
        .concat(),
        data: instruction_data.data(),
    };

    // Execute the instruction
    // Note: This may fail without InitializeRentFreeConfig setup.
    // The full test requires rent-free config initialization.
    let result = rpc
        .create_and_send_transaction(&[instruction], &payer.pubkey(), &[&payer])
        .await;

    // For now, we verify the instruction builds correctly.
    // Full execution requires additional setup (InitializeRentFreeConfig, etc.)
    println!("Transaction result: {:?}", result);
}