import pytest
from datetime import datetime, timedelta, timezone
from uuid import UUID, uuid4
from zoneinfo import ZoneInfo

from app.crud.event import event_crud as crud_event
from app.schemas.events import EventCreate, EventUpdate
from app.models.event import Event


def test_create_event(db_session, mock_user):
    """Test creating a new event."""
    event_data = {
        "title": "Test Birthday Party",
        "slug": "test-birthday-party",
        "description": "A test birthday celebration",
        "event_date": datetime.now(tz=timezone.utc) + timedelta(days=30),
        "timezone": "UTC",
        "is_public": True
    }
    event_in = EventCreate(**event_data)
    event = crud_event.create_with_owner(
        db=db_session, obj_in=event_in, owner_id=mock_user.id
    )

    assert event.title == event_data["title"]
    assert event.slug == event_data["slug"]
    assert event.created_by == mock_user.id


def test_get_event(db_session, mock_event):
    """Test retrieving an event by ID."""
    stored_event = crud_event.get(db=db_session, id=mock_event.id)
    assert stored_event
    assert stored_event.id == mock_event.id
    assert stored_event.title == mock_event.title


def test_get_event_by_slug(db_session, mock_event):
    """Test retrieving an event by slug."""
    stored_event = crud_event.get_by_slug(db=db_session, slug=mock_event.slug)
    assert stored_event
    assert stored_event.id == mock_event.id
    assert stored_event.slug == mock_event.slug


def test_get_user_events(db_session, mock_event, mock_user):
    """Test retrieving all events for a specific user."""
    events = crud_event.get_user_events(
        db=db_session,
        user_id=mock_user.id,
        skip=0,
        limit=100
    )
    assert len(events) > 0
    assert any(event.id == mock_event.id for event in events)


def test_update_event(db_session, mock_event):
    """Test updating an event."""
    update_data = EventUpdate(
        title="Updated Birthday Party",
        description="Updated description"
    )
    updated_event = crud_event.update(
        db=db_session,
        db_obj=mock_event,
        obj_in=update_data
    )
    assert updated_event.title == "Updated Birthday Party"
    assert updated_event.description == "Updated description"


def test_delete_event(db_session, mock_event):
    """Test deleting an event."""
    event = crud_event.remove(db=db_session, id=mock_event.id)
    assert event.id == mock_event.id
    deleted_event = crud_event.get(db=db_session, id=mock_event.id)
    assert deleted_event is None


def test_get_upcoming_events(db_session):
    """Test retrieving upcoming events."""
    now = datetime.now(tz=timezone.utc)
    future_date = now + timedelta(days=30)

    future_event_data = {
        "title": "Future Event",
        "slug": "future-event",
        "description": "An upcoming event",
        "event_date": future_date,
        "timezone": "UTC",
        "is_public": True
    }
    event_in = EventCreate(**future_event_data)
    crud_event.create_with_owner(
        db=db_session,
        obj_in=event_in,
        owner_id=uuid4()
    )

    upcoming_events = crud_event.get_upcoming_events(
        db=db_session,
        skip=0,
        limit=100
    )
    assert len(upcoming_events) > 0

    current_time = datetime.now(tz=timezone.utc)
    for event in upcoming_events:
        # Add timezone info to event_date if it's naive
        event_date = event.event_date
        if event_date.tzinfo is None:
            event_date = event_date.replace(tzinfo=timezone.utc)
        assert event_date >= current_time


def test_get_public_event(db_session, mock_event):
    """Test retrieving a public event."""
    public_event = crud_event.get_public_event(
        db=db_session,
        slug=mock_event.slug
    )
    assert public_event is not None
    assert public_event.is_public is True


def test_get_private_event_with_access_code(db_session):
    """Test retrieving a private event with access code."""
    private_event_data = {
        "title": "Private Party",
        "slug": "private-party",
        "event_date": datetime.now(tz=timezone.utc) + timedelta(days=30),
        "timezone": "UTC",
        "is_public": False,
        "access_code": "secret123"
    }
    event_in = EventCreate(**private_event_data)
    private_event = crud_event.create_with_owner(
        db=db_session,
        obj_in=event_in,
        owner_id=uuid4()
    )

    # Try accessing with correct access code
    retrieved_event = crud_event.get_public_event(
        db=db_session,
        slug="private-party",
        access_code="secret123"
    )
    assert retrieved_event is not None
    assert retrieved_event.id == private_event.id

    # Try accessing with wrong access code
    retrieved_event = crud_event.get_public_event(
        db=db_session,
        slug="private-party",
        access_code="wrong"
    )
    assert retrieved_event is None


def test_get_non_existent_event(db_session):
    """Test retrieving a non-existent event."""
    non_existent_id = uuid4()
    event = crud_event.get(db=db_session, id=non_existent_id)
    assert event is None


def test_get_non_existent_event_by_slug(db_session):
    """Test retrieving a non-existent event by slug."""
    event = crud_event.get_by_slug(db=db_session, slug="non-existent-slug")
    assert event is None


def test_create_event_with_invalid_date(db_session, mock_user):
    """Test creating an event with a past date."""
    past_date = datetime.now(tz=timezone.utc) - timedelta(days=1)
    event_data = {
        "title": "Past Event",
        "slug": "past-event",
        "event_date": past_date,
        "timezone": "UTC"
    }
    with pytest.raises(ValueError):
        event_in = EventCreate(**event_data)