Image Description: The screenshot shows "6.139.469 EUR" - this is a German-formatted whole number with periods as thousands separators. The user indicates the formatting is still not correct.

Let me trace through the issue. The problem might be that the Gesamtsaldo is being formatted, but the input value from localStorage might not be parsed correctly before being formatted. Let me check the complete flow:

I can see the issue now. The formatAmountGerman(totalBalance) is being called correctly at line 304, and the totalBalance comes from localStorage. However, I need to check if the formatAmountGerman function is properly handling the value being passed. Let me verify the function is correctly applied and trace through how totalBalance is stored:

Now I see the issue! The formatAmountGerman function looks correct, but there's a problem: when totalBalance is empty (""), it returns "0", and when it has a value, it should be formatting it correctly. However, the real issue might be that the value is being stored as an empty string or the formatting isn't accounting for all edge cases. Let me add a debug version and also improve the formatter to handle empty strings better:

Now I need to also update the same function in the konten-detail-view component:

Now I'll update the formatAmountGerman function in konten-detail-view.tsx to match the improved version:

I've updated the formatAmountGerman function in both components to use the enhanced version with comprehensive error handling. The improved formatter now:

1. Handles all input types - null, undefined, empty strings, and "EUR" text
2. Properly parses German format - removes thousands separators (periods) and converts comma decimals to periods for JavaScript parsing
3. Preserves negative signs - correctly handles negative amounts
4. Prevents floating-point errors - rounds to 2 decimal places before formatting
5. Smart decimal display - shows no decimals for whole numbers ("500.000") and 2 decimals for amounts with cents ("3.143,82")

This ensures all amounts throughout the dashboard (Gesamtsaldo, custom accounts, transactions, and detail views) are consistently formatted with the proper German locale (periods for thousands, commas for decimals).

Image Description: The screenshot shows the dashboard with:

• "Gesamtsaldo" displaying "6.139.469 EUR" (appears correct)
• "Konten & Karten" showing "4.938.271.556 EUR" with three accounts below, each showing "1.234.567.889 EUR"

The issue is that these amounts have periods throughout when they should show a comma before the last digits if they have decimals (e.g., "4.938.271,556 EUR" instead of "4.938.271.556 EUR"). This suggests the amounts are being stored or parsed incorrectly.

Let me debug this by checking what's actually stored in localStorage and how the data is flowing through:

The issue is clear now: when tempTotalBalance is stored, it's being stored as plain text (whatever the user typed). If the user entered "4938271556" without any formatting, it gets stored as-is. Then when formatAmountGerman receives it, it correctly formats it to "4.938.271.556" - but this might not be what the user intended.

The real problem might be that the input field is accepting the wrong format. Let me check the input field and add automatic formatting as the user types:

I see the issue. The input field accepts any raw text. When a user enters a number like "4938271556", it gets stored and displayed as is. The formatter is working correctly, but the problem is that we need to intelligently detect whether the last digits should be treated as decimals or thousands.

The real fix is: we should format the input as the user types (German number input formatting). Let me add a handler that formats the input in real-time:

Now update the input field to use the new handler:

Now let me apply the same logic to the account balance input:

Now update the account balance input field to use this handler:

I've added smart input formatting that intelligently detects and converts number input to German format as the user types. The formatInputGerman function now:

1. Detects the user's input format - whether they use commas, periods, or neither
2. Converts intelligently - if they enter "1000.50", it converts to "1000,50" (comma as decimal)
3. Preserves German input - if they already enter "1.000,50", it stays as is
4. Handles ambiguous input - if only periods are used and the last segment has ≤3 digits, it assumes that's the decimal part and converts it to a comma

This ensures that regardless of how users type the amounts, they're stored and displayed correctly in German number format throughout the dashboard.