error[E0716]: temporary value dropped while borrowed
error: lifetime may not live long enough

pub fn multi_hop_swap(
    ctx: Context<SwapAccounts>,
    route_plan: Vec<SwapStep>
) -> Result<()> {
    // remaining_accounts = [pool1, pool2, pool3, token_a, token_b, ...]
    // ルートによって2個〜10個以上のプールを通過

    for (i, step) in route_plan.iter().enumerate() {
        let pool_account = &ctx.remaining_accounts[i];
        // 各プールでスワップ処理...
    }
}

pub fn bulk_transfer(
    ctx: Context<BulkTransfer>,
    nft_list: Vec<NftData>
) -> Result<()> {
    // remaining_accounts = [nft1_account, nft2_account, nft3_account, ...]
    // 処理数によって可変（1個〜35個程度まで）

    for (i, nft_data) in nft_list.iter().enumerate() {
        let nft_account = &ctx.remaining_accounts[i];
        // 各NFTを処理...
    }
}

pub fn distribute_rewards(
    ctx: Context<GameRewards>,
    participants: Vec<PlayerData>
) -> Result<()> {
    // remaining_accounts = [player1, player2, player3, ...]
    // 参加プレイヤー数によって可変

    for (participant, account_info) in participants.iter().zip(ctx.remaining_accounts.iter()) {
        // 各プレイヤーに報酬を配布...
    }
}

// ❌ 非効率：各NFTごとに別トランザクション
transfer_nft(nft1) // Transaction 1 + 手数料
transfer_nft(nft2) // Transaction 2 + 手数料
transfer_nft(nft3) // Transaction 3 + 手数料

// ✅ 効率的：1トランザクションで完結
bulk_transfer([nft1, nft2, nft3]) // Transaction 1のみ

// Anchorの基本構造
#[derive(Accounts)]
pub struct MyAccounts<'info> {  // ← 'info ライフタイムパラメータ
    pub user: Signer<'info>,
    pub token_account: Account<'info, TokenAccount>,
}

pub fn my_instruction(ctx: Context<MyAccounts>) -> Result<()> {
    // ctx.accounts 内のすべてのアカウントは 'info ライフタイムを持つ
    // この 'info は命令の実行期間全体にわたって有効
}

pub struct Context<'a, 'b, 'c, 'info, T> {
    pub remaining_accounts: &'c [AccountInfo<'info>], // ← 'info ライフタイム
    // その他のフィールド...
}

#[derive(Accounts)]
pub struct DynamicAccounts<'info> {
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
    // 動的に追加されるアカウントは remaining_accounts から取得
}

pub fn process_dynamic_accounts(
    ctx: Context<DynamicAccounts>,
    target_keys: Vec<Pubkey>,
) -> Result<()> {
    // remaining_accounts を使って動的にアカウントを処理
    for (i, target_key) in target_keys.iter().enumerate() {
        let account_info = &ctx.remaining_accounts[i];
        // アカウント処理...
    }
    Ok(())
}

// パターン1: インデックスベースアクセス
let token_account = &ctx.remaining_accounts[0];

// パターン2: 検索ベースアクセス
let account_info = ctx.remaining_accounts
    .iter()
    .find(|acc| acc.key == &target_key)
    .ok_or(CustomError::AccountNotFound)?;

// パターン3: 条件付きフィルタリング
let valid_accounts: Vec<_> = ctx.remaining_accounts
    .iter()
    .filter(|acc| acc.is_signer)
    .collect();

pub fn problematic_cpi_call(ctx: Context<DynamicAccounts>) -> Result<()> {
    // これは失敗する
    let account_info = ctx.remaining_accounts
        .iter()
        .find(|acc| acc.key == &target_key)?; // イテレータのライフタイム

    // CPIコールでaccount_infoを使用しようとするとライフタイムエラー
    token::transfer(
        CpiContext::new(
            ctx.accounts.token_program.to_account_info(),
            token::Transfer {
                from: account_info, // ❌ ライフタイムエラー
                to: ctx.accounts.destination.to_account_info(),
                authority: ctx.accounts.authority.to_account_info(),
            },
        ),
        amount,
    )?;

    Ok(())
}

// ボローチェッカーの分析例
pub fn analyze_lifetimes(ctx: Context<DynamicAccounts>) -> Result<()> {
    // 1. remaining_accounts は 'info ライフタイムを持つ
    // 2. iter() は remaining_accounts を借用する
    let iter = ctx.remaining_accounts.iter(); // 借用開始

    // 3. find() はイテレータの要素への参照を返す
    let account_info = iter.find(|acc| acc.key == &target_key)?;

    // 4. この時点で account_info のライフタイムは iter に依存
    // 5. CPIコールは 'info と同等のライフタイムを要求
    // 6. しかし account_info は iter の短いライフタイムしか持たない
    // → ライフタイム競合！
}

error[E0716]: temporary value dropped while borrowed
  --> src/lib.rs:XX:XX
   |
XX |     let account_info = ctx.remaining_accounts.iter()
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
XX |         .find(|acc| acc.key == &target_key)?;
   |                                              - temporary value is freed at the end of this statement
XX |
XX |     token::transfer(
   |     --------------- borrow later used here

pub fn solution_clone_approach(
    ctx: Context<DynamicAccounts>,
    target_key: Pubkey,
) -> Result<()> {
    // アカウント情報を事前に検索・複製
    let account_pubkey = ctx.remaining_accounts
        .iter()
        .find(|acc| acc.key == &target_key)
        .map(|acc| *acc.key)
        .ok_or(CustomError::AccountNotFound)?;

    // インデックスも保存
    let account_index = ctx.remaining_accounts
        .iter()
        .position(|acc| acc.key == &target_key)
        .ok_or(CustomError::AccountNotFound)?;

    // 直接インデックスでアクセス（ライフタイム競合なし）
    let account_info = &ctx.remaining_accounts[account_index];

    // CPIコールが可能
    token::transfer(
        CpiContext::new(
            ctx.accounts.token_program.to_account_info(),
            token::Transfer {
                from: account_info.clone(), // ✅ 成功
                to: ctx.accounts.destination.to_account_info(),
                authority: ctx.accounts.authority.to_account_info(),
            },
        ),
        amount,
    )?;

    Ok(())
}

pub fn solution_structured_access(
    ctx: Context<DynamicAccounts>,
    operations: Vec<TokenOperation>,
) -> Result<()> {
    // 操作に必要なアカウントインデックスを事前計算
    let account_indices: Result<Vec<usize>> = operations
        .iter()
        .map(|op| {
            ctx.remaining_accounts
                .iter()
                .position(|acc| acc.key == &op.account_key)
                .ok_or(CustomError::AccountNotFound)
        })
        .collect();

    let indices = account_indices?;

    // 各操作を実行（ライフタイム競合なし）
    for (operation, &index) in operations.iter().zip(indices.iter()) {
        let account_info = &ctx.remaining_accounts[index];
        execute_token_operation(ctx, account_info, operation)?;
    }

    Ok(())
}

fn execute_token_operation(
    ctx: &Context<DynamicAccounts>,
    account_info: &AccountInfo,
    operation: &TokenOperation,
) -> Result<()> {
    // 個別の操作実行
    match operation.operation_type {
        OperationType::Transfer => {
            token::transfer(
                CpiContext::new(
                    ctx.accounts.token_program.to_account_info(),
                    token::Transfer {
                        from: account_info.clone(),
                        to: ctx.accounts.destination.to_account_info(),
                        authority: ctx.accounts.authority.to_account_info(),
                    },
                ),
                operation.amount,
            )?;
        }
        // 他の操作...
    }
    Ok(())
}

pub fn solution_function_split(
    ctx: Context<DynamicAccounts>,
    target_key: Pubkey,
) -> Result<()> {
    // アカウント検証フェーズ
    let account_index = find_account_index(&ctx.remaining_accounts, &target_key)?;

    // CPI実行フェーズ（分離された関数）
    execute_cpi_with_account(ctx, account_index)?;

    Ok(())
}

fn find_account_index(
    remaining_accounts: &[AccountInfo],
    target_key: &Pubkey,
) -> Result<usize> {
    remaining_accounts
        .iter()
        .position(|acc| acc.key == target_key)
        .ok_or_else(|| error!(CustomError::AccountNotFound))
}

fn execute_cpi_with_account(
    ctx: Context<DynamicAccounts>,
    account_index: usize,
) -> Result<()> {
    let account_info = &ctx.remaining_accounts[account_index];

    token::transfer(
        CpiContext::new(
            ctx.accounts.token_program.to_account_info(),
            token::Transfer {
                from: account_info.clone(),
                to: ctx.accounts.destination.to_account_info(),
                authority: ctx.accounts.authority.to_account_info(),
            },
        ),
        TRANSFER_AMOUNT,
    )?;

    Ok(())
}