from datetime import datetime, timedelta
from typing import List
import pytest
from pydantic import ValidationError
from app.schemas import (
    SleepSessionCreate,
    SleepSessionUpdate,
    SleepSessionRead,
    SessionListResponse,
    DailySummaryDay,
    DailySummaryResponse,
    TimetableSlot,
    TimetableResponse,
    WakeupBedtimeDay,
    WakeupBedtimeResponse,
    SummaryResponse,
)

def test_sleep_session_create_valid():
    start_time = datetime.now()
    data = {"start_time": start_time}
    schema = SleepSessionCreate(**data)
    assert schema.start_time == start_time

def test_sleep_session_create_invalid_missing_field():
    with pytest.raises(ValidationError):
        SleepSessionCreate()

def test_sleep_session_create_invalid_type():
    with pytest.raises(ValidationError):
        SleepSessionCreate(start_time="not-a-date")

def test_sleep_session_update_valid():
    start_time = datetime.now()
    data = {"start_time": start_time}
    schema = SleepSessionUpdate(**data)
    assert schema.start_time == start_time
    assert schema.end_time is None

def test_sleep_session_update_valid_partial():
    data = {"end_time": datetime.now()}
    schema = SleepSessionUpdate(**data)
    assert schema.end_time is not None
    assert schema.start_time is None

def test_sleep_session_read_valid():
    now = datetime.now()
    data = {
        "id": 1,
        "start_time": now,
        "end_time": now + timedelta(hours=8),
        "created_at": now,
        "updated_at": now,
    }
    schema = SleepSessionRead(**data)
    assert schema.id == 1
    assert schema.start_time == now
    assert schema.end_time == now + timedelta(hours=8)

def test_sleep_session_read_invalid_id():
    now = datetime.now()
    data = {
        "id": "not-an-int",
        "start_time": now,
        "end_time": None,
        "created_at": now,
        "updated_at": now,
    }
    with pytest.raises(ValidationError):
        SleepSessionRead(**data)

def test_session_list_response_valid():
    now = datetime.now()
    sessions = [
        {
            "id": 1,
            "start_time": now,
            "end_time": None,
            "created_at": now,
            "updated_at": now,
        }
    ]
    data = {"sessions": sessions, "total": 1}
    schema = SessionListResponse(**data)
    assert len(schema.sessions) == 1
    assert schema.total == 1

def test_session_list_response_invalid_sessions():
    with pytest.raises(ValidationError):
        SessionListResponse(sessions="not-a-list", total=0)

def test_daily_summary_day_valid():
    data = {
        "date": "2023-01-01",
        "total_minutes": 480,
        "day_minutes": 200,
        "night_minutes": 280,
    }
    schema = DailySummaryDay(**data)
    assert schema.date == "2023-01-01"
    assert schema.total_minutes == 480

def test_daily_summary_day_invalid_type():
    with pytest.raises(ValidationError):
        DailySummaryDay(date="2023-01-01", total_minutes="not-an-int", day_minutes=100, night_minutes=100)

def test_daily_summary_response_valid():
    days = [
        {
            "date": "2023-01-01",
            "total_minutes": 480,
            "day_minutes": 200,
            "night_minutes": 280,
        }
    ]
    data = {"days": days}
    schema = DailySummaryResponse(**data)
    assert len(schema.days) == 1

def test_timetable_slot_valid():
    data = {
        "date": "2023-01-01",
        "slot_start": "08:00",
        "slot_end": "09:00",
        "sleeping": True,
    }
    schema = TimetableSlot(**data)
    assert schema.sleeping is True

def test_timetable_slot_invalid_sleeping():
    with pytest.raises(ValidationError):
        TimetableSlot(date="2023-01-01", slot_start="08:00", slot_end="09:00", sleeping="not-a-bool")

def test_timetable_response_valid():
    slots = [
        {
            "date": "2023-01-01",
            "slot_start": "08:00",
            "slot_end": "09:00",
            "sleeping": True,
        }
    ]
    data = {"slots": slots}
    schema = TimetableResponse(**data)
    assert len(schema.slots) == 1

def test_wakeup_bedtime_day_valid():
    data = {"date": "2023-01-01", "wakeup_minutes": 480, "bedtime_minutes": 1200}
    schema = WakeupBedtimeDay(**data)
    assert schema.wakeup_minutes == 480
    assert schema.bedtime_minutes == 1200

def test_wakeup_bedtime_day_optional_fields():
    data = {"date": "2023-01-01"}
    schema = WakeupBedtimeDay(**data)
    assert schema.wakeup_minutes is None
    assert schema.bedtime_minutes is None

def test_wakeup_bedtime_response_valid():
    days = [{"date": "2023-01-01", "wakeup_minutes": 480, "bedtime_minutes": 1200}]
    data = {"days": days}
    schema = WakeupBedtimeResponse(**data)
    assert len(schema.days) == 1

def test_summary_response_valid():
    data = {
        "total_sleeps": 10,
        "avg_sleeps_per_day": 1.5,
        "total_sleeps_all_time": 100,
        "avg_sleeps_per_day_all_time": 1.2,
    }
    schema = SummaryResponse(**data)
    assert schema.total_sleeps == 10
    assert schema.avg_sleeps_per_day == 1.5

def test_summary_response_invalid_float():
    with pytest.raises(ValidationError):
        SummaryResponse(
            total_sleeps=10,
            avg_sleeps_per_day="not-a-float",
            total_sleeps_all_time=100,
            avg_sleeps_per_day_all_time=1.2,
        )