wip multi-currency

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

                             Forms\Components\TextInput::make('amount')
                                 ->label('Amount')
                                 ->required()
-                                ->money()
+                                ->money(fn (Invoice $record) => $record->currency_code)
                                 ->live(onBlur: true)
                                 ->helperText(function (Invoice $record, $state) {
-                                    if (! CurrencyConverter::isValidAmount($state)) {
+                                    $invoiceCurrency = $record->currency_code;
+                                    if (! CurrencyConverter::isValidAmount($state, $invoiceCurrency)) {
                                         return null;
                                     }
 
                                     $amountDue = $record->getRawOriginal('amount_due');
 
-                                    $amount = CurrencyConverter::convertToCents($state);
+                                    $amount = CurrencyConverter::convertToCents($state, $invoiceCurrency);
 
                                     if ($amount <= 0) {
                                         return 'Please enter a valid positive amount';
                                     }
 
                                     return match (true) {
-                                        $newAmountDue > 0 => 'Amount due after payment will be ' . CurrencyConverter::formatCentsToMoney($newAmountDue),
+                                        $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)),
+                                        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)) {
+                                    static fn (Invoice $record): Closure => static function (string $attribute, $value, Closure $fail) use ($record) {
+                                        if (! CurrencyConverter::isValidAmount($value, $record->currency_code)) {
                                             $fail('Please enter a valid amount');
                                         }
                                     },

app/Models/Accounting/Invoice.php

 use App\Enums\Accounting\JournalEntryType;
 use App\Enums\Accounting\TransactionType;
 use App\Filament\Company\Resources\Sales\InvoiceResource;
+use App\Models\Banking\BankAccount;
 use App\Models\Common\Client;
 use App\Models\Setting\Currency;
 use App\Observers\InvoiceObserver;
             $transactionDescription = "Invoice #{$this->invoice_number}: Payment from {$this->client->name}";
         }
 
+        $bankAccount = BankAccount::findOrFail($data['bank_account_id']);
+        $bankAccountCurrency = $bankAccount->account->currency_code ?? CurrencyAccessor::getDefaultCurrency();
+
+        $invoiceCurrency = $this->currency_code;
+        $requiresConversion = $invoiceCurrency !== $bankAccountCurrency;
+
+        if ($requiresConversion) {
+            $amountInInvoiceCurrencyCents = CurrencyConverter::convertToCents($data['amount'], $invoiceCurrency);
+            $amountInBankCurrencyCents = CurrencyConverter::convertBalance(
+                $amountInInvoiceCurrencyCents,
+                $invoiceCurrency,
+                $bankAccountCurrency
+            );
+            $formattedAmountForBankCurrency = CurrencyConverter::convertCentsToFormatSimple(
+                $amountInBankCurrencyCents,
+                $bankAccountCurrency
+            );
+        } else {
+            $formattedAmountForBankCurrency = $data['amount']; // Already in simple format
+        }
+
         // Create transaction
         $this->transactions()->create([
             'company_id' => $this->company_id,
             'type' => $transactionType,
             'is_payment' => true,
             'posted_at' => $data['posted_at'],
-            'amount' => $data['amount'],
+            'amount' => $formattedAmountForBankCurrency,
             'payment_method' => $data['payment_method'],
             'bank_account_id' => $data['bank_account_id'],
             'account_id' => Account::getAccountsReceivableAccount()->id,

app/Observers/TransactionObserver.php

             return;
         }
 
-        $depositTotal = (int) $invoice->deposits()
+        $invoiceCurrency = $invoice->currency_code;
+
+        $depositTotalInInvoiceCurrencyCents = (int) $invoice->deposits()
             ->when($excludedTransaction, fn (Builder $query) => $query->whereKeyNot($excludedTransaction->getKey()))
-            ->sum('amount');
+            ->get()
+            ->sum(function (Transaction $transaction) use ($invoiceCurrency) {
+                $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
+                $amountCents = (int) $transaction->getRawOriginal('amount');
+
+                return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $invoiceCurrency);
+            });
 
-        $withdrawalTotal = (int) $invoice->withdrawals()
+        $withdrawalTotalInInvoiceCurrencyCents = (int) $invoice->withdrawals()
             ->when($excludedTransaction, fn (Builder $query) => $query->whereKeyNot($excludedTransaction->getKey()))
-            ->sum('amount');
+            ->get()
+            ->sum(function (Transaction $transaction) use ($invoiceCurrency) {
+                $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
+                $amountCents = (int) $transaction->getRawOriginal('amount');
+
+                return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $invoiceCurrency);
+            });
 
-        $totalPaid = $depositTotal - $withdrawalTotal;
+        $totalPaidInInvoiceCurrencyCents = $depositTotalInInvoiceCurrencyCents - $withdrawalTotalInInvoiceCurrencyCents;
 
-        $invoiceTotal = (int) $invoice->getRawOriginal('total');
+        $invoiceTotalInInvoiceCurrencyCents = (int) $invoice->getRawOriginal('total');
 
         $newStatus = match (true) {
-            $totalPaid > $invoiceTotal => InvoiceStatus::Overpaid,
-            $totalPaid === $invoiceTotal => InvoiceStatus::Paid,
+            $totalPaidInInvoiceCurrencyCents > $invoiceTotalInInvoiceCurrencyCents => InvoiceStatus::Overpaid,
+            $totalPaidInInvoiceCurrencyCents === $invoiceTotalInInvoiceCurrencyCents => InvoiceStatus::Paid,
             default => InvoiceStatus::Partial,
         };
 
         }
 
         $invoice->update([
-            'amount_paid' => CurrencyConverter::convertCentsToFloat($totalPaid),
+            'amount_paid' => CurrencyConverter::convertCentsToFormatSimple($totalPaidInInvoiceCurrencyCents, $invoiceCurrency),
             'status' => $newStatus,
             'paid_at' => $paidAt,
         ]);
             return;
         }
 
-        $withdrawalTotal = (int) $bill->withdrawals()
+        $billCurrency = $bill->currency_code;
+
+        $withdrawalTotalInBillCurrencyCents = (int) $bill->withdrawals()
             ->when($excludedTransaction, fn (Builder $query) => $query->whereKeyNot($excludedTransaction->getKey()))
-            ->sum('amount');
+            ->get()
+            ->sum(function (Transaction $transaction) use ($billCurrency) {
+                $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
+                $amountCents = (int) $transaction->getRawOriginal('amount');
+
+                return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $billCurrency);
+            });
+
+        $totalPaidInBillCurrencyCents = $withdrawalTotalInBillCurrencyCents;
 
-        $totalPaid = $withdrawalTotal;
-        $billTotal = (int) $bill->getRawOriginal('total');
+        $billTotalInBillCurrencyCents = (int) $bill->getRawOriginal('total');
 
         $newStatus = match (true) {
-            $totalPaid >= $billTotal => BillStatus::Paid,
+            $totalPaidInBillCurrencyCents >= $billTotalInBillCurrencyCents => BillStatus::Paid,
             default => BillStatus::Partial,
         };
 
         }
 
         $bill->update([
-            'amount_paid' => CurrencyConverter::convertCentsToFloat($totalPaid),
+            'amount_paid' => CurrencyConverter::convertCentsToFormatSimple($totalPaidInBillCurrencyCents, $billCurrency),
             'status' => $newStatus,
             'paid_at' => $paidAt,
         ]);