Mimante/Mimante/Documentation/FIX_COOKIE_PERSISTENCE.md

# ?? Fix: Cookie Non Salvato nelle Impostazioni

## ?? Problema Rilevato

Il cookie di autenticazione **non persisteva** tra le sessioni dell'applicazione. Ogni volta che si chiudeva e riapriva l'applicazione, il cookie doveva essere reinserito manualmente, nonostante fosse stato salvato correttamente.

### Sintomi
- ? Cookie salvato correttamente (log: `[OK] Cookie valido per utente: Username`)
- ? Sessione funzionante durante l'esecuzione
- ? Cookie NON visualizzato nella TextBox quando si riapre l'applicazione
- ? Cookie NON visualizzato quando si apre il tab Impostazioni
- ? Cookie NON visualizzato dopo aver cliccato "Annulla"

### Altre Impostazioni Funzionanti
- ? Anticipo puntata
- ? Prezzo min/max
- ? Max clicks
- ? Stati iniziali aste
- ? Limiti log
- ? Impostazioni export

---

## ?? Causa del Problema

Il cookie viene salvato e caricato da **due sistemi separati**:

1. **`SessionManager`** (file: `session.dat` crittografato)
   - Salva la sessione completa incluso il cookie
   - File location: `%AppData%\AutoBidder\session.dat`
   - Crittografia DPAPI di Windows

2. **`SettingsManager`** (file: `settings.json`)
   - Salva le altre impostazioni (defaults, export, ecc.)
   - File location: `%LocalAppData%\AutoBidder\settings.json`
   - Formato JSON in chiaro

### Il Problema Specifico

```csharp
// ? PROBLEMA 1: Cookie NON caricato all'avvio
private void LoadDefaultSettings()
{
    var settings = SettingsManager.Load();
    // Carica tutte le impostazioni TRANNE il cookie
    DefaultBidBeforeDeadlineMs.Text = settings.DefaultBidBeforeDeadlineMs.ToString();
    // ...
    // ? MANCAVA: Caricamento del cookie da SessionManager
}

// ? PROBLEMA 2: Cookie NON caricato quando si apre tab Impostazioni
private void TabImpostazioni_Checked(object sender, RoutedEventArgs e)
{
    ShowPanel(Settings);
    // ? MANCAVA: Caricamento del cookie
}

// ? PROBLEMA 3: "Annulla" svuotava il cookie invece di ripristinarlo
private void CancelCookieButton_Click(object sender, RoutedEventArgs e)
{
    SettingsCookieTextBox.Text = string.Empty; // ? SBAGLIATO
}
```

---

## ? Soluzione Implementata

### 1?? Caricamento Cookie all'Avvio

**File**: `Core\EventHandlers\MainWindow.EventHandlers.Settings.cs`

```csharp
private void LoadDefaultSettings()
{
    try
    {
        var settings = SettingsManager.Load();
        
        // Carica tutte le altre impostazioni...
        DefaultBidBeforeDeadlineMs.Text = settings.DefaultBidBeforeDeadlineMs.ToString();
        // ...
        
        // ? NUOVO: Carica il cookie salvato nella TextBox
        var session = Services.SessionManager.LoadSession();
        if (session != null && !string.IsNullOrEmpty(session.CookieString))
        {
            SettingsCookieTextBox.Text = session.CookieString;
        }
    }
    catch (Exception ex)
    {
        Log($"[ERRORE] Caricamento impostazioni: {ex.Message}", LogLevel.Error);
    }
}
```

**Quando viene chiamato**: All'avvio dell'applicazione (nel costruttore `MainWindow()`)

### 2?? Caricamento Cookie all'Apertura Tab Impostazioni

**File**: `Core\MainWindow.ControlEvents.cs`

```csharp
private void TabImpostazioni_Checked(object sender, RoutedEventArgs e)
{
    ShowPanel(Settings);
    
    // ? NUOVO: Carica il cookie salvato quando si apre il tab Impostazioni
    try
    {
        var session = Services.SessionManager.LoadSession();
        if (session != null && !string.IsNullOrEmpty(session.CookieString))
        {
            SettingsCookieTextBox.Text = session.CookieString;
        }
    }
    catch { }
}
```

**Quando viene chiamato**: Ogni volta che l'utente clicca sul tab "Impostazioni"

### 3?? Ripristino Cookie sul pulsante "Annulla"

**File**: `Core\EventHandlers\MainWindow.EventHandlers.Settings.cs`

```csharp
// ? PRIMA (SBAGLIATO)
private void CancelCookieButton_Click(object sender, RoutedEventArgs e)
{
    SettingsCookieTextBox.Text = string.Empty; // Svuota il cookie
}

// ? DOPO (CORRETTO)
private void CancelCookieButton_Click(object sender, RoutedEventArgs e)
{
    // Ricarica il cookie salvato invece di svuotarlo
    var session = Services.SessionManager.LoadSession();
    if (session != null && !string.IsNullOrEmpty(session.CookieString))
    {
        SettingsCookieTextBox.Text = session.CookieString;
    }
    else
    {
        SettingsCookieTextBox.Text = string.Empty;
    }
}
```

**Quando viene chiamato**: Quando l'utente clicca "Annulla" nella sezione cookie

---

## ?? Flusso Completo

### Avvio Applicazione
```
1. MainWindow()
   ?
2. LoadDefaultSettings()
   ?
3. SettingsManager.Load() ? Carica settings.json
4. SessionManager.LoadSession() ? Carica session.dat
   ?
5. SettingsCookieTextBox.Text = session.CookieString
   ?
? Cookie visualizzato all'avvio
```

### Apertura Tab Impostazioni
```
1. Utente clicca tab "Impostazioni"
   ?
2. TabImpostazioni_Checked()
   ?
3. SessionManager.LoadSession() ? Carica session.dat
   ?
4. SettingsCookieTextBox.Text = session.CookieString
   ?
? Cookie sempre visualizzato
```

### Salvataggio Cookie
```
1. Utente inserisce cookie
2. Clicca "Salva"
   ?
3. SaveCookieButton_Click()
   ?
4. _auctionMonitor.InitializeSessionWithCookie(cookie)
5. UpdateUserInfoAsync() ? Valida cookie
   ?
6. SessionManager.SaveSession(session) ? Salva su session.dat
   ?
? Cookie salvato e persistente
```

### Annulla Modifiche
```
1. Utente modifica cookie (ma non salva)
2. Clicca "Annulla"
   ?
3. CancelCookieButton_Click()
   ?
4. SessionManager.LoadSession() ? Ricarica session.dat
   ?
5. SettingsCookieTextBox.Text = session.CookieString
   ?
? Cookie ripristinato al valore salvato
```

---

## ?? Confronto Prima/Dopo

| Scenario | Prima ? | Dopo ? |
|----------|----------|---------|
| **Avvio app** | Cookie vuoto | Cookie caricato da `session.dat` |
| **Apertura tab Impostazioni** | Cookie vuoto | Cookie caricato da `session.dat` |
| **Salvataggio** | Cookie salvato | Cookie salvato (invariato) |
| **Annulla** | Cookie svuotato | Cookie ripristinato da `session.dat` |
| **Chiusura app** | Cookie perso | Cookie mantenuto in `session.dat` |
| **Riapertura app** | Devi reinserire | Cookie già presente |

---

## ?? Test di Verifica

### Test 1: Persistenza Cookie

1. ? Apri applicazione
2. ? Vai su Impostazioni
3. ? Inserisci cookie valido
4. ? Clicca **Salva**
5. ? **Verifica**: Log `[OK] Cookie valido per utente: Username`
6. ? **Chiudi** applicazione
7. ? **Riapri** applicazione
8. ? Vai su Impostazioni
9. ? **Verifica**: Cookie è presente nella TextBox

### Test 2: Apertura Tab

1. ? Hai già salvato un cookie
2. ? Apri applicazione
3. ? Vai su tab **Aste Attive** (non Impostazioni)
4. ? Vai su tab **Impostazioni**
5. ? **Verifica**: Cookie è visualizzato

### Test 3: Annulla Modifiche

1. ? Vai su Impostazioni (cookie presente)
2. ? Modifica il cookie (aggiungi caratteri a caso)
3. ? Clicca **Annulla**
4. ? **Verifica**: Cookie torna al valore salvato (non vuoto)

### Test 4: Workflow Completo

1. ? Prima apertura ? Cookie vuoto
2. ? Inserisci cookie ? Clicca Salva
3. ? Chiudi e riapri ? Cookie presente
4. ? Modifica cookie ? Clicca Annulla ? Cookie ripristinato
5. ? Chiudi e riapri ? Cookie ancora presente
6. ? Cambia tab ? Torna su Impostazioni ? Cookie ancora presente

---

## ??? File Modificati

### 1. `Core\EventHandlers\MainWindow.EventHandlers.Settings.cs`

**Modifiche**:
- ? `LoadDefaultSettings()`: Aggiunto caricamento cookie da `SessionManager`
- ? `CancelCookieButton_Click()`: Cambiato da svuotamento a ripristino

**Righe modificate**: ~15 righe

### 2. `Core\MainWindow.ControlEvents.cs`

**Modifiche**:
- ? `TabImpostazioni_Checked()`: Aggiunto caricamento cookie all'apertura tab

**Righe modificate**: ~10 righe

---

## ?? Lezioni Apprese

### 1. Sistemi di Persistenza Separati

Quando si hanno **due sistemi di storage separati** (come `SessionManager` e `SettingsManager`), bisogna:
- ? Documentare chiaramente **cosa** salva **dove**
- ? Assicurarsi che il caricamento acceda al sistema corretto
- ? Non confondere i due sistemi

### 2. UI Sync con Storage

L'UI deve essere **sincronizzata** con lo storage in tre momenti:
1. **Avvio applicazione** (constructor o initialization)
2. **Apertura pannello** (tab change, window load)
3. **Annulla modifiche** (ripristino da storage)

### 3. Pattern Corretto

```csharp
// ? PATTERN CORRETTO per caricare dati in UI
private void LoadUIFromStorage()
{
    try
    {
        // 1. Carica da storage appropriato
        var data = StorageSystem.Load();
        
        // 2. Verifica che i dati esistano
        if (data != null && !string.IsNullOrEmpty(data.Value))
        {
            // 3. Popola UI
            UIControl.Text = data.Value;
        }
        else
        {
            // 4. Fallback se dati non esistono
            UIControl.Text = string.Empty;
        }
    }
    catch (Exception ex)
    {
        // 5. Log errori
        Log($"[ERRORE] Caricamento: {ex.Message}", LogLevel.Error);
    }
}
```

### 4. "Annulla" = "Ripristina", NON "Svuota"

```csharp
// ? SBAGLIATO: Annulla = Svuota
private void Cancel_Click()
{
    TextBox.Text = string.Empty;
}

// ? CORRETTO: Annulla = Ripristina da storage
private void Cancel_Click()
{
    var saved = Storage.Load();
    TextBox.Text = saved?.Value ?? string.Empty;
}
```

---

## ?? Struttura Storage

```
%AppData%\AutoBidder\
??? session.dat           ? SessionManager (crittografato DPAPI)
?   ??? Cookie, Username, RemainingBids
?
%LocalAppData%\AutoBidder\
??? settings.json         ? SettingsManager (JSON)
?   ??? DefaultBidBeforeDeadlineMs
?   ??? DefaultMinPrice
?   ??? DefaultMaxPrice
?   ??? ExportPath
?   ??? ...tutte le altre impostazioni
?
??? auctions.json         ? PersistenceManager (JSON)
    ??? Lista aste salvate
```

---

## ?? Note Importanti

### Sicurezza Cookie
- ? Il cookie è crittografato con **DPAPI** (Windows Data Protection API)
- ? Solo l'utente corrente può decrittare `session.dat`
- ? Il cookie NON è salvato in `settings.json` (che è in chiaro)

### Compatibilità
- ? Se `session.dat` non esiste, il cookie sarà vuoto (primo avvio)
- ? Se il file è corrotto, viene ignorato e l'utente deve reinserire il cookie
- ? Nessun crash se i file non esistono

### Performance
- ? `SessionManager.LoadSession()` è veloce (legge file piccolo)
- ? Viene chiamato solo quando necessario (avvio, apertura tab, annulla)
- ? Non impatta le performance generali

---

**Data Fix**: 2025  
**Versione**: 5.2+  
**Issue**: Cookie non persisteva tra sessioni  
**Causa**: Cookie mai caricato nella TextBox UI  
**Soluzione**: Caricamento esplicito da `SessionManager.LoadSession()`  
**Status**: ? RISOLTO

## ?? Riferimenti

- Vedi anche: `Services\SessionManager.cs` per dettagli storage sessione
- Vedi anche: `Utilities\SettingsManager.cs` per altre impostazioni
- Vedi anche: `Documentation\FIX_SETTINGS_SAVE_AND_LOGGING.md` per logging