Priority Management

interface WalletPriority {
  id: number;
  address: string;
  currency: string;
  network: string;
  priority: number;
}

async function getCurrentPriority(
  userAccessToken: string
): Promise<WalletPriority[]> {
  const response = await fetch(
    'https://api.yourplatform.com/v1/wallet/external/priority',
    {
      method: 'GET',
      headers: {
        'x-client-key': process.env.CLIENT_PUBLIC_KEY!,
        'Authorization': `Bearer ${userAccessToken}`
      }
    }
  );

  if (!response.ok) {
    throw new Error('Failed to fetch wallet priority');
  }

  return await response.json();
}

interface PriorityUpdate {
  id: number;
  priority: number;
}

async function updatePriority(
  userAccessToken: string,
  updates: PriorityUpdate[]
): Promise<void> {
  const response = await fetch(
    'https://api.yourplatform.com/v1/wallet/external/priority',
    {
      method: 'PUT',
      headers: {
        'x-client-key': process.env.CLIENT_PUBLIC_KEY!,
        'Authorization': `Bearer ${userAccessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ wallets: updates })
    }
  );

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.message || 'Failed to update priority');
  }
}

import { DragDropContext, Droppable, Draggable } from 'react-beautiful-dnd';
import { useState, useEffect } from 'react';

interface Wallet {
  id: number;
  address: string;
  currency: string;
  network: string;
  balance: string;
  priority: number;
}

function PriorityManager({ userId }: { userId: string }) {
  const [wallets, setWallets] = useState<Wallet[]>([]);
  const [loading, setLoading] = useState(false);

  useEffect(() => {
    loadWallets();
  }, []);

  async function loadWallets() {
    const data = await getCurrentPriority(userId);
    setWallets(data.sort((a, b) => a.priority - b.priority));
  }

  function handleDragEnd(result: any) {
    if (!result.destination) return;

    const items = Array.from(wallets);
    const [reorderedItem] = items.splice(result.source.index, 1);
    items.splice(result.destination.index, 0, reorderedItem);

    const updatedWallets = items.map((wallet, index) => ({
      ...wallet,
      priority: index + 1
    }));

    setWallets(updatedWallets);
  }

  async function savePriority() {
    setLoading(true);
    try {
      const updates = wallets.map(w => ({ id: w.id, priority: w.priority }));
      await updatePriority(userId, updates);
      alert('Priority updated successfully!');
    } catch (error) {
      console.error('Failed to update priority:', error);
      alert('Failed to update priority');
    } finally {
      setLoading(false);
    }
  }

  return (
    <div className="priority-manager">
      <h2>Wallet Priority</h2>
      <p>Drag to reorder. Wallets at the top are charged first.</p>

      <DragDropContext onDragEnd={handleDragEnd}>
        <Droppable droppableId="wallets">
          {(provided) => (
            <div {...provided.droppableProps} ref={provided.innerRef}>
              {wallets.map((wallet, index) => (
                <Draggable
                  key={wallet.id}
                  draggableId={wallet.id.toString()}
                  index={index}
                >
                  {(provided) => (
                    <div
                      ref={provided.innerRef}
                      {...provided.draggableProps}
                      {...provided.dragHandleProps}
                      className="wallet-card"
                    >
                      <div className="priority-badge">{wallet.priority}</div>
                      <div className="wallet-info">
                        <div className="network">{wallet.network}</div>
                        <div className="address">
                          {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                        </div>
                        <div className="balance">
                          {wallet.balance} {wallet.currency.toUpperCase()}
                        </div>
                      </div>
                    </div>
                  )}
                </Draggable>
              ))}
              {provided.placeholder}
            </div>
          )}
        </Droppable>
      </DragDropContext>

      <button onClick={savePriority} disabled={loading}>
        {loading ? 'Saving...' : 'Save Priority'}
      </button>
    </div>
  );
}

function QuickActions({ wallets, onUpdate }: {
  wallets: Wallet[],
  onUpdate: (updates: PriorityUpdate[]) => void
}) {

  function optimizeForGas() {
    const gasCostOrder = ['solana', 'linea', 'ethereum'];
    const sorted = [...wallets].sort((a, b) => {
      return gasCostOrder.indexOf(a.network) - gasCostOrder.indexOf(b.network);
    });
    onUpdate(sorted.map((w, i) => ({ id: w.id, priority: i + 1 })));
  }

  function optimizeForBalance() {
    const sorted = [...wallets].sort((a, b) => {
      return parseFloat(a.balance) - parseFloat(b.balance);
    });
    onUpdate(sorted.map((w, i) => ({ id: w.id, priority: i + 1 })));
  }

  function preferNetwork(network: string) {
    const sorted = [...wallets].sort((a, b) => {
      if (a.network === network && b.network !== network) return -1;
      if (a.network !== network && b.network === network) return 1;
      return 0;
    });
    onUpdate(sorted.map((w, i) => ({ id: w.id, priority: i + 1 })));
  }

  return (
    <div className="quick-actions">
      <button onClick={optimizeForGas}>
        Optimize for Gas Fees
      </button>
      <button onClick={optimizeForBalance}>
        Use Smallest Balances First
      </button>
      <button onClick={() => preferNetwork('linea')}>
        Prefer Linea
      </button>
      <button onClick={() => preferNetwork('solana')}>
        Prefer Solana
      </button>
    </div>
  );
}

async function autoAdjustPriority(userId: string) {
  const wallets = await getExternalWallets(userId);

  const optimized = wallets
    .filter(w => parseFloat(w.balance) > 100)
    .map(wallet => {
      let score = 0;

      if (wallet.network === 'solana') score += 3;
      else if (wallet.network === 'linea') score += 2;
      else score += 1;

      if (parseFloat(wallet.balance) < 500) score += 2;
      else if (parseFloat(wallet.balance) < 1000) score += 1;

      return { ...wallet, score };
    })
    .sort((a, b) => b.score - a.score)
    .map((w, i) => ({ id: w.id, priority: i + 1 }));

  await updatePriority(userId, optimized);
}