wip

app/Filament/Company/Resources/Purchases/BillResource/Pages/ListBills.php

         return [
             Actions\Action::make('payBills')
                 ->outlined()
-                ->url(BillResource::getUrl('pay-bills')),
+                ->url(PayBills::getUrl()),
             Actions\CreateAction::make(),
         ];
     }

app/Filament/Company/Resources/Sales/InvoiceResource.php

 use App\Enums\Accounting\DocumentDiscountMethod;
 use App\Enums\Accounting\DocumentType;
 use App\Enums\Accounting\InvoiceStatus;
-use App\Enums\Accounting\PaymentMethod;
 use App\Enums\Setting\PaymentTerms;
 use App\Filament\Company\Resources\Sales\ClientResource\RelationManagers\InvoicesRelationManager;
 use App\Filament\Company\Resources\Sales\InvoiceResource\Pages;
 use App\Models\Accounting\Adjustment;
 use App\Models\Accounting\DocumentLineItem;
 use App\Models\Accounting\Invoice;
-use App\Models\Banking\BankAccount;
 use App\Models\Common\Client;
 use App\Models\Common\Offering;
 use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
 use App\Utilities\RateCalculator;
 use Awcodes\TableRepeater\Header;
-use Closure;
 use Filament\Forms;
 use Filament\Forms\Form;
 use Filament\Notifications\Notification;
                         Invoice::getReplicateAction(Tables\Actions\ReplicateAction::class),
                         Invoice::getApproveDraftAction(Tables\Actions\Action::class),
                         Invoice::getMarkAsSentAction(Tables\Actions\Action::class),
-                        Tables\Actions\Action::make('recordPaymentBulk')
+                        Tables\Actions\Action::make('recordPayment')
                             ->label('Record Payment')
                             ->icon('heroicon-m-credit-card')
+                            ->visible(function (Invoice $record) {
+                                return $record->canRecordPayment();
+                            })
                             ->url(fn (Invoice $record) => Pages\RecordPayments::getUrl([
-                                'tableFilters' => ['client_id' => ['value' => $record->client_id]],
+                                'tableFilters' => [
+                                    'client_id' => ['value' => $record->client_id],
+                                    'currency_code' => ['value' => $record->currency_code],
+                                ],
                                 'invoice_id' => $record->id,
                             ]))
                             ->openUrlInNewTab(false),
-                        Tables\Actions\Action::make('recordPayment')
-                            ->label(fn (Invoice $record) => $record->status === InvoiceStatus::Overpaid ? 'Refund Overpayment' : 'Record Payment')
-                            ->slideOver()
-                            ->modalWidth(MaxWidth::TwoExtraLarge)
-                            ->icon('heroicon-m-credit-card')
-                            ->visible(function (Invoice $record) {
-                                return $record->canRecordPayment();
-                            })
-                            ->mountUsing(function (Invoice $record, Form $form) {
-                                $form->fill([
-                                    'posted_at' => now(),
-                                    'amount' => abs($record->amount_due),
-                                ]);
-                            })
-                            ->databaseTransaction()
-                            ->successNotificationTitle('Payment recorded')
-                            ->form([
-                                Forms\Components\DatePicker::make('posted_at')
-                                    ->label('Date'),
-                                Forms\Components\Grid::make()
-                                    ->schema([
-                                        Forms\Components\Select::make('bank_account_id')
-                                            ->label('Account')
-                                            ->required()
-                                            ->live()
-                                            ->options(function () {
-                                                return BankAccount::query()
-                                                    ->join('accounts', 'bank_accounts.account_id', '=', 'accounts.id')
-                                                    ->select(['bank_accounts.id', 'accounts.name', 'accounts.currency_code'])
-                                                    ->get()
-                                                    ->mapWithKeys(function ($account) {
-                                                        $label = $account->name;
-                                                        if ($account->currency_code) {
-                                                            $label .= " ({$account->currency_code})";
-                                                        }
-
-                                                        return [$account->id => $label];
-                                                    })
-                                                    ->toArray();
-                                            })
-                                            ->searchable(),
-                                        Forms\Components\TextInput::make('amount')
-                                            ->label('Amount')
-                                            ->required()
-                                            ->money(fn (Invoice $record) => $record->currency_code)
-                                            ->live(onBlur: true)
-                                            ->helperText(function (Invoice $record, $state) {
-                                                $invoiceCurrency = $record->currency_code;
-
-                                                if (! CurrencyConverter::isValidAmount($state, 'USD')) {
-                                                    return null;
-                                                }
-
-                                                $amountDue = $record->amount_due;
-
-                                                $amount = CurrencyConverter::convertToCents($state, 'USD');
-
-                                                if ($amount <= 0) {
-                                                    return 'Please enter a valid positive amount';
-                                                }
-
-                                                if ($record->status === InvoiceStatus::Overpaid) {
-                                                    $newAmountDue = $amountDue + $amount;
-                                                } else {
-                                                    $newAmountDue = $amountDue - $amount;
-                                                }
-
-                                                return match (true) {
-                                                    $newAmountDue > 0 => 'Amount due after payment will be ' . CurrencyConverter::formatCentsToMoney($newAmountDue, $invoiceCurrency),
-                                                    $newAmountDue === 0 => 'Invoice will be fully paid',
-                                                    default => 'Invoice will be overpaid by ' . CurrencyConverter::formatCentsToMoney(abs($newAmountDue), $invoiceCurrency),
-                                                };
-                                            })
-                                            ->rules([
-                                                static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
-                                                    if (! CurrencyConverter::isValidAmount($value, 'USD')) {
-                                                        $fail('Please enter a valid amount');
-                                                    }
-                                                },
-                                            ]),
-                                    ])->columns(2),
-                                Forms\Components\Placeholder::make('currency_conversion')
-                                    ->label('Currency Conversion')
-                                    ->content(function (Forms\Get $get, Invoice $record) {
-                                        $amount = $get('amount');
-                                        $bankAccountId = $get('bank_account_id');
-
-                                        $invoiceCurrency = $record->currency_code;
-
-                                        if (empty($amount) || empty($bankAccountId) || ! CurrencyConverter::isValidAmount($amount, 'USD')) {
-                                            return null;
-                                        }
-
-                                        $bankAccount = BankAccount::with('account')->find($bankAccountId);
-                                        if (! $bankAccount) {
-                                            return null;
-                                        }
-
-                                        $bankCurrency = $bankAccount->account->currency_code ?? CurrencyAccessor::getDefaultCurrency();
-
-                                        // If currencies are the same, no conversion needed
-                                        if ($invoiceCurrency === $bankCurrency) {
-                                            return null;
-                                        }
-
-                                        // Convert amount from invoice currency to bank currency
-                                        $amountInInvoiceCurrencyCents = CurrencyConverter::convertToCents($amount, 'USD');
-                                        $amountInBankCurrencyCents = CurrencyConverter::convertBalance(
-                                            $amountInInvoiceCurrencyCents,
-                                            $invoiceCurrency,
-                                            $bankCurrency
-                                        );
-
-                                        $formattedBankAmount = CurrencyConverter::formatCentsToMoney($amountInBankCurrencyCents, $bankCurrency);
-
-                                        return "Payment will be recorded as {$formattedBankAmount} in the bank account's currency ({$bankCurrency}).";
-                                    })
-                                    ->hidden(function (Forms\Get $get, Invoice $record) {
-                                        $bankAccountId = $get('bank_account_id');
-                                        if (empty($bankAccountId)) {
-                                            return true;
-                                        }
-
-                                        $invoiceCurrency = $record->currency_code;
-
-                                        $bankAccount = BankAccount::with('account')->find($bankAccountId);
-                                        if (! $bankAccount) {
-                                            return true;
-                                        }
-
-                                        $bankCurrency = $bankAccount->account->currency_code ?? CurrencyAccessor::getDefaultCurrency();
-
-                                        // Hide if currencies are the same
-                                        return $invoiceCurrency === $bankCurrency;
-                                    }),
-                                Forms\Components\Select::make('payment_method')
-                                    ->label('Payment method')
-                                    ->required()
-                                    ->options(PaymentMethod::class),
-                                Forms\Components\Textarea::make('notes')
-                                    ->label('Notes'),
-                            ])
-                            ->action(function (Invoice $record, Tables\Actions\Action $action, array $data) {
-                                $record->recordPayment($data);
-
-                                $action->success();
-                            }),
                     ])->dropdown(false),
                     Tables\Actions\DeleteAction::make(),
                 ]),

app/Filament/Company/Resources/Sales/InvoiceResource/Pages/ListInvoices.php

     protected function getHeaderActions(): array
     {
         return [
+            Actions\Action::make('recordPayments')
+                ->outlined()
+                ->url(RecordPayments::getUrl()),
             Actions\CreateAction::make(),
         ];
     }

app/Filament/Company/Resources/Sales/InvoiceResource/Pages/RecordPayments.php

 use Filament\Forms\Form;
 use Filament\Notifications\Notification;
 use Filament\Resources\Pages\ListRecords;
+use Filament\Support\Enums\MaxWidth;
 use Filament\Support\RawJs;
 use Filament\Tables;
 use Filament\Tables\Columns\Summarizers\Summarizer;
 
     public ?array $data = [];
 
+    // New property for allocation amount
+    public ?int $allocationAmount = null;
+
     #[Url(as: 'invoice_id')]
     public ?int $invoiceId = null;
 
         return 'Record Payments';
     }
 
+    public function getMaxContentWidth(): MaxWidth | string | null
+    {
+        return 'max-w-8xl';
+    }
+
     public function mount(): void
     {
         parent::mount();
 
-        $this->form->fill();
-
         $preservedClientId = $this->tableFilters['client_id']['value'] ?? null;
+        $preservedCurrencyCode = $this->tableFilters['currency_code']['value'] ?? CurrencyAccessor::getDefaultCurrency();
 
         $this->tableFilters = [
             'client_id' => $preservedClientId ? ['value' => $preservedClientId] : [],
-            'currency_code' => ['value' => CurrencyAccessor::getDefaultCurrency()],
+            'currency_code' => ['value' => $preservedCurrencyCode],
         ];
 
         // Auto-fill payment amount if invoice_id is provided
                 $this->paymentAmounts[$invoiceId] = $invoice->amount_due;
             }
         }
+
+        $this->form->fill();
     }
 
     protected function getHeaderActions(): array
                         ->success()
                         ->send();
 
-                    $this->reset('paymentAmounts');
+                    $this->reset('paymentAmounts', 'allocationAmount');
 
                     $this->resetTable();
                 }),
         ];
     }
 
+    protected function allocateOldestFirst(Collection $invoices, int $amountInCents): void
+    {
+        $remainingAmount = $amountInCents;
+
+        $sortedInvoices = $invoices->sortBy('due_date');
+
+        foreach ($sortedInvoices as $invoice) {
+            if ($remainingAmount <= 0) {
+                break;
+            }
+
+            $amountDue = $invoice->amount_due;
+            $allocation = min($remainingAmount, $amountDue);
+
+            $this->paymentAmounts[$invoice->id] = $allocation;
+            $remainingAmount -= $allocation;
+        }
+    }
+
+    protected function hasSelectedClient(): bool
+    {
+        return ! empty($this->getTableFilterState('client_id')['value']);
+    }
+
     /**
      * @return array<int | string, string | Form>
      */
         return $form
             ->live()
             ->schema([
-                Forms\Components\Grid::make(3)
+                Forms\Components\Grid::make(2) // Changed from 3 to 4
                     ->schema([
                         Forms\Components\Select::make('bank_account_id')
                             ->label('Account')
                             ->options(PaymentMethod::class)
                             ->default(PaymentMethod::BankPayment)
                             ->softRequired(),
+                        // Allocation amount field with suffix action
+                        Forms\Components\TextInput::make('allocation_amount')
+                            ->label('Allocate Payment Amount')
+                            ->live()
+                            ->default(array_sum($this->paymentAmounts))
+                            ->money($this->getTableFilterState('currency_code')['value'])
+                            ->suffixAction(
+                                Forms\Components\Actions\Action::make('allocate')
+                                    ->icon('heroicon-m-calculator')
+                                    ->action(function ($state) {
+                                        $this->allocationAmount = CurrencyConverter::convertToCents($state, 'USD');
+                                        if ($this->allocationAmount && $this->hasSelectedClient()) {
+                                            $this->allocateOldestFirst($this->getTableRecords(), $this->allocationAmount);
+
+                                            $amountFormatted = CurrencyConverter::formatCentsToMoney($this->allocationAmount, 'USD', true);
+
+                                            Notification::make()
+                                                ->title('Payment allocated')
+                                                ->body("Allocated {$amountFormatted} across invoices")
+                                                ->success()
+                                                ->send();
+                                        }
+                                    })
+                            ),
                     ]),
             ])->statePath('data');
     }
                         Summarizer::make()
                             ->using(function () {
                                 $total = array_sum($this->paymentAmounts);
-                                $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
-                                $activeCurrency = $this->getTableFilterState('currency_code')['value'] ?? $defaultCurrency;
+                                $bankAccountCurrency = $this->getSelectedBankAccount()->account->currency_code;
+                                $activeCurrency = $this->getTableFilterState('currency_code')['value'] ?? $bankAccountCurrency;
 
-                                if ($activeCurrency !== $defaultCurrency) {
-                                    $total = CurrencyConverter::convertBalance($total, $activeCurrency, $defaultCurrency);
+                                if ($activeCurrency !== $bankAccountCurrency) {
+                                    $total = CurrencyConverter::convertBalance($total, $activeCurrency, $bankAccountCurrency);
                                 }
 
-                                return CurrencyConverter::formatCentsToMoney($total, $defaultCurrency, true);
+                                return CurrencyConverter::formatCentsToMoney($total, $bankAccountCurrency, true);
                             }),
                         Summarizer::make()
                             ->using(fn () => $this->totalPaymentAmount)
                             ->visible(function () {
                                 $activeCurrency = $this->getTableFilterState('currency_code')['value'] ?? null;
-                                $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+                                $bankAccountCurrency = $this->getSelectedBankAccount()->account->currency_code;
 
-                                return $activeCurrency && $activeCurrency !== $defaultCurrency;
+                                return $activeCurrency && $activeCurrency !== $bankAccountCurrency;
                             }),
                     ]),
+                // New allocation status column
+                TextColumn::make('allocation_status')
+                    ->label('Status')
+                    ->getStateUsing(function (Invoice $record) {
+                        $paymentAmount = $this->paymentAmounts[$record->id] ?? 0;
+
+                        if ($paymentAmount <= 0) {
+                            return 'No payment';
+                        }
+
+                        if ($paymentAmount >= $record->amount_due) {
+                            return 'Full payment';
+                        }
+
+                        return 'Partial payment';
+                    })
+                    ->badge()
+                    ->color(fn (string $state): string => match ($state) {
+                        'Full payment' => 'success',
+                        'Partial payment' => 'warning',
+                        default => 'gray',
+                    }),
             ])
             ->bulkActions([
                 Tables\Actions\BulkAction::make('setFullAmounts')
         return CurrencyConverter::formatCentsToMoney($total, $currencyCode, true);
     }
 
+    #[Computed]
+    public function allocationVariance(): string
+    {
+        if (! $this->allocationAmount) {
+            return '$0.00';
+        }
+
+        $totalAllocated = array_sum($this->paymentAmounts);
+        $variance = $this->allocationAmount - $totalAllocated;
+
+        $currencyCode = $this->getTableFilterState('currency_code')['value'];
+
+        return CurrencyConverter::formatCentsToMoney($variance, $currencyCode, true);
+    }
+
     public function getSelectedBankAccount(): BankAccount
     {
         $bankAccountId = $this->data['bank_account_id'];
         $visibleInvoiceKeys = array_flip($visibleInvoiceIds);
 
         $this->paymentAmounts = array_intersect_key($this->paymentAmounts, $visibleInvoiceKeys);
+
+        // Reset allocation when client changes
+        $this->allocationAmount = null;
     }
 }

resources/views/filament/company/resources/sales/invoice-resource/pages/record-payments.blade.php

 >
     <div class="flex flex-col gap-y-6">
         <x-filament::section>
-            <div class="flex items-center justify-between">
+            <div class="flex items-start justify-between">
                 <div>
                     {{ $this->form }}
                 </div>