# Idle Consumption Measurement Operation

Măsurarea consumului rezidual (standby) al unui dispozitiv încărcat la maxim.

## Responsabilități

- Determinarea consumului inactiv real al unui dispozitiv (după 100% + top-up)
- Detectare automată a stării "idle" (power stabilizat)
- Selectare manuală a intervalului idle din grafic
- Salvare profil idle per device
- Utilizare pentru terminare automată sesiune + bilanț energetic

## Context

### Problema

După ce dispozitivul raportează **100% battery**, încărcătorul nu se opreşte imediat:

```
Timeline:
00:00 — Device reaches 100%
00:00-00:15 — Top-up phase (unele devices încarcă semnificativ)
               Current: 1.5A → 0.8A → 0.3A → 0.05A
00:15 — Top-up terminat, device intra în idle
00:15-∞ — Idle phase (consum rezidual constant)
         Current: 0.05A constant
         Power: V × 0.05A ≈ 0.25W
```

**Necesar:**
- Distinge top-up phase de idle phase
- Măsoară idle power real
- Folosește-o pentru bilanț energetic final

### Consumul idle = baseline pentru bilanț

```
Total energy from charger:      50 Wh (measured)
Time charging:                  2 hours
Idle power:                      0.25 W
Energy to idle consumption:     0.25W × 2h = 0.5 Wh

Real energy to device battery: 50 - 0.5 = 49.5 Wh

⟹ Capacity learning mai precis
⟹ Bilanț charger vs device vs loss
```

## Invarianţi

- **MUST**: Device la 100% battery la start
- **MUST**: Idle power < 5W (nu active usage)
- **MUST**: Idle power > 0.01W (detectabil)
- **MUST**: Idle interval ≥ 30 secunde (stabilitate)
- **MUST**: Idle power salvat per (device, charger type)
- **SHOULD**: Idle consumul constant (variance < 10%)
- **MAY**: Idle profile salvat in Core Data

## Lifecycle

### 1. Setup & initialization

Utilizatorul:
1. Încarcă device la maxim (100%)
2. Lasă conectat la charger după 100%
3. Deschide app → "Measure idle consumption"
4. Selectează dispozitiv + charger type
5. Pornește măsurare

```swift
struct IdleConsumptionSession {
    let id: UUID
    let deviceID: UUID
    let chargerType: ChargerType?
    let startTime: Date
    let measuredAt100Percent: Bool  // MUST: true
    let sessionID: UUID
}
```

**Precondition:**
- Device must report 100% battery
- Device connected to charger
- Meter recording power

### 2. Wait for top-up completion

App observă power trend:

```swift
func detectIdlePhase(measurements: [Measurement]) -> Int? {
    // Last 60 measurements (1 minute)
    let recent = measurements.suffix(60)
    
    // Calculate power variance in recent window
    let powers = recent.map { $0.power }
    let mean = powers.reduce(0, +) / Double(powers.count)
    let variance = powers.map { pow($0 - mean, 2) }.reduce(0, +) / Double(powers.count)
    let stdDev = sqrt(variance)
    
    // Idle criteria:
    // 1. Power < 5W (no active charging)
    // 2. Variance < 10% of mean (stable)
    // 3. Duration > 30s at this level
    
    if mean < 5.0 && stdDev < (mean * 0.1) {
        return measurements.count - 60  // Index of phase start
    }
    return nil
}
```

**Detection criteria:**
- Power < 5W (no active charging)
- StdDev < 10% of mean (stable, not fluctuating)
- Duration > 30 seconds (confirm stability)

**Timeline:**
```
10:00 — User starts measurement
10:15 — Top-up ends, power drops to 0.25W
        App auto-detects idle phase
10:15-10:45 — User reviews, confirms
```

**MUST**: Detect automatically when possible
**SHOULD**: Notify user "Idle phase detected @ 10:15"

### 3. User review & selection

User vede graficul cu highlight pentru idle phase detectată:

```
Power (W)
20 ├───────────────────┐
   │ Top-up phase      │
10 ├───────────┐       │
   │           │       │
 5 ├───────────┤       │
   │  ↓ Idle detected   │
 0.5 ├───────────────┐ ◄─ Auto-selected interval
   │                │
   └────┬──────────┬──┴───────────→ time
        10:15      10:45
    (start idle)   (user confirmed)
```

**User actions:**
- Tap to confirm auto-selected interval
- Drag to refine start position
- Drag to refine end position
- Tap "Save idle profile"

**MUST**: Allow manual override
**SHOULD**: Offer auto-selection if confidence high

### 4. Compute idle power

```swift
func computeIdlePower(
    measurements: [Measurement],
    from startTime: Date,
    to endTime: Date
) -> IdleConsumptionProfile {
    let filtered = measurements.filter { m in
        m.timestamp >= startTime && m.timestamp <= endTime
    }
    
    guard !filtered.isEmpty else { return nil }
    
    let powers = filtered.map { $0.power }
    let currents = filtered.map { $0.current }
    let voltages = filtered.map { $0.voltage }
    
    let avgPower = powers.reduce(0, +) / Double(powers.count)
    let stdDev = sqrt(
        powers.map { pow($0 - avgPower, 2) }.reduce(0, +) / Double(powers.count)
    )
    
    // Energy over idle period
    let duration = endTime.timeIntervalSince(startTime)
    let energy = avgPower * duration / 3600  // Wh
    
    return IdleConsumptionProfile(
        deviceID: device.id,
        chargerID: charger?.id,
        idlePower: avgPower,  // W
        stdDev: stdDev,
        energy: energy,
        sampleCount: filtered.count,
        measuredAt: Date.now,
        interval: (startTime, endTime)
    )
}
```

### 5. Save idle profile

**Salvează:**
```swift
struct IdleConsumptionProfile {
    let id: UUID
    let deviceID: UUID
    let chargerID: UUID?  // Optional, may be unknown charger
    let idlePower: Double  // W, avg
    let stdDev: Double     // W, variance
    let energy: Double     // Wh, cumulative idle energy
    let sampleCount: Int
    let measuredAt: Date
    let interval: (start: Date, end: Date)
    let notes: String?
}
```

**NU salvează:** Raw measurements

**Storage:** Core Data `DeviceIdleProfile` table

**MUST**: Salvare explicită (user confirm)
**SHOULD**: Allow update (measure again if suspicious)

## API Public

### Measurement

```swift
// Start idle measurement session
func startIdleConsumptionSession(
    for device: ChargedDevice,
    charger: ChargerType?
) -> IdleConsumptionSession

// Detect idle phase automatically
func detectIdlePhase(
    in measurements: [Measurement]
) -> (startIndex: Int, confidence: Double)?

// Compute idle profile for interval
func computeIdlePower(
    measurements: [Measurement],
    from: Date,
    to: Date
) -> IdleConsumptionProfile?

// Save profile
func saveIdleProfile(_ profile: IdleConsumptionProfile) -> Bool
```

### Query & usage

```swift
// Get idle profile for device
func loadIdleProfile(for device: ChargedDevice) -> IdleConsumptionProfile?

// Get all profiles for device (multiple charger types)
func loadIdleProfiles(for device: ChargedDevice) 
    -> [IdleConsumptionProfile]

// Get idle power estimate for device+charger combo
func getIdlePower(
    device: ChargedDevice,
    charger: ChargerType?
) -> Double?

// Update profile after new measurement
func updateIdleProfile(_ profile: IdleConsumptionProfile) -> Bool

// Delete old profile
func deleteIdleProfile(_ id: UUID) -> Bool
```

## Comportamente critice

### Top-up phase confusion

```
Timeline misreading:
User thinks 10:10 = idle start
But device still trickling charge @ 0.2A
Power = 1.0W (not idle yet!)
⟹ False idle profile
```

**MUST**: Require variance < 10% (not just low power)
**SHOULD**: Alert user if variance high
**MAY**: Auto-suggest earlier/later boundary

### Multiple charger types

```
Device A measured with:
- Charger X: idle = 0.25W
- Charger Y: idle = 0.30W (different charger)

⟹ Store separate profiles
⟹ User selects charger type at measurement time
```

**MUST**: Key by (device, charger type)
**SHOULD**: Allow null charger (unknown)
**SHOULD**: Group by device in UI

### Device still charging (false idle)

```
User hits "save" while device still @ 100%
But charger delivering 0.5A (top-up)
Power = 2.5W
⟹ This is NOT idle, it's slow charge!
```

**MUST**: Warn if battery % still 100% during interval
**SHOULD**: Reject if power > 3W (too high for idle)
**MAY**: Ask "Are you sure this is idle?"

### Idle profile very high (> 1W)

```
Device idle measurement: 1.5W
(Typical idle: 0.1-0.5W)
⟹ Something unusual:
   - Screen still on?
   - Background app running?
   - Device malfunctioning?
```

**SHOULD**: Warn "Idle power seems high"
**SHOULD**: Suggest retry with device fully idle
**MAY**: Store with `dataQuality: "warning"`

## Use cases

### 1. Auto-terminate charging session

```
Charging session started:
  Start battery: 20%
  Start energy: 0 Wh

During charging:
  Monitor power trend
  When power drops to idle level...
  
Idle detection trigger:
  Power < idle_threshold (e.g., 0.3W)
  Duration > 2 minutes stable
  Battery = 100%
  
⟹ Auto-terminate session
⟹ Calculate final energy
```

**Pseudocode:**
```swift
func shouldAutoTerminateCharging(
    currentPower: Double,
    currentBattery: Double,
    duration: TimeInterval
) -> Bool {
    let idleProfile = loadIdleProfile(for: device)
    let idleThreshold = (idleProfile?.idlePower ?? 0.5) * 1.5  // 50% margin
    
    return currentPower < idleThreshold &&
           currentBattery >= 99.0 &&
           duration > 120  // 2 min stable
}
```

### 2. Bilanț energetic final

```
Charging session:
  Meter energy:      50.0 Wh
  Duration:          2 hours
  Idle power:        0.25 W
  Idle energy:       0.25W × 2h = 0.5 Wh
  
Charger idle:        0.10 W
Charger idle energy: 0.10W × 2h = 0.2 Wh

Energy to device:    50.0 - 0.5 - 0.2 = 49.3 Wh
```

**Accuracy improvement**: +1-2% fidelity

### 3. Anomaly detection

```
Device A (iPhone):
  Normal idle: 0.15W
  Today's measurement: 0.45W  (3× higher!)
  
⟹ Alert user:
   "Device drawing 3× idle power"
   "Battery drain issue?"
   "Check background apps"
```

## Statistici generate

| Metric | Unit | Descriere |
|---|---|---|
| Idle Power | W | Average power during idle |
| StdDev | W | Variance (should be low) |
| Idle Energy | Wh | Total over measurement period |
| Sample Count | # | Measurements in interval |
| Confidence | % | Stability metric |
| Data Quality | flag | "good" / "warning" / "poor" |

### Confidence calculation

```swift
func calculateConfidence(stdDev: Double, mean: Double) -> Double {
    let relativeStdDev = stdDev / mean
    
    if relativeStdDev < 0.05 {
        return 0.95  // Excellent
    } else if relativeStdDev < 0.10 {
        return 0.85  // Good
    } else if relativeStdDev < 0.20 {
        return 0.70  // Fair
    } else {
        return 0.50  // Poor (high variance)
    }
}
```

## Testare

### Unit tests

```swift
test_detectIdlePhase_ValidData()
test_detectIdlePhase_HighVariance_NotDetected()
test_detectIdlePhase_HighPower_NotDetected()
test_detectIdlePhase_MinimumDuration()
test_computeIdlePower_ValidInterval()
test_computeIdlePower_EmptyInterval()
test_computeIdlePower_HighVariance_Warning()
test_saveIdleProfile_Persists()
test_loadIdleProfile_ByDevice()
test_multipleChargerTypes_SeparateProfiles()
test_shouldAutoTerminateCharging_WithIdleProfile()
test_energyBilantz_SubtractsIdleEnergy()
test_confidenceCalculation_RelativeVariance()
```

### Integration tests

- [ ] Measure idle: device 100%, charger connected
- [ ] Auto-detect idle phase when variance drops
- [ ] User overrides auto-selection with manual interval
- [ ] Save idle profile → reload → same values
- [ ] Multiple profiles per device (different chargers)
- [ ] Auto-terminate charging when idle detected
- [ ] Energy bilanț matches meter - idle correction
- [ ] Anomaly detection for 3× idle power

## Edge cases

### Very low idle (< 0.01W)

```
Device truly idle: 0.008W
Below detection threshold
⟹ Impossible to measure accurately
```

**SHOULD**: "Idle power too low to measure"
**MAY**: Skip measurement

### Device powered off during measurement

```
User powers off device mid-measurement
Power drops to 0W
⟹ Not idle, device is off
```

**MUST**: Detect power drop to 0
**SHOULD**: Discard measurement
**MAY**: Suggest "Check device is still on"

### Charger unplugged mid-measurement

```
User unplugs charger
Power drops immediately
⟹ Not valid idle state
```

**SHOULD**: Detect sudden power drop
**SHOULD**: Alert user "Charger disconnected?"

### Very long idle measurement

```
User measures 24 hours of idle
Device behavior may change:
- OS updates background activity
- Bluetooth periodic sync
- GPS location update
⟹ Not constant idle
```

**SHOULD**: Warn if > 2 hours
**MAY**: Suggest shorter interval (30 min typical)

## Storage & syncing

### What IS saved

```json
{
  "id": "UUID",
  "deviceID": "UUID",
  "chargerID": "UUID?",
  "idlePower": 0.25,
  "stdDev": 0.02,
  "energy": 0.5,
  "sampleCount": 3600,
  "measuredAt": "2026-05-23T10:45:00Z",
  "confidence": 0.85,
  "dataQuality": "good"
}
```

### What is NOT saved

```
❌ individual measurements
❌ raw power samples
❌ voltage/current timeseries
❌ interval timestamps (only duration)
```

**Reason**: Storage efficiency

### CloudKit sync

- **SHOULD**: Sync idle profiles to iCloud
- **REASON**: Use on other devices (same charger type)
- **Example**: iPhone idle measured on device A, used on device B

## Dependenţe

- [Charging Monitoring](./ChargingMonitoring.md): session context
- [Consumption Measurement](./ConsumptionMeasurement.md): power analysis
- Core Data: `DeviceIdleProfile` entity
- UI: Graph with selection + auto-detection highlight

## Related features

### Auto-terminate charging session

```swift
func shouldAutoTerminate(
    session: ChargeSession,
    currentPower: Double,
    battery: Double
) -> Bool {
    guard battery >= 99.0 else { return false }
    
    let idle = loadIdleProfile(for: session.device)
    let threshold = (idle?.idlePower ?? 0.5) * 1.5
    
    return currentPower < threshold
}
```

### Energy balance correction

```swift
func correctedDeviceEnergy(
    total: Double,
    idleProfile: IdleConsumptionProfile,
    duration: TimeInterval
) -> Double {
    let idleEnergy = idleProfile.idlePower * duration / 3600
    return total - idleEnergy
}
```

## Notes

- **Measurement window**: Tipic 30 min — 2 ore
- **Update frequency**: Every few weeks (device behavior stable)
- **Per charger**: Different chargers may have different idle power
- **Privacy**: No raw data, just aggregates
- **Related**: [Charge Session Integrity](../Charge%20Session%20Integrity%20and%20Conflict%20Healing.md)