# Sportwetten EV Calculator

Hallo und willkommen!
Dies ist ein kleines Projekt, das wir mit C# und WPF gemacht haben.
Die App hilft, potenziellen Gewinn und Erwartungswert (EV) für Sportwetten zu berechnen. Man gibt Quoten und eine geschätzte Gewinnwahrscheinlichkeit ein, und das Programm zeigt, ob eine Wette sich lohnt oder nicht.

Wir haben das Projekt gemacht, um WPF besser zu lernen und Mathe mit Programmierung zu verbinden. Es ist ein einfaches Übungsprojekt für Bildung.

## Wie benutzt man die App?
1. Starte das Programm.
2. Gib deinen Betrag ein.
3. Gib deine geschätzte Gewinnwahrscheinlichkeit ein (zwischen 0 und 1).
4. Wähle die Wettart: „Einzeln" oder „Kombi".
5. Gib die Quoten ein.
6. Klicke auf Berechnen.
7. Es wird angezeigt, Info über die Wett, wie viel Gewinn möglich ist und ob der Erwartungswert positiv oder negativ ist.

## Eingabetypen

Numerische Eingaben:

Betrag (decimal)
Gewinnwahrscheinlichkeiten (decimal zwischen 0 und 1)
Quoten (decimal)


Auswahleingaben:

Wettart (Einzeln/Kombi)

## Was ist drin?
- C# 
- WPF 
- Mathematische Logik für die EV-Berechnung

## Dateien
- MainWindow.xaml – Layout der App mit deklarativem UI-Aufbau
- MainWindow.xaml.cs – Logik, Events und Berechnungen
- README.md – Diese Datei hier

### XAML-Struktur (Auszug)
```xml
<Window x:Class="WpfApp2.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="EV Wetten Rechner" Height="557" Width="500">
    <Grid Margin="15">
        <!-- ... -->
        <StackPanel Grid.Row="4" Margin="0,0,0,15">
            <Label Content="Quoten:" FontWeight="SemiBold"/>
            <StackPanel x:Name="quottenPanel">
                <!-- Hier werden die Quoten-Elemente dynamisch eingefügt -->
            </StackPanel>
            <Button x:Name="kpfAddQuotten" Content="+ Weitere Quote hinzufügen" 
                    Click="kpfAddQuottenGedrückt"/>
        </StackPanel>
        <!-- ... -->
        <ScrollViewer Grid.Row="6" VerticalScrollBarVisibility="Auto">
            <StackPanel x:Name="ergebnisPanel">
                <!-- Hier werden die Ergebnisse dynamisch eingefügt -->
            </StackPanel>
        </ScrollViewer>
    </Grid>
</Window>
```

## Verwendete Formeln für Erwartungswert (EV)

### Für Einzelwetten und Kombiwetten:
```
EV = (Gewinnwahrscheinlichkeit × Potenzieller Gewinn) - (Verlustwahrscheinlichkeit × Einsatz)
```
Dabei ist:
- Gewinnwahrscheinlichkeit: Die geschätzte Chance auf Gewinn (zwischen 0 und 1)
- Verlustwahrscheinlichkeit: 1 - Gewinnwahrscheinlichkeit
- Potenzieller Gewinn: Einsatz × (Quote - 1)
- Einsatz: Der gesetzte Betrag

Aus unserem Code:
```csharp
decimal gewinnWahrscheinlichkeit = probability;
decimal verlustWahrscheinlichkeit = 1 - gewinnWahrscheinlichkeit;
decimal potenziellerGewinn = betrag * (summe - 1);
decimal ev = (potenziellerGewinn * gewinnWahrscheinlichkeit) - (betrag * verlustWahrscheinlichkeit);
```

### Für Kombiwetten zusätzlich:
```
Gesamtquote (summe) = Quote1 × Quote2 × ... × QuoteN
```

Im Code multiplizieren wir alle Quoten miteinander:
```csharp
decimal summe = 1.0m;
for (int i = 0; i < quoteTextBoxes.Count; i++)
{
    // Für jede eingegebene Quote
    if (!string.IsNullOrWhiteSpace(oddBox.Text))
    {
        decimal quote = Convert.ToDecimal(oddBox.Text);
        summe = summe * quote;
    }
}
```

## Technische Herausforderungen und Lösungen

Während der Entwicklung dieses Projekts stießen wir auf mehrere technische Herausforderungen, die wir durch passende Lösungsansätze überwinden konnten:

### 1. Dynamische UI-Elemente generieren
Ein Hauptproblem war das dynamische Erstellen von StackPanels für die Eingabe mehrerer Quoten bei Kombiwetten. Anstatt diese fest im XAML zu definieren, mussten wir sie zur Laufzeit generieren.

**Lösung**: Wir haben die Methode `QuotenInputErzeuger` entwickelt, die UI-Elemente programmatisch erstellt:

```csharp
private void QuotenInputErzeuger(int index)
{
    //ein Stackpanel zu herstellen
    StackPanel rowPanel = new StackPanel();
    rowPanel.Orientation = Orientation.Horizontal;

    //ein Label zu herstellen
    Label label = new Label();
    label.Content = "Quoten der " + index + "-x Wette:";
    label.Width = 150;

    //ein neu TextBox zu erzeugen, um quote zu geben
    TextBox textBox = new TextBox();
    textBox.Width = 100;
    textBox.Height = 25;

    //Label und textbox zu Stackpanel zu addieren
    rowPanel.Children.Add(label);
    rowPanel.Children.Add(textBox);

    //die neu Stackpanel zu der MainWindow.xaml Stackpanel zu addieren
    quottenPanel.Children.Add(rowPanel);
    quoteTextBoxes.Add(textBox);
}
```

Wir verwenden den `System.Windows.Controls`-Namespace, um UI-Elemente wie StackPanel, Label und TextBox programmatisch zu erzeugen und zu manipulieren. Diese Lösung ermöglicht es uns, die Anzahl der Quoten-Eingabefelder dynamisch an die Wettart (Einzeln oder Kombi) anzupassen.

Für die Verwaltung dieser dynamisch erzeugten Elemente haben wir eine Liste implementiert:
```csharp
private List<TextBox> quoteTextBoxes;
```

Diese Liste speichert alle erzeugten TextBox-Objekte, sodass wir später auf ihre Werte zugreifen können:
```csharp
for (int i = 0; i < quoteTextBoxes.Count; i++)
{
    TextBox oddBox = quoteTextBoxes[i];
    if (!string.IsNullOrWhiteSpace(oddBox.Text))
    {
        decimal quote = Convert.ToDecimal(oddBox.Text);
        // Weiterer Code...
    }
}
```

### 2. Präzise Berechnungen mit geeignetem Datentyp
Anfangs hatten wir Probleme mit der Genauigkeit bei Berechnungen, als wir `double` und `float` verwendeten. Wir erhielten oft ungenaue Ergebnisse oder sogar 0 als Output.

**Lösung**: Wir haben uns für den `decimal`-Datentyp entschieden, der besonders für Finanzberechnungen geeignet ist:

```csharp
// Aus unserem Code:
decimal probability = Convert.ToDecimal(txtGewinnWahrscheinlichkeit.Text);
decimal betrag = Convert.ToDecimal(txtBetrag.Text);
decimal summe = 1.0m; // Gesamtquote, "m" kennzeichnet decimal-Literal

// Berechnung des Erwartungswerts
decimal gewinnWahrscheinlichkeit = probability;
decimal verlustWahrscheinlichkeit = 1 - gewinnWahrscheinlichkeit;
decimal potenziellerGewinn = betrag * (summe - 1);
decimal ev = (potenziellerGewinn * gewinnWahrscheinlichkeit) - (betrag * verlustWahrscheinlichkeit);
```

Der `decimal`-Datentyp bietet 28-29 signifikante Stellen und ist damit deutlich präziser als `double` (15-16 Stellen) oder `float` (7 Stellen) für unsere finanzmathematischen Berechnungen. Besonders bei der Berechnung von Prozenten und Quoten hat sich dieser Datentyp als viel genauer erwiesen.

### 3. Dynamische Ergebnisanzeige
Eine weitere Herausforderung war die dynamische Darstellung der Ergebnisse. Wir haben die Methode `ZeigeErgebnis` implementiert, die anhand der Berechnungen passende UI-Elemente erzeugt:

```csharp
private void ZeigeErgebnis(decimal ev, decimal betrag, decimal summe, int anzahlWetten, decimal probability)
{
    ergebnisPanel.Children.Clear(); // Bestehende Ergebnisse löschen
    
    // Stackpanel für info erzeugen
    StackPanel infoPanel = new StackPanel();
    
    // Wettart bestimmen (Einzeln oder Kombi)
    string wettart;
    if (rkEinzeln.IsChecked == true)
    {
        wettart = "Einzeln";
    }
    else
    {
        wettart = anzahlWetten + "x Kombi";
    }
    
    // Informationen und Bewertung dynamisch anzeigen
    // ...
}
```

## Warum haben wir das gemacht?
- Wir wollten lernen, wie man GUI-Anwendungen mit C# und WPF entwickelt.
- Das Thema Wetten ist gut zum Üben, weil man mit Quoten, Wahrscheinlichkeiten und einfachem Rechnen arbeiten kann.
- Die App ist nicht für echtes Wetten gedacht, sondern als Lernhilfe.

## Nächste Schritte und geplante Verbesserungen
Für zukünftige Versionen der Anwendung planen wir folgende Verbesserungen:
1. Zurück-Button implementieren
Ein Button zum Zurücksetzen der Eingaben oder zum Zurückkehren zu einem vorherigen Zustand soll hinzugefügt werden:
2. Fehlerbehandlung mit Try-Catch verbessern
Aktuell verwenden wir einfache Validierungen. Für eine robustere Anwendung sollen Try-Catch-Blöcke implementiert werden:

## Etwas zum Schluss
- Das Projekt ist nicht perfekt, aber es war gut zum Lernen.

## Arbeitsverteilung:
+Iyad Sassoui:Hat leider nichts gemacht
+Ismail Amara:Hat die Nachirchten für Exceptions (NullorWhite space/ein Zahl größe als 1 und kleine als 0 ) gemacht ,auch er hat mit Abdelaziz Elouazzani Event Handler Methode gemacht und er hat Ideen und Verbesserungsvorschlag geggeben.
+Abdelaziz Elouazzani:Er war verantwortlich für die Rest der Code für MainWindow.xaml.cs und MainWindow.xaml (Layout) und README Datei

## die Quelle ,die wir genutzt haben,um probleme zu löschen sind:
-https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls?view=windowsdesktop-9.0&viewFallbackFrom=net-5.0
-https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.stackpanel?view=windowsdesktop-9.0
-https://www.youtube.com/watch?v=WYBoTT2ce8c&list=PLKShHgmYjjFwmuUZ46GxeSTA2zKZF-8nv&index=1
-https://winnerodds.com/what-is-expected-value-with-calculator/