"""Integration tests for Calendar CalDAV operations.

Note: These tests use the shared temporary_calendar fixture from conftest.py
which reuses a session-scoped calendar to avoid Nextcloud rate limiting issues.
Each test cleans up its own events/todos but shares the same calendar.
"""

import logging
import uuid
from datetime import datetime, timedelta

import pytest
from httpx import HTTPStatusError

from nextcloud_mcp_server.client import NextcloudClient

logger = logging.getLogger(__name__)

# Mark all tests in this module as integration tests
pytestmark = pytest.mark.integration


@pytest.fixture
async def temporary_event(nc_client: NextcloudClient, temporary_calendar: str):
    """Create a temporary event for testing and clean up afterward.

    Uses the shared temporary_calendar fixture from conftest.py which reuses
    a session-scoped calendar to avoid Nextcloud rate limiting.
    """
    event_uid = None
    calendar_name = temporary_calendar

    # Create a test event
    tomorrow = datetime.now() + timedelta(days=1)
    event_data = {
        "title": f"Test Event {uuid.uuid4().hex[:8]}",
        "start_datetime": tomorrow.strftime("%Y-%m-%dT14:00:00"),
        "end_datetime": tomorrow.strftime("%Y-%m-%dT15:00:00"),
        "description": "Test event created by integration tests",
        "location": "Test Location",
        "categories": "testing",
        "status": "CONFIRMED",
        "priority": 5,
    }

    try:
        logger.info(f"Creating temporary event in calendar: {calendar_name}")
        result = await nc_client.calendar.create_event(calendar_name, event_data)
        event_uid = result.get("uid")

        if not event_uid:
            pytest.fail("Failed to create temporary event")

        logger.info(f"Created temporary event with UID: {event_uid}")
        yield {"uid": event_uid, "calendar_name": calendar_name, "data": event_data}

    finally:
        # Cleanup
        if event_uid:
            try:
                logger.info(f"Cleaning up temporary event: {event_uid}")
                await nc_client.calendar.delete_event(calendar_name, event_uid)
                logger.info(f"Successfully deleted temporary event: {event_uid}")
            except HTTPStatusError as e:
                if e.response.status_code != 404:
                    logger.error(f"Error deleting temporary event {event_uid}: {e}")
            except Exception as e:
                logger.error(
                    f"Unexpected error deleting temporary event {event_uid}: {e}"
                )


async def test_list_calendars(nc_client: NextcloudClient):
    """Test listing available calendars."""
    calendars = await nc_client.calendar.list_calendars()

    assert isinstance(calendars, list)

    if not calendars:
        pytest.skip("No calendars available - Calendar app may not be enabled")

    logger.info(f"Found {len(calendars)} calendars")

    # Check structure of calendars
    for calendar in calendars:
        assert "name" in calendar
        assert "display_name" in calendar
        assert "href" in calendar
        # Optional fields
        assert "description" in calendar
        assert "color" in calendar

        logger.info(f"Calendar: {calendar['name']} - {calendar['display_name']}")


async def test_create_and_delete_event(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test creating and deleting a basic event."""
    calendar_name = temporary_calendar

    # Create event
    tomorrow = datetime.now() + timedelta(days=1)
    event_data = {
        "title": "Integration Test Event",
        "start_datetime": tomorrow.strftime("%Y-%m-%dT10:00:00"),
        "end_datetime": tomorrow.strftime("%Y-%m-%dT11:00:00"),
        "description": "Test event for integration testing",
        "location": "Test Room",
        "categories": "testing,integration",
        "status": "CONFIRMED",
        "priority": 3,
    }

    try:
        result = await nc_client.calendar.create_event(calendar_name, event_data)
        assert "uid" in result
        assert result["status_code"] in [200, 201, 204]

        event_uid = result["uid"]
        logger.info(f"Created event with UID: {event_uid}")

        # Verify event was created by retrieving it
        retrieved_event, etag = await nc_client.calendar.get_event(
            calendar_name, event_uid
        )
        assert retrieved_event["uid"] == event_uid
        assert retrieved_event["title"] == "Integration Test Event"
        assert retrieved_event["location"] == "Test Room"

        # Delete event
        delete_result = await nc_client.calendar.delete_event(calendar_name, event_uid)
        assert delete_result["status_code"] in [200, 204, 404]

        logger.info(f"Successfully deleted event: {event_uid}")

    except Exception as e:
        logger.error(f"Test failed: {e}")
        raise


async def test_create_all_day_event(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test creating an all-day event."""
    calendar_name = temporary_calendar

    tomorrow = datetime.now() + timedelta(days=1)
    event_data = {
        "title": "All Day Test Event",
        "start_datetime": tomorrow.strftime("%Y-%m-%d"),
        "all_day": True,
        "description": "Test all-day event",
        "categories": "testing",
    }

    try:
        result = await nc_client.calendar.create_event(calendar_name, event_data)
        event_uid = result["uid"]
        logger.info(f"Created all-day event with UID: {event_uid}")

        # Verify event
        retrieved_event, _ = await nc_client.calendar.get_event(
            calendar_name, event_uid
        )
        assert retrieved_event["title"] == "All Day Test Event"
        assert retrieved_event.get("all_day") is True

        # Cleanup
        await nc_client.calendar.delete_event(calendar_name, event_uid)

    except Exception as e:
        logger.error(f"All-day event test failed: {e}")
        raise


async def test_create_recurring_event(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test creating a recurring event."""
    calendar_name = temporary_calendar

    tomorrow = datetime.now() + timedelta(days=1)
    event_data = {
        "title": "Weekly Recurring Test",
        "start_datetime": tomorrow.strftime("%Y-%m-%dT14:00:00"),
        "end_datetime": tomorrow.strftime("%Y-%m-%dT15:00:00"),
        "description": "Test recurring event",
        "recurring": True,
        "recurrence_rule": "FREQ=WEEKLY;BYDAY=MO,WE,FR",
        "reminder_minutes": 30,
    }

    try:
        result = await nc_client.calendar.create_event(calendar_name, event_data)
        event_uid = result["uid"]
        logger.info(f"Created recurring event with UID: {event_uid}")

        # Verify event
        retrieved_event, _ = await nc_client.calendar.get_event(
            calendar_name, event_uid
        )
        assert retrieved_event["title"] == "Weekly Recurring Test"
        assert retrieved_event.get("recurring") is True

        # Cleanup
        await nc_client.calendar.delete_event(calendar_name, event_uid)

    except Exception as e:
        logger.error(f"Recurring event test failed: {e}")
        raise


async def test_list_events_in_range(nc_client: NextcloudClient, temporary_event: dict):
    """Test listing events within a date range."""
    calendar_name = temporary_event["calendar_name"]

    # Get events for the next week
    start_datetime = datetime.now()
    end_datetime = datetime.now() + timedelta(days=7)

    events = await nc_client.calendar.get_calendar_events(
        calendar_name=calendar_name,
        start_datetime=start_datetime,
        end_datetime=end_datetime,
        limit=50,
    )

    assert isinstance(events, list)
    logger.info(f"Found {len(events)} events in date range")

    # Our temporary event should be in the list
    event_uids = [event.get("uid") for event in events]
    assert temporary_event["uid"] in event_uids

    # Check event structure
    for event in events:
        assert "uid" in event
        assert "title" in event
        assert "start_datetime" in event


async def test_update_event(nc_client: NextcloudClient, temporary_event: dict):
    """Test updating an existing event."""
    calendar_name = temporary_event["calendar_name"]
    event_uid = temporary_event["uid"]

    # Update event data
    updated_data = {
        "title": "Updated Test Event Title",
        "description": "Updated description for test event",
        "location": "Updated Location",
        "priority": 1,  # High priority
    }

    try:
        result = await nc_client.calendar.update_event(
            calendar_name, event_uid, updated_data
        )
        assert result["uid"] == event_uid

        # Verify updates
        updated_event, _ = await nc_client.calendar.get_event(calendar_name, event_uid)
        assert updated_event["title"] == "Updated Test Event Title"
        assert updated_event["description"] == "Updated description for test event"
        assert updated_event["location"] == "Updated Location"
        assert updated_event["priority"] == 1

        logger.info(f"Successfully updated event: {event_uid}")

    except Exception as e:
        logger.error(f"Event update test failed: {e}")
        raise


async def test_update_event_extended_fields(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test updating categories, recurrence_rule, attendees, and reminder_minutes."""
    calendar_name = temporary_calendar

    tomorrow = datetime.now() + timedelta(days=1)
    event_data = {
        "title": "Extended Fields Update Test",
        "start_datetime": tomorrow.strftime("%Y-%m-%dT10:00:00"),
        "end_datetime": tomorrow.strftime("%Y-%m-%dT11:00:00"),
        "description": "Base event for extended-field update test",
    }

    event_uid = None
    try:
        result = await nc_client.calendar.create_event(calendar_name, event_data)
        event_uid = result["uid"]
        logger.info(f"Created base event for extended fields test: {event_uid}")

        # --- Phase 1: Set all four extended fields ---
        updated_data = {
            "categories": "work,meeting",
            "recurrence_rule": "FREQ=WEEKLY;COUNT=4",
            "attendees": "alice@example.com,bob@example.com",
            "reminder_minutes": 15,
        }
        await nc_client.calendar.update_event(calendar_name, event_uid, updated_data)

        retrieved, _ = await nc_client.calendar.get_event(calendar_name, event_uid)

        # Verify categories
        assert "work" in retrieved.get("categories", "")
        assert "meeting" in retrieved.get("categories", "")

        # Verify recurrence rule
        assert retrieved.get("recurring") is True
        assert "WEEKLY" in retrieved.get("recurrence_rule", "")

        # Verify attendees
        attendees = retrieved.get("attendees", "")
        assert "alice@example.com" in attendees
        assert "bob@example.com" in attendees

        logger.info("Phase 1 passed: all extended fields set correctly")

        # --- Phase 2: Clear all four extended fields ---
        cleared_data = {
            "categories": "",
            "recurrence_rule": "",
            "attendees": "",
            "reminder_minutes": 0,
        }
        await nc_client.calendar.update_event(calendar_name, event_uid, cleared_data)

        cleared, _ = await nc_client.calendar.get_event(calendar_name, event_uid)

        # Verify categories cleared
        assert not cleared.get("categories")

        # Verify recurrence cleared
        assert cleared.get("recurring") is not True
        assert not cleared.get("recurrence_rule")

        # Verify attendees cleared
        assert not cleared.get("attendees")

        logger.info("Phase 2 passed: all extended fields cleared correctly")

    except Exception as e:
        logger.error(f"Extended fields update test failed: {e}")
        raise
    finally:
        if event_uid:
            try:
                await nc_client.calendar.delete_event(calendar_name, event_uid)
            except Exception:
                pass


async def test_create_event_with_attendees(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test creating an event with attendees."""
    calendar_name = temporary_calendar

    tomorrow = datetime.now() + timedelta(days=1)
    event_data = {
        "title": "Meeting with Attendees",
        "start_datetime": tomorrow.strftime("%Y-%m-%dT16:00:00"),
        "end_datetime": tomorrow.strftime("%Y-%m-%dT17:00:00"),
        "description": "Test meeting with multiple attendees",
        "location": "Conference Room A",
        "attendees": "test1@example.com,test2@example.com",
        "reminder_minutes": 15,
        "status": "TENTATIVE",
    }

    try:
        result = await nc_client.calendar.create_event(calendar_name, event_data)
        event_uid = result["uid"]
        logger.info(f"Created event with attendees, UID: {event_uid}")

        # Verify event
        retrieved_event, _ = await nc_client.calendar.get_event(
            calendar_name, event_uid
        )
        assert retrieved_event["title"] == "Meeting with Attendees"
        assert "test1@example.com" in retrieved_event.get("attendees", "")
        assert retrieved_event["status"] == "TENTATIVE"

        # Cleanup
        await nc_client.calendar.delete_event(calendar_name, event_uid)

    except Exception as e:
        logger.error(f"Event with attendees test failed: {e}")
        raise


async def test_get_nonexistent_event(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test retrieving a non-existent event."""
    calendar_name = temporary_calendar
    fake_uid = f"nonexistent-{uuid.uuid4()}"

    # caldav library raises generic Exception for missing events, not HTTPStatusError
    with pytest.raises(Exception, match="not found"):
        await nc_client.calendar.get_event(calendar_name, fake_uid)

    logger.info(f"Correctly raised exception for nonexistent event: {fake_uid}")


async def test_delete_nonexistent_event(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test deleting a non-existent event."""
    calendar_name = temporary_calendar
    fake_uid = f"nonexistent-{uuid.uuid4()}"

    result = await nc_client.calendar.delete_event(calendar_name, fake_uid)
    assert result["status_code"] == 404
    logger.info(f"Correctly got 404 for deleting nonexistent event: {fake_uid}")


async def test_event_with_url_and_categories(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test creating an event with URL and multiple categories."""
    calendar_name = temporary_calendar

    tomorrow = datetime.now() + timedelta(days=1)
    event_data = {
        "title": "Event with URL and Categories",
        "start_datetime": tomorrow.strftime("%Y-%m-%dT09:00:00"),
        "end_datetime": tomorrow.strftime("%Y-%m-%dT10:30:00"),
        "description": "Test event with additional metadata",
        "categories": "work,meeting,important,quarterly",
        "url": "https://zoom.us/j/123456789",
        "privacy": "PRIVATE",
        "priority": 2,
    }

    try:
        result = await nc_client.calendar.create_event(calendar_name, event_data)
        event_uid = result["uid"]
        logger.info(f"Created event with metadata, UID: {event_uid}")

        # Verify event
        retrieved_event, _ = await nc_client.calendar.get_event(
            calendar_name, event_uid
        )
        assert retrieved_event["title"] == "Event with URL and Categories"
        assert "work" in retrieved_event.get("categories", "")
        assert "important" in retrieved_event.get("categories", "")
        assert retrieved_event.get("url") == "https://zoom.us/j/123456789"
        assert retrieved_event.get("privacy") == "PRIVATE"
        assert retrieved_event.get("priority") == 2

        # Cleanup
        await nc_client.calendar.delete_event(calendar_name, event_uid)

    except Exception as e:
        logger.error(f"Event with metadata test failed: {e}")
        raise


async def test_list_events_date_range_filtering(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test that date range filtering actually excludes events outside the range.

    Reproduces GH-538: get_calendar_events() accepted date range parameters
    but returned events from the entire calendar history, ignoring date filters.
    """
    calendar_name = temporary_calendar
    past_uid = None
    future_uid = None

    try:
        # Create Event A: 30 days in the past
        past_date = datetime.now() - timedelta(days=30)
        past_event_data = {
            "title": f"Past Event {uuid.uuid4().hex[:8]}",
            "start_datetime": past_date.strftime("%Y-%m-%dT10:00:00"),
            "end_datetime": past_date.strftime("%Y-%m-%dT11:00:00"),
            "description": "Event in the past for date range test",
        }
        result_past = await nc_client.calendar.create_event(
            calendar_name, past_event_data
        )
        past_uid = result_past["uid"]
        logger.info(f"Created past event: {past_uid}")

        # Create Event B: 1 day in the future
        future_date = datetime.now() + timedelta(days=1)
        future_event_data = {
            "title": f"Future Event {uuid.uuid4().hex[:8]}",
            "start_datetime": future_date.strftime("%Y-%m-%dT14:00:00"),
            "end_datetime": future_date.strftime("%Y-%m-%dT15:00:00"),
            "description": "Event in the future for date range test",
        }
        result_future = await nc_client.calendar.create_event(
            calendar_name, future_event_data
        )
        future_uid = result_future["uid"]
        logger.info(f"Created future event: {future_uid}")

        # Query with date range: today → 7 days ahead
        now = datetime.now()
        week_ahead = now + timedelta(days=7)

        events = await nc_client.calendar.get_calendar_events(
            calendar_name=calendar_name,
            start_datetime=now,
            end_datetime=week_ahead,
            limit=50,
        )

        event_uids = [e["uid"] for e in events]

        # Future event (tomorrow) SHOULD be in results
        assert future_uid in event_uids, (
            f"Future event {future_uid} should be in date-filtered results"
        )

        # Past event (30 days ago) should NOT be in results
        assert past_uid not in event_uids, (
            f"Past event {past_uid} should be excluded by date range filter "
            f"(GH-538: date range was being ignored)"
        )

        logger.info(
            f"Date range filtering works: {len(events)} events returned, "
            f"past event correctly excluded"
        )

    finally:
        # Cleanup both events
        for uid in [past_uid, future_uid]:
            if uid:
                try:
                    await nc_client.calendar.delete_event(calendar_name, uid)
                except Exception as e:
                    logger.warning(f"Cleanup failed for event {uid}: {e}")


async def test_recurring_event_date_range_expansion(
    nc_client: NextcloudClient, temporary_calendar: str
):
    """Test that recurring events are expanded into individual occurrences.

    When querying with a date range, a recurring event should return one
    event dict per occurrence within the range, each with the correct
    start_datetime for that occurrence (not the original master event date).

    This is a follow-up to GH-538: the time-range filter correctly selected
    recurring events, but returned the master event with its original DTSTART
    instead of expanding occurrences.
    """
    calendar_name = temporary_calendar
    event_uid = None

    try:
        # Create a daily recurring event starting 7 days ago
        start = datetime.now() - timedelta(days=7)
        event_data = {
            "title": f"Daily Recurrence {uuid.uuid4().hex[:8]}",
            "start_datetime": start.strftime("%Y-%m-%dT09:00:00"),
            "end_datetime": start.strftime("%Y-%m-%dT10:00:00"),
            "description": "Daily recurring event for expansion test",
            "recurring": True,
            "recurrence_rule": "FREQ=DAILY",
        }
        result = await nc_client.calendar.create_event(calendar_name, event_data)
        event_uid = result["uid"]
        logger.info(f"Created daily recurring event: {event_uid}")

        # Query with date range: today → 3 days ahead
        query_start = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
        query_end = query_start + timedelta(days=3)

        events = await nc_client.calendar.get_calendar_events(
            calendar_name=calendar_name,
            start_datetime=query_start,
            end_datetime=query_end,
            limit=50,
        )

        # Filter to only our recurring event (calendar may have others)
        our_events = [e for e in events if e["uid"] == event_uid]

        # Should have multiple occurrences (one per day in the range)
        assert len(our_events) >= 2, (
            f"Expected multiple expanded occurrences, got {len(our_events)}. "
            f"Expansion may not be working."
        )

        # Each occurrence should have a different start_datetime
        start_dates = [e["start_datetime"] for e in our_events]
        assert len(set(start_dates)) == len(our_events), (
            f"Each occurrence should have a unique start_datetime, got: {start_dates}"
        )

        # No start_datetime should fall outside the queried range
        for e in our_events:
            event_start = datetime.fromisoformat(e["start_datetime"])
            # Remove timezone info for comparison if present
            if event_start.tzinfo is not None:
                event_start = event_start.replace(tzinfo=None)
            assert event_start >= query_start - timedelta(hours=1), (
                f"Occurrence {e['start_datetime']} is before query start {query_start}"
            )
            assert event_start < query_end + timedelta(hours=1), (
                f"Occurrence {e['start_datetime']} is after query end {query_end}"
            )

        # Expanded occurrences should NOT have recurrence rules
        # (server strips RRULE when expanding)
        for e in our_events:
            assert not e.get("recurring"), (
                "Expanded occurrence should not have recurring=True, "
                "RRULE should be stripped by server-side expansion"
            )

        logger.info(
            f"Recurring event expansion works: {len(our_events)} occurrences "
            f"returned with unique start dates"
        )

    finally:
        if event_uid:
            try:
                await nc_client.calendar.delete_event(calendar_name, event_uid)
            except Exception as e:
                logger.warning(f"Cleanup failed for recurring event {event_uid}: {e}")


async def test_calendar_operations_error_handling(
    nc_client: NextcloudClient,
):
    """Test error handling for calendar operations."""

    # Test with non-existent calendar
    fake_calendar = f"nonexistent_calendar_{uuid.uuid4().hex}"

    # caldav library returns empty list for non-existent calendars, doesn't raise
    # Testing that it doesn't crash and returns empty results
    events = await nc_client.calendar.get_calendar_events(fake_calendar)
    assert isinstance(events, list)
    # Empty list is expected for non-existent calendar
    assert len(events) == 0

    logger.info("Error handling tests completed successfully")