Redelegation

async function migrateToLinea(
  userId: string,
  ethereumWalletAddress: string,
  lineaWalletAddress: string
) {
  console.log('Step 1: Delegate new Linea wallet');
  await completeDelegationFlow(
    userId,
    'linea',
    'usdc',
    '10000',
    lineaWalletAddress
  );

  console.log('Step 2: Update priority to prefer Linea');
  const wallets = await getCurrentPriority(userId);

  const lineaWallet = wallets.find(w => w.address === lineaWalletAddress);
  const ethereumWallet = wallets.find(w => w.address === ethereumWalletAddress);

  if (lineaWallet && ethereumWallet) {
    await updatePriority(userId, [
      { id: lineaWallet.id, priority: 1 },
      { id: ethereumWallet.id, priority: 2 }
    ]);
  }

  console.log('Step 3: Optional - Revoke Ethereum delegation');
  // User can manually revoke in their wallet or leave as backup
}

async function increaseAllowance(
  userId: string,
  walletAddress: string,
  currentAllowance: number,
  additionalAmount: number
): Promise<void> {
  const newAllowance = currentAllowance + additionalAmount;

  console.log(`Increasing allowance from ${currentAllowance} to ${newAllowance}`);

  const wallet = await getExternalWallets(userId);
  const targetWallet = wallet.find(w => w.address === walletAddress);

  if (!targetWallet) {
    throw new Error('Wallet not found');
  }

  await completeDelegationFlow(
    userId,
    targetWallet.network as any,
    targetWallet.currency as any,
    newAllowance.toString(),
    walletAddress
  );

  console.log('✅ Allowance increased successfully');
}

interface ContractUpgrade {
  network: 'linea' | 'ethereum' | 'solana';
  newSpenderAddress: string;
  newTokenAddress?: string;
  effectiveDate: Date;
}

async function migrateToNewContract(
  userId: string,
  walletAddress: string,
  upgrade: ContractUpgrade
): Promise<void> {
  const wallets = await getExternalWallets(userId);
  const wallet = wallets.find(w =>
    w.address === walletAddress && w.network === upgrade.network
  );

  if (!wallet) {
    throw new Error('Wallet not found for migration');
  }

  console.log('Starting contract upgrade migration...');
  console.log(`Network: ${upgrade.network}`);
  console.log(`New spender: ${upgrade.newSpenderAddress}`);

  await completeDelegationFlow(
    userId,
    wallet.network as any,
    wallet.currency as any,
    wallet.allowance,
    walletAddress,
    {
      spenderAddress: upgrade.newSpenderAddress,
      tokenAddress: upgrade.newTokenAddress
    }
  );

  console.log('✅ Migration to new contract complete');

  const updated = await getExternalWallets(userId);
  const updatedWallet = updated.find(w => w.address === walletAddress);

  console.log('Updated wallet:', updatedWallet);
}

async function batchRedelegate(
  userId: string,
  updates: Array<{
    address: string;
    newAllowance: string;
  }>
): Promise<{
  successful: string[];
  failed: Array<{ address: string; error: string }>;
}> {
  const results = {
    successful: [] as string[],
    failed: [] as Array<{ address: string; error: string }>
  };

  const wallets = await getExternalWallets(userId);

  for (const update of updates) {
    try {
      const wallet = wallets.find(w => w.address === update.address);

      if (!wallet) {
        throw new Error('Wallet not found');
      }

      await completeDelegationFlow(
        userId,
        wallet.network as any,
        wallet.currency as any,
        update.newAllowance,
        update.address
      );

      results.successful.push(update.address);
      console.log(`✅ Redelegated ${update.address}`);

    } catch (error: any) {
      results.failed.push({
        address: update.address,
        error: error.message
      });
      console.error(`❌ Failed to redelegate ${update.address}:`, error);
    }

    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  return results;
}

describe('Redelegation', () => {
  it('should increase allowance successfully', async () => {
    const initialAllowance = 5000;
    const additionalAmount = 5000;
    const expectedNew = 10000;

    await increaseAllowance(
      userId,
      walletAddress,
      initialAllowance,
      additionalAmount
    );

    const wallets = await getExternalWallets(userId);
    const wallet = wallets.find(w => w.address === walletAddress);

    expect(wallet?.allowance).toBe(expectedNew.toString());
  });

  it('should handle contract upgrade migration', async () => {
    const upgrade: ContractUpgrade = {
      network: 'linea',
      newSpenderAddress: '0xNewSpender...',
      effectiveDate: new Date()
    };

    await migrateToNewContract(userId, walletAddress, upgrade);

    // Verify new contract is being used
    const wallets = await getExternalWallets(userId);
    const wallet = wallets.find(w => w.address === walletAddress);

    expect(wallet).toBeDefined();
    // Additional verification that new spender is active
  });

  it('should batch redelegate multiple wallets', async () => {
    const updates = [
      { address: wallet1, newAllowance: '10000' },
      { address: wallet2, newAllowance: '5000' }
    ];

    const results = await batchRedelegate(userId, updates);

    expect(results.successful).toHaveLength(2);
    expect(results.failed).toHaveLength(0);
  });
});

interface RedelegationMetrics {
  totalRedelegations: number;
  redelegationsByReason: {
    allowanceIncrease: number;
    allowanceDecrease: number;
    contractUpgrade: number;
    networkMigration: number;
    security: number;
  };
  averageNewAllowance: number;
  redelegationSuccessRate: number;
}

async function trackRedelegation(
  userId: string,
  reason: string,
  oldAllowance: number,
  newAllowance: number,
  success: boolean
) {
  await analytics.track('wallet_redelegation', {
    userId,
    reason,
    oldAllowance,
    newAllowance,
    change: newAllowance - oldAllowance,
    changePercent: ((newAllowance - oldAllowance) / oldAllowance) * 100,
    success,
    timestamp: new Date()
  });
}