undefined

6.5h ┤     ╭╮
6.0h ┤   ╭─╯╰╮
5.5h ┤ ╭─╯   ╰─╮
5.0h ┼─┘       ╰─
     └───────────
     Mar  Apr  May  Jun

12 ┤ ●
10 ┤  ●
 8 ┤    ●
 6 ┤
   └──────
   Dec  Mar  Jun

---

{
  "sleep_records": [
    {
      "id": "sleep_20250620001",
      "date": "2025-06-20",
      "sleep_times": {
        "bedtime": "23:00",
        "sleep_onset_time": "23:30",
        "wake_time": "07:00",
        "out_of_bed_time": "07:15"
      },
      "sleep_metrics": {
        "sleep_duration_hours": 7.0,
        "time_in_bed_hours": 8.25,
        "sleep_latency_minutes": 30,
        "sleep_efficiency": 84.8
      },
      "sleep_quality": {
        "subjective_quality": "fair",
        "quality_score": 5,
        "rested_feeling": "somewhat"
      },
      "factors": {
        "exercise": true,
        "exercise_time": "evening",
        "caffeine_after_2pm": false,
        "screen_time_before_bed_minutes": 60
      }
    }
  ]
}

def calculate_sleep_quality_score(record):
    """
    Calculate sleep quality score (0-10 points)

    Factor Weights:
    - Sleep Duration: 30%
    - Sleep Efficiency: 25%
    - Sleep Onset Latency: 20%
    - Nighttime Awakenings: 15%
    - Subjective Quality: 10%
    """
    score = 0

    # Sleep Duration Score (ideal 7-9 hours)
    duration = record['sleep_duration_hours']
    if 7 <= duration <= 9:
        duration_score = 10
    elif 6 <= duration < 7 or 9 < duration <= 10:
        duration_score = 7
    else:
        duration_score = 4
    score += duration_score * 0.30

    # Sleep Efficiency Score (>90% excellent)
    efficiency = record['sleep_efficiency']
    efficiency_score = min(efficiency / 90 * 10, 10)
    score += efficiency_score * 0.25

    # Sleep Onset Latency Score (<15 minutes excellent)
    latency = record['sleep_latency_minutes']
    if latency <= 15:
        latency_score = 10
    elif latency <= 30:
        latency_score = 7
    elif latency <= 45:
        latency_score = 4
    else:
        latency_score = 1
    score += latency_score * 0.20

    # Nighttime Awakening Score (0 times excellent)
    awakenings = record['awakenings']['count']
    awakening_score = max(10 - awakenings * 2, 0)
    score += awakening_score * 0.15

    # Subjective Quality Score
    quality_map = {
        'excellent': 10,
        'very_good': 8,
        'good': 7,
        'fair': 5,
        'poor': 3,
        'very_poor': 1
    }
    subjective_score = quality_map.get(
        record['sleep_quality']['subjective_quality'],
        5
    )
    score += subjective_score * 0.10

    return round(score, 1)

def calculate_sleep_consistency_score(records):
    """
    Calculate sleep consistency score (0-100 points)

    Factors:
    - Bedtime standard deviation
    - Wake-up time standard deviation
    - Sleep duration standard deviation
    - Weekday vs. weekend difference
    """
    # Extract time data
    bedtimes = [r['bedtime'] for r in records]
    wake_times = [r['wake_time'] for r in records]
    durations = [r['sleep_duration_hours'] for r in records]

    # Calculate standard deviation (minutes)
    bedtime_std = time_to_minutes_std(bedtimes)
    wake_std = time_to_minutes_std(wake_times)
    duration_std = statistics.stdev(durations)

    # Calculate weekday vs. weekend difference
    weekday_avg = avg([r['sleep_duration_hours']
                       for r in records if is_weekday(r)])
    weekend_avg = avg([r['sleep_duration_hours']
                       for r in records if is_weekend(r)])
    diff = abs(weekday_avg - weekend_avg)

    # Comprehensive score
    score = 100
    score -= bedtime_std * 0.5  # Impact of bedtime standard deviation
    score -= wake_std * 0.5     # Impact of wake-up time standard deviation
    score -= duration_std * 2   # Impact of sleep duration standard deviation
    score -= diff * 10          # Impact of weekday-weekend difference

    return max(0, min(100, round(score)))

def calculate_correlation(sleep_data, other_data, lag_days=0):
    """
    Calculate correlation between sleep and other indicators

    Parameters:
    - sleep_data: List of sleep data
    - other_data: List of other indicator data
    - lag_days: Number of lag days (considering delay effects)

    Returns:
    - correlation_coefficient: Correlation coefficient
    - p_value: Statistical significance
    - interpretation: Correlation explanation
    """
    # Align data (considering lag)
    aligned = align_data_with_lag(sleep_data, other_data, lag_days)

    # Calculate Pearson correlation coefficient
    from scipy import stats
    corr, p_value = stats.pearsonr(
        aligned['sleep_values'],
        aligned['other_values']
    )

    # Interpret correlation
    if abs(corr) < 0.3:
        strength = "Weak"
    elif abs(corr) < 0.7:
        strength = "Moderate"
    else:
        strength = "Strong"

    direction = "Positive Correlation" if corr > 0 else "Negative Correlation"
    significant = p_value < 0.05

    interpretation = f"{strength} {direction}"
    if significant:
        interpretation += " (Statistically Significant)"

    return {
        'correlation_coefficient': round(corr, 3),
        'p_value': round(p_value, 4),
        'interpretation': interpretation,
        'significant': significant
    }