wip multi-currency

app/Casts/RateCast.php

 
 namespace App\Casts;
 
-use App\Enums\Setting\NumberFormat;
-use App\Models\Setting\Localization;
+use App\Enums\Accounting\AdjustmentComputation;
 use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\RateCalculator;
 use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
 use Illuminate\Database\Eloquent\Model;
 
 class RateCast implements CastsAttributes
 {
-    private const PRECISION = 4;
-
     public function get($model, string $key, $value, array $attributes): string
     {
+        if (! $value) {
+            return '0';
+        }
+
         $currency_code = $this->getDefaultCurrencyCode();
-        $computation = $attributes['computation'] ?? null;
+        $computation = AdjustmentComputation::parse($attributes['computation'] ?? $attributes['discount_computation'] ?? null);
 
-        if ($computation === 'fixed') {
+        if ($computation?->isFixed()) {
             return money($value, $currency_code)->formatSimple();
         }
 
-        $floatValue = $value / (10 ** self::PRECISION);
-
-        $format = Localization::firstOrFail()->number_format->value;
-        [$decimal_mark, $thousands_separator] = NumberFormat::from($format)->getFormattingParameters();
-
-        return $this->formatWithoutTrailingZeros($floatValue, $decimal_mark, $thousands_separator);
+        return RateCalculator::formatScaledRate($value);
     }
 
     public function set(Model $model, string $key, mixed $value, array $attributes): int
     {
+        if (! $value) {
+            return 0;
+        }
+
         if (is_int($value)) {
             return $value;
         }
 
-        $computation = $attributes['computation'] ?? null;
+        $computation = AdjustmentComputation::parse($attributes['computation'] ?? $attributes['discount_computation'] ?? null);
 
         $currency_code = $this->getDefaultCurrencyCode();
 
-        if ($computation === 'fixed') {
+        if ($computation?->isFixed()) {
             return money($value, $currency_code, true)->getAmount();
         }
 
-        $format = Localization::firstOrFail()->number_format->value;
-        [$decimal_mark, $thousands_separator] = NumberFormat::from($format)->getFormattingParameters();
-
-        $intValue = str_replace([$thousands_separator, $decimal_mark], ['', '.'], $value);
-
-        return (int) round((float) $intValue * (10 ** self::PRECISION));
+        return RateCalculator::parseLocalizedRate($value);
     }
 
     private function getDefaultCurrencyCode(): string
     {
         return CurrencyAccessor::getDefaultCurrency();
     }
-
-    private function formatWithoutTrailingZeros($floatValue, $decimal_mark, $thousands_separator): string
-    {
-        $formatted = number_format($floatValue, self::PRECISION, $decimal_mark, $thousands_separator);
-        $formatted = rtrim($formatted, '0');
-
-        return rtrim($formatted, $decimal_mark);
-    }
 }

app/Concerns/ManagesLineItems.php

 use App\Enums\Accounting\DocumentDiscountMethod;
 use App\Models\Accounting\Bill;
 use App\Models\Accounting\DocumentLineItem;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
+use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Collection;
 
 
     protected function updateDocumentTotals(Model $record, array $data): array
     {
+        $currencyCode = $data['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
         $subtotalCents = $record->lineItems()->sum('subtotal');
         $taxTotalCents = $record->lineItems()->sum('tax_total');
         $discountTotalCents = $this->calculateDiscountTotal(
             AdjustmentComputation::parse($data['discount_computation']),
             $data['discount_rate'] ?? null,
             $subtotalCents,
-            $record
+            $record,
+            $currencyCode,
         );
 
         $grandTotalCents = $subtotalCents + $taxTotalCents - $discountTotalCents;
 
         return [
-            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents),
-            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents),
-            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents),
-            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents),
+            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents, $currencyCode),
+            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents, $currencyCode),
+            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents, $currencyCode),
+            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents, $currencyCode),
         ];
     }
 
         ?AdjustmentComputation $discountComputation,
         ?string $discountRate,
         int $subtotalCents,
-        Model $record
+        Model $record,
+        string $currencyCode
     ): int {
         if ($discountMethod->isPerLineItem()) {
             return $record->lineItems()->sum('discount_total');
         }
 
         if ($discountComputation?->isPercentage()) {
-            return (int) ($subtotalCents * ((float) $discountRate / 100));
+            $scaledRate = RateCalculator::parseLocalizedRate($discountRate);
+
+            return RateCalculator::calculatePercentage($subtotalCents, $scaledRate);
         }
 
-        return CurrencyConverter::convertToCents($discountRate);
+        return CurrencyConverter::convertToCents($discountRate, $currencyCode);
     }
 }

app/Filament/Company/Pages/Accounting/Transactions.php

                         }
                     )
                     ->sortable()
-                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount?->account->currency_code ?? CurrencyAccessor::getDefaultCurrency(), true),
+                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount?->account->currency_code),
             ])
             ->recordClasses(static fn (Transaction $transaction) => $transaction->reviewed ? 'bg-primary-300/10' : null)
             ->defaultSort('posted_at', 'desc')

app/Filament/Company/Resources/Banking/AccountResource.php

                                     ->localizeLabel()
                                     ->required(),
                                 CreateCurrencySelect::make('currency_code')
-                                    ->disabledOn('edit')
-                                    ->relationship('currency', 'name'),
+                                    ->disabledOn('edit'),
                             ]),
                         Forms\Components\Group::make()
                             ->columns()

app/Filament/Company/Resources/Purchases/VendorResource.php

                                     ->default(VendorType::Regular)
                                     ->columnSpanFull(),
                                 CreateCurrencySelect::make('currency_code')
-                                    ->relationship('currency', 'name')
                                     ->nullable()
                                     ->visible(fn (Forms\Get $get) => VendorType::parse($get('type')) === VendorType::Regular),
                                 Forms\Components\Select::make('contractor_type')

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

                     ])->columns(1),
                 Forms\Components\Section::make('Billing')
                     ->schema([
-                        CreateCurrencySelect::make('currency_code')
-                            ->relationship('currency', 'name'),
+                        CreateCurrencySelect::make('currency_code'),
                         CustomSection::make('Billing Address')
                             ->relationship('billingAddress')
                             ->contained(false)

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

 use App\Filament\Company\Resources\Sales\InvoiceResource\Pages;
 use App\Filament\Company\Resources\Sales\InvoiceResource\RelationManagers;
 use App\Filament\Company\Resources\Sales\InvoiceResource\Widgets;
+use App\Filament\Forms\Components\CreateCurrencySelect;
 use App\Filament\Forms\Components\InvoiceTotals;
 use App\Filament\Tables\Actions\ReplicateBulkAction;
 use App\Filament\Tables\Filters\DateRangeFilter;
 use App\Models\Accounting\Adjustment;
 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\Components\TableRepeater;
 use Awcodes\TableRepeater\Header;
 use Closure;
                                     ->relationship('client', 'name')
                                     ->preload()
                                     ->searchable()
-                                    ->required(),
+                                    ->required()
+                                    ->live()
+                                    ->afterStateUpdated(function (Forms\Set $set, Forms\Get $get, $state) {
+                                        if (! $state) {
+                                            return;
+                                        }
+
+                                        $currencyCode = Client::find($state)?->currency_code;
+
+                                        if ($currencyCode) {
+                                            $set('currency_code', $currencyCode);
+                                        }
+                                    }),
+                                CreateCurrencySelect::make('currency_code'),
                             ]),
                             Forms\Components\Group::make([
                                 Forms\Components\TextInput::make('invoice_number')
                                         $unitPrice = max((float) ($get('unit_price') ?? 0), 0);
                                         $salesTaxes = $get('salesTaxes') ?? [];
                                         $salesDiscounts = $get('salesDiscounts') ?? [];
+                                        $currencyCode = $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency();
 
                                         $subtotal = $quantity * $unitPrice;
 
-                                        // Calculate tax amount based on subtotal
-                                        $taxAmount = 0;
-                                        if (! empty($salesTaxes)) {
-                                            $taxRates = Adjustment::whereIn('id', $salesTaxes)->pluck('rate');
-                                            $taxAmount = collect($taxRates)->sum(fn ($rate) => $subtotal * ($rate / 100));
-                                        }
-
-                                        // Calculate discount amount based on subtotal
-                                        $discountAmount = 0;
-                                        if (! empty($salesDiscounts)) {
-                                            $discountRates = Adjustment::whereIn('id', $salesDiscounts)->pluck('rate');
-                                            $discountAmount = collect($discountRates)->sum(fn ($rate) => $subtotal * ($rate / 100));
-                                        }
+                                        $subtotalInCents = CurrencyConverter::convertToCents($subtotal, $currencyCode);
+
+                                        $taxAmountInCents = Adjustment::whereIn('id', $salesTaxes)
+                                            ->get()
+                                            ->sum(function (Adjustment $adjustment) use ($subtotalInCents) {
+                                                if ($adjustment->computation->isPercentage()) {
+                                                    return RateCalculator::calculatePercentage($subtotalInCents, $adjustment->getRawOriginal('rate'));
+                                                } else {
+                                                    return $adjustment->getRawOriginal('rate');
+                                                }
+                                            });
+
+                                        $discountAmountInCents = Adjustment::whereIn('id', $salesDiscounts)
+                                            ->get()
+                                            ->sum(function (Adjustment $adjustment) use ($subtotalInCents) {
+                                                if ($adjustment->computation->isPercentage()) {
+                                                    return RateCalculator::calculatePercentage($subtotalInCents, $adjustment->getRawOriginal('rate'));
+                                                } else {
+                                                    return $adjustment->getRawOriginal('rate');
+                                                }
+                                            });
 
                                         // Final total
-                                        $total = $subtotal + ($taxAmount - $discountAmount);
+                                        $totalInCents = $subtotalInCents + ($taxAmountInCents - $discountAmountInCents);
 
-                                        return CurrencyConverter::formatToMoney($total);
+                                        return CurrencyConverter::formatCentsToMoney($totalInCents, $currencyCode);
                                     }),
                             ]),
                         InvoiceTotals::make(),
                     ->sortable()
                     ->searchable(),
                 Tables\Columns\TextColumn::make('total')
-                    ->currency()
-                    ->sortable(),
+                    ->currencyWithConversion(static fn (Invoice $record) => $record->currency_code)
+                    ->sortable()
+                    ->toggleable(),
                 Tables\Columns\TextColumn::make('amount_paid')
                     ->label('Amount Paid')
-                    ->currency()
-                    ->sortable(),
+                    ->currencyWithConversion(static fn (Invoice $record) => $record->currency_code)
+                    ->sortable()
+                    ->toggleable(),
                 Tables\Columns\TextColumn::make('amount_due')
                     ->label('Amount Due')
-                    ->currency()
+                    ->currencyWithConversion(static fn (Invoice $record) => $record->currency_code)
                     ->sortable(),
             ])
             ->filters([

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

                                     ->url(static fn (Invoice $record) => ClientResource::getUrl('edit', ['record' => $record->client_id])),
                                 TextEntry::make('amount_due')
                                     ->label('Amount Due')
-                                    ->money(),
+                                    ->currency(static fn (Invoice $record) => $record->currency_code),
                                 TextEntry::make('due_date')
                                     ->label('Due')
                                     ->asRelativeDay(),

app/Filament/Forms/Components/CreateCurrencySelect.php

             ->required()
             ->createOptionForm($this->createCurrencyForm())
             ->createOptionAction(fn (Action $action) => $this->createCurrencyAction($action));
+
+        $this->relationship('currency', 'name');
+
+        $this->createOptionUsing(static function (array $data) {
+            return DB::transaction(static function () use ($data) {
+                $currency = CreateCurrency::create(
+                    $data['code'],
+                    $data['name'],
+                    $data['rate']
+                );
+
+                return $currency->code;
+            });
+        });
     }
 
     protected function createCurrencyForm(): array
         return $action
             ->label('Add Currency')
             ->slideOver()
-            ->modalWidth(MaxWidth::Medium)
-            ->action(static function (array $data) {
-                return DB::transaction(static function () use ($data) {
-                    $code = $data['code'];
-                    $name = $data['name'];
-                    $rate = $data['rate'];
-
-                    return CreateCurrency::create($code, $name, $rate);
-                });
-            });
+            ->modalWidth(MaxWidth::Medium);
     }
 }

app/Models/Accounting/Bill.php

 use App\Enums\Accounting\TransactionType;
 use App\Filament\Company\Resources\Purchases\BillResource;
 use App\Models\Common\Vendor;
+use App\Models\Setting\Currency;
 use App\Observers\BillObserver;
 use App\Utilities\Currency\CurrencyConverter;
 use Filament\Actions\MountableAction;
         'amount_due' => MoneyCast::class,
     ];
 
+    public function currency(): BelongsTo
+    {
+        return $this->belongsTo(Currency::class, 'currency_code', 'code');
+    }
+
     public function vendor(): BelongsTo
     {
         return $this->belongsTo(Vendor::class);

app/Models/Accounting/DocumentLineItem.php

 use App\Models\Common\Offering;
 use App\Observers\DocumentLineItemObserver;
 use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Attributes\ObservedBy;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
         );
     }
 
+    public function calculateTaxTotalAmount(): int
+    {
+        $subtotalInCents = $this->getRawOriginal('subtotal');
+
+        return $this->taxes->reduce(function (int $carry, Adjustment $tax) use ($subtotalInCents) {
+            if ($tax->computation->isPercentage()) {
+                $scaledRate = $tax->getRawOriginal('rate');
+
+                return $carry + RateCalculator::calculatePercentage($subtotalInCents, $scaledRate);
+            } else {
+                return $carry + $tax->getRawOriginal('rate');
+            }
+        }, 0);
+    }
+
     public function calculateDiscountTotal(): Money
     {
         $subtotal = money($this->subtotal, CurrencyAccessor::getDefaultCurrency());
         );
     }
 
+    public function calculateDiscountTotalAmount(): int
+    {
+        $subtotalInCents = $this->getRawOriginal('subtotal');
+
+        return $this->discounts->reduce(function (int $carry, Adjustment $discount) use ($subtotalInCents) {
+            if ($discount->computation->isPercentage()) {
+                $scaledRate = $discount->getRawOriginal('rate');
+
+                return $carry + RateCalculator::calculatePercentage($subtotalInCents, $scaledRate);
+            } else {
+                return $carry + $discount->getRawOriginal('rate');
+            }
+        }, 0);
+    }
+
     public function calculateAdjustmentTotal(Adjustment $adjustment): Money
     {
         $subtotal = money($this->subtotal, CurrencyAccessor::getDefaultCurrency());
 
         return $subtotal->multiply($adjustment->rate / 100);
     }
+
+    public function calculateAdjustmentTotalAmount(Adjustment $adjustment): int
+    {
+        $subtotalInCents = $this->getRawOriginal('subtotal');
+
+        if ($adjustment->computation->isPercentage()) {
+            $scaledRate = $adjustment->getRawOriginal('rate');
+
+            return RateCalculator::calculatePercentage($subtotalInCents, $scaledRate);
+        } else {
+            return $adjustment->getRawOriginal('rate');
+        }
+    }
 }

app/Models/Accounting/Invoice.php

 use App\Enums\Accounting\TransactionType;
 use App\Filament\Company\Resources\Sales\InvoiceResource;
 use App\Models\Common\Client;
+use App\Models\Setting\Currency;
 use App\Observers\InvoiceObserver;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
 use Filament\Actions\Action;
 use Filament\Actions\MountableAction;
         return $this->belongsTo(Client::class);
     }
 
+    public function currency(): BelongsTo
+    {
+        return $this->belongsTo(Currency::class, 'currency_code', 'code');
+    }
+
     public function lineItems(): MorphMany
     {
         return $this->morphMany(DocumentLineItem::class, 'documentable');
 
     public function createApprovalTransaction(): void
     {
+        $total = $this->formatAmountToDefaultCurrency($this->getRawOriginal('total'));
+
         $transaction = $this->transactions()->create([
             'company_id' => $this->company_id,
             'type' => TransactionType::Journal,
             'posted_at' => $this->date,
-            'amount' => $this->total,
+            'amount' => $total,
             'description' => 'Invoice Approval for Invoice #' . $this->invoice_number,
         ]);
 
             'company_id' => $this->company_id,
             'type' => JournalEntryType::Debit,
             'account_id' => Account::getAccountsReceivableAccount()->id,
-            'amount' => $this->total,
+            'amount' => $total,
             'description' => $baseDescription,
         ]);
 
-        $totalLineItemSubtotal = (int) $this->lineItems()->sum('subtotal');
-        $invoiceDiscountTotalCents = (int) $this->getRawOriginal('discount_total');
+        $totalLineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $this->lineItems()->sum('subtotal'));
+        $invoiceDiscountTotalCents = $this->convertAmountToDefaultCurrency((int) $this->getRawOriginal('discount_total'));
         $remainingDiscountCents = $invoiceDiscountTotalCents;
 
         foreach ($this->lineItems as $index => $lineItem) {
             $lineItemDescription = "{$baseDescription} › {$lineItem->offering->name}";
 
+            $lineItemSubtotal = $this->formatAmountToDefaultCurrency($lineItem->getRawOriginal('subtotal'));
+
             $transaction->journalEntries()->create([
                 'company_id' => $this->company_id,
                 'type' => JournalEntryType::Credit,
                 'account_id' => $lineItem->offering->income_account_id,
-                'amount' => $lineItem->subtotal,
+                'amount' => $lineItemSubtotal,
                 'description' => $lineItemDescription,
             ]);
 
             foreach ($lineItem->adjustments as $adjustment) {
+                $adjustmentAmount = $this->formatAmountToDefaultCurrency($lineItem->calculateAdjustmentTotalAmount($adjustment));
+
                 $transaction->journalEntries()->create([
                     'company_id' => $this->company_id,
                     'type' => $adjustment->category->isDiscount() ? JournalEntryType::Debit : JournalEntryType::Credit,
                     'account_id' => $adjustment->account_id,
-                    'amount' => $lineItem->calculateAdjustmentTotal($adjustment)->getAmount(),
+                    'amount' => $adjustmentAmount,
                     'description' => $lineItemDescription,
                 ]);
             }
 
-            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotal > 0) {
-                $lineItemSubtotalCents = (int) $lineItem->getRawOriginal('subtotal');
+            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotalCents > 0) {
+                $lineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $lineItem->getRawOriginal('subtotal'));
 
                 if ($index === $this->lineItems->count() - 1) {
                     $lineItemDiscount = $remainingDiscountCents;
                 } else {
                     $lineItemDiscount = (int) round(
-                        ($lineItemSubtotalCents / $totalLineItemSubtotal) * $invoiceDiscountTotalCents
+                        ($lineItemSubtotalCents / $totalLineItemSubtotalCents) * $invoiceDiscountTotalCents
                     );
                     $remainingDiscountCents -= $lineItemDiscount;
                 }
         $this->createApprovalTransaction();
     }
 
+    public function convertAmountToDefaultCurrency(int $amountCents): int
+    {
+        $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+        $needsConversion = $this->currency_code !== $defaultCurrency;
+
+        if ($needsConversion) {
+            return CurrencyConverter::convertBalance($amountCents, $this->currency_code, $defaultCurrency);
+        }
+
+        return $amountCents;
+    }
+
+    public function formatAmountToDefaultCurrency(int $amountCents): string
+    {
+        $convertedCents = $this->convertAmountToDefaultCurrency($amountCents);
+
+        return CurrencyConverter::convertCentsToFormatSimple($convertedCents);
+    }
+
     public static function getApproveDraftAction(string $action = Action::class): MountableAction
     {
         return $action::make('approveDraft')

app/Providers/MacroServiceProvider.php

 use App\Models\Setting\Localization;
 use App\Utilities\Accounting\AccountCode;
 use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
 use BackedEnum;
 use Carbon\CarbonInterface;
 use Closure;
             return $this;
         });
 
+        TextEntry::macro('currency', function (string | Closure | null $currency = null, ?bool $convert = null): static {
+            $currency ??= CurrencyAccessor::getDefaultCurrency();
+            $convert ??= true;
+
+            $this->formatStateUsing(static function (TextEntry $entry, $state) use ($currency, $convert): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $currency = $entry->evaluate($currency);
+                $convert = $entry->evaluate($convert);
+
+                return money($state, $currency, $convert)->format();
+            });
+
+            return $this;
+        });
+
+        TextColumn::macro('currencyWithConversion', function (string | Closure | null $currency = null): static {
+            $currency ??= CurrencyAccessor::getDefaultCurrency();
+
+            $this->formatStateUsing(static function (TextColumn $column, $state) use ($currency): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $currency = $column->evaluate($currency);
+
+                return CurrencyConverter::formatToMoney($state, $currency);
+            });
+
+            $this->description(static function (TextColumn $column, $state) use ($currency): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $oldCurrency = $column->evaluate($currency);
+                $newCurrency = CurrencyAccessor::getDefaultCurrency();
+
+                if ($oldCurrency === $newCurrency) {
+                    return null;
+                }
+
+                $balanceInCents = CurrencyConverter::convertToCents($state, $oldCurrency);
+
+                $convertedBalanceInCents = CurrencyConverter::convertBalance($balanceInCents, $oldCurrency, $newCurrency);
+
+                return CurrencyConverter::formatCentsToMoney($convertedBalanceInCents, $newCurrency, true);
+            });
+
+            return $this;
+        });
+
+        TextEntry::macro('currencyWithConversion', function (string | Closure | null $currency = null): static {
+            $currency ??= CurrencyAccessor::getDefaultCurrency();
+
+            $this->formatStateUsing(static function (TextEntry $entry, $state) use ($currency): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $currency = $entry->evaluate($currency);
+
+                return CurrencyConverter::formatToMoney($state, $currency);
+            });
+
+            $this->helperText(static function (TextEntry $entry, $state) use ($currency): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $oldCurrency = $entry->evaluate($currency);
+                $newCurrency = CurrencyAccessor::getDefaultCurrency();
+
+                if ($oldCurrency === $newCurrency) {
+                    return null;
+                }
+
+                $balanceInCents = CurrencyConverter::convertToCents($state, $oldCurrency);
+                $convertedBalanceInCents = CurrencyConverter::convertBalance($balanceInCents, $oldCurrency, $newCurrency);
+
+                return CurrencyConverter::formatCentsToMoney($convertedBalanceInCents, $newCurrency, true);
+            });
+
+            return $this;
+        });
+
         TextInput::macro('rate', function (string | Closure | null $computation = null, bool $showAffix = true): static {
             $this
                 ->when(

app/Utilities/RateCalculator.php

+<?php
+
+namespace App\Utilities;
+
+use App\Enums\Setting\NumberFormat;
+use App\Models\Setting\Localization;
+
+class RateCalculator
+{
+    public const PRECISION = 4;
+
+    public const SCALING_FACTOR = 10 ** self::PRECISION;
+
+    public const PERCENTAGE_SCALING_FACTOR = self::SCALING_FACTOR * 100;
+
+    public static function calculatePercentage(int $value, int $scaledRate): int
+    {
+        return (int) round(($value * $scaledRate) / self::PERCENTAGE_SCALING_FACTOR);
+    }
+
+    public static function scaledRateToDecimal(int $scaledRate): float
+    {
+        return $scaledRate / self::PERCENTAGE_SCALING_FACTOR;
+    }
+
+    public static function decimalToScaledRate(float $decimalRate): int
+    {
+        return (int) round($decimalRate * self::PERCENTAGE_SCALING_FACTOR);
+    }
+
+    public static function parseLocalizedRate(string $value): int
+    {
+        $format = Localization::firstOrFail()->number_format->value;
+        [$decimalMark, $thousandsSeparator] = NumberFormat::from($format)->getFormattingParameters();
+
+        $floatValue = (float) str_replace([$thousandsSeparator, $decimalMark], ['', '.'], $value);
+
+        return (int) round($floatValue * self::SCALING_FACTOR);
+    }
+
+    public static function formatScaledRate(int $scaledRate): string
+    {
+        $format = Localization::firstOrFail()->number_format->value;
+        [$decimalMark, $thousandsSeparator] = NumberFormat::from($format)->getFormattingParameters();
+
+        $percentageValue = $scaledRate / self::SCALING_FACTOR;
+
+        $formatted = number_format($percentageValue, self::PRECISION, $decimalMark, $thousandsSeparator);
+        $formatted = rtrim($formatted, '0');
+
+        return rtrim($formatted, $decimalMark);
+    }
+}

app/View/Models/InvoiceTotalViewModel.php

 use App\Enums\Accounting\DocumentDiscountMethod;
 use App\Models\Accounting\Adjustment;
 use App\Models\Accounting\Invoice;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
+use App\Utilities\RateCalculator;
 
 class InvoiceTotalViewModel
 {
 
     public function buildViewData(): array
     {
+        $currencyCode = $this->data['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
+        $defaultCurrencyCode = CurrencyAccessor::getDefaultCurrency();
+
         $lineItems = collect($this->data['lineItems'] ?? []);
 
-        $subtotal = $lineItems->sum(static function ($item) {
+        $subtotalInCents = $lineItems->sum(static function ($item) use ($currencyCode) {
             $quantity = max((float) ($item['quantity'] ?? 0), 0);
             $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
 
-            return $quantity * $unitPrice;
+            $subtotal = $quantity * $unitPrice;
+
+            return CurrencyConverter::convertToCents($subtotal, $currencyCode);
         });
 
-        $taxTotal = $lineItems->reduce(function ($carry, $item) {
+        $taxTotalInCents = $lineItems->reduce(function ($carry, $item) use ($currencyCode) {
             $quantity = max((float) ($item['quantity'] ?? 0), 0);
             $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
             $salesTaxes = $item['salesTaxes'] ?? [];
             $lineTotal = $quantity * $unitPrice;
 
-            $taxAmount = Adjustment::whereIn('id', $salesTaxes)
-                ->pluck('rate')
-                ->sum(fn ($rate) => $lineTotal * ($rate / 100));
+            $lineTotalInCents = CurrencyConverter::convertToCents($lineTotal, $currencyCode);
+
+            $taxAmountInCents = Adjustment::whereIn('id', $salesTaxes)
+                ->get()
+                ->sum(function (Adjustment $adjustment) use ($lineTotalInCents) {
+                    if ($adjustment->computation->isPercentage()) {
+                        return RateCalculator::calculatePercentage($lineTotalInCents, $adjustment->getRawOriginal('rate'));
+                    } else {
+                        return $adjustment->getRawOriginal('rate');
+                    }
+                });
 
-            return $carry + $taxAmount;
+            return $carry + $taxAmountInCents;
         }, 0);
 
         // Calculate discount based on method
         $discountMethod = DocumentDiscountMethod::parse($this->data['discount_method']) ?? DocumentDiscountMethod::PerLineItem;
 
         if ($discountMethod->isPerLineItem()) {
-            $discountTotal = $lineItems->reduce(function ($carry, $item) {
+            $discountTotalInCents = $lineItems->reduce(function ($carry, $item) use ($currencyCode) {
                 $quantity = max((float) ($item['quantity'] ?? 0), 0);
                 $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
                 $salesDiscounts = $item['salesDiscounts'] ?? [];
-                $lineTotal = $quantity * $unitPrice;
-
-                $discountAmount = Adjustment::whereIn('id', $salesDiscounts)
-                    ->pluck('rate')
-                    ->sum(fn ($rate) => $lineTotal * ($rate / 100));
-
-                return $carry + $discountAmount;
+                $lineTotalInCents = CurrencyConverter::convertToCents($quantity * $unitPrice, $currencyCode);
+
+                $discountAmountInCents = Adjustment::whereIn('id', $salesDiscounts)
+                    ->get()
+                    ->sum(function (Adjustment $adjustment) use ($lineTotalInCents) {
+                        if ($adjustment->computation->isPercentage()) {
+                            return RateCalculator::calculatePercentage($lineTotalInCents, $adjustment->getRawOriginal('rate'));
+                        } else {
+                            return $adjustment->getRawOriginal('rate');
+                        }
+                    });
+
+                return $carry + $discountAmountInCents;
             }, 0);
         } else {
             $discountComputation = AdjustmentComputation::parse($this->data['discount_computation']) ?? AdjustmentComputation::Percentage;
-            $discountRate = (float) ($this->data['discount_rate'] ?? 0);
+            $discountRate = $this->data['discount_rate'] ?? '0';
 
             if ($discountComputation->isPercentage()) {
-                $discountTotal = $subtotal * ($discountRate / 100);
+                $scaledDiscountRate = RateCalculator::parseLocalizedRate($discountRate);
+                $discountTotalInCents = RateCalculator::calculatePercentage($subtotalInCents, $scaledDiscountRate);
             } else {
-                $discountTotal = $discountRate;
+                $discountTotalInCents = CurrencyConverter::convertToCents($discountRate, $currencyCode);
             }
         }
 
-        $grandTotal = $subtotal + ($taxTotal - $discountTotal);
+        $grandTotalInCents = $subtotalInCents + ($taxTotalInCents - $discountTotalInCents);
+
+        $conversionMessage = null;
+
+        if ($currencyCode !== $defaultCurrencyCode) {
+            $rate = currency($currencyCode)->getRate();
+
+            $convertedTotalInCents = CurrencyConverter::convertBalance($grandTotalInCents, $currencyCode, $defaultCurrencyCode);
+
+            $conversionMessage = sprintf(
+                'Currency conversion: %s (%s) at an exchange rate of %s',
+                CurrencyConverter::formatCentsToMoney($convertedTotalInCents, $defaultCurrencyCode),
+                $defaultCurrencyCode,
+                $rate
+            );
+        }
 
         return [
-            'subtotal' => CurrencyConverter::formatToMoney($subtotal),
-            'taxTotal' => CurrencyConverter::formatToMoney($taxTotal),
-            'discountTotal' => CurrencyConverter::formatToMoney($discountTotal),
-            'grandTotal' => CurrencyConverter::formatToMoney($grandTotal),
+            'subtotal' => CurrencyConverter::formatCentsToMoney($subtotalInCents, $currencyCode),
+            'taxTotal' => CurrencyConverter::formatCentsToMoney($taxTotalInCents, $currencyCode),
+            'discountTotal' => CurrencyConverter::formatCentsToMoney($discountTotalInCents, $currencyCode),
+            'grandTotal' => CurrencyConverter::formatCentsToMoney($grandTotalInCents, $currencyCode),
+            'conversionMessage' => $conversionMessage,
         ];
     }
 }

config/money.php

             'symbol' => 'Fr.',
             'symbol_first' => true,
             'decimal_mark' => '.',
-            'thousands_separator' => ',',
+            'thousands_separator' => "'",
         ],
 
         'MOP' => [

resources/views/filament/company/resources/sales/invoices/components/invoice-view.blade.php

                         @endif
                     </td>
                     <td class="text-center py-3">{{ $item->quantity }}</td>
-                    <td class="text-right py-3">{{ CurrencyConverter::formatToMoney($item->unit_price) }}</td>
-                    <td class="text-right pr-6 py-3">{{ CurrencyConverter::formatToMoney($item->subtotal) }}</td>
+                    <td class="text-right py-3">{{ CurrencyConverter::formatToMoney($item->unit_price, $invoice->currency_code) }}</td>
+                    <td class="text-right pr-6 py-3">{{ CurrencyConverter::formatToMoney($item->subtotal, $invoice->currency_code) }}</td>
                 </tr>
             @endforeach
             </tbody>
             <tr>
                 <td class="pl-6 py-2" colspan="2"></td>
                 <td class="text-right font-semibold py-2">Subtotal:</td>
-                <td class="text-right pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->subtotal) }}</td>
+                <td class="text-right pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->subtotal, $invoice->currency_code) }}</td>
             </tr>
             @if($invoice->discount_total)
                 <tr class="text-success-800 dark:text-success-600">
                     <td class="pl-6 py-2" colspan="2"></td>
                     <td class="text-right py-2">Discount:</td>
                     <td class="text-right pr-6 py-2">
-                        ({{ CurrencyConverter::formatToMoney($invoice->discount_total) }})
+                        ({{ CurrencyConverter::formatToMoney($invoice->discount_total, $invoice->currency_code) }})
                     </td>
                 </tr>
             @endif
                 <tr>
                     <td class="pl-6 py-2" colspan="2"></td>
                     <td class="text-right py-2">Tax:</td>
-                    <td class="text-right pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->tax_total) }}</td>
+                    <td class="text-right pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->tax_total, $invoice->currency_code) }}</td>
                 </tr>
             @endif
             <tr>
                 <td class="pl-6 py-2" colspan="2"></td>
                 <td class="text-right font-semibold border-t py-2">Total:</td>
-                <td class="text-right border-t pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->total) }}</td>
+                <td class="text-right border-t pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->total, $invoice->currency_code) }}</td>
             </tr>
             <tr>
                 <td class="pl-6 py-2" colspan="2"></td>
                 <td class="text-right font-semibold border-t-4 border-double py-2">Amount Due
                     ({{ $invoice->currency_code }}):
                 </td>
-                <td class="text-right border-t-4 border-double pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->amount_due) }}</td>
+                <td class="text-right border-t-4 border-double pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->amount_due, $invoice->currency_code) }}</td>
             </tr>
             </tfoot>
         </table>

resources/views/filament/forms/components/invoice-totals.blade.php

                 <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Total:</td>
                 <td class="text-sm pl-4 py-2 leading-6">{{ $grandTotal }}</td>
             </tr>
+            @if($conversionMessage)
+                <tr>
+                    <td colspan="6" class="text-sm pl-4 py-2 leading-6 text-gray-600">
+                        {{ $conversionMessage }}
+                    </td>
+                </tr>
+            @endif
         </tbody>
     </table>
 </div>