# Python: Calendar integration for lactation breaks
from datetime import datetime, timedelta

class LactationBreakScheduler:
    def __init__(self, work_start="09:00", work_end="17:00"):
        self.work_start = datetime.strptime(work_start, "%H:%M")
        self.work_end = datetime.strptime(work_end, "%H:%M")
        self.break_duration = 30  # minutes
        self.break_interval = 150  # minutes (2.5 hours)

    def generate_break_windows(self, date):
        breaks = []
        current = self.work_start

        while current + timedelta(minutes=self.break_duration) <= self.work_end:
            breaks.append({
                'start': current.strftime("%H:%M"),
                'end': (current + timedelta(minutes=self.break_duration)).strftime("%H:%M"),
                'type': 'lactation-break'
            })
            current += timedelta(minutes=self.break_interval)

        return breaks

# Generate typical break windows
scheduler = LactationBreakScheduler()
print(scheduler.generate_break_windows("2026-03-16"))
# Output: [{'start': '09:00', 'end': '09:30', 'type': 'lactation-break'},
#          {'start': '11:30', 'end': '12:00', 'type': 'lactation-break'},
#          {'start': '14:00', 'end': '14:30', 'type': 'lactation-break'}]

# Python: Lactation break automation with multiple calendar systems
from typing import List, Dict
from datetime import datetime, timedelta
import asyncio

class LactationBreakEnforcement:
    def __init__(self, calendar_clients: Dict[str, object]):
        self.calendars = calendar_clients  # Google, Outlook, Slack calendars
        self.break_policies = {}

    async def register_employee_breaks(self, employee_id: str, breaks: List[Dict]):
        """Register lactation breaks for an employee across all systems."""
        policy = {
            'employee_id': employee_id,
            'breaks': breaks,
            'created_at': datetime.now(),
            'applies_to': ['google_calendar', 'outlook', 'slack']
        }
        self.break_policies[employee_id] = policy

        # Push breaks to all connected calendar systems
        await asyncio.gather(
            self._sync_google_calendar(employee_id, breaks),
            self._sync_outlook_calendar(employee_id, breaks),
            self._update_slack_status(employee_id, breaks)
        )

    async def _sync_google_calendar(self, employee_id: str, breaks: List[Dict]):
        """Sync breaks to Google Calendar with protected time settings."""
        for break_window in breaks:
            event = {
                'summary': 'Lactation Break - Protected Time',
                'description': 'Lactation break. Meeting organizers: please reschedule conflicts.',
                'start': {
                    'dateTime': break_window['start'],
                    'timeZone': break_window.get('timezone', 'America/New_York')
                },
                'end': {
                    'dateTime': break_window['end'],
                    'timeZone': break_window.get('timezone', 'America/New_York')
                },
                'transparency': 'opaque',  # Shows as busy
                'visibility': 'private',
                'reminders': {
                    'useDefault': False,
                    'overrides': [
                        {'method': 'popup', 'minutes': 10}
                    ]
                }
            }
            await self.calendars['google'].events.insert(
                calendarId='primary',
                body=event
            )

    async def _sync_outlook_calendar(self, employee_id: str, breaks: List[Dict]):
        """Sync breaks to Outlook calendar."""
        for break_window in breaks:
            event = {
                'subject': 'Lactation Break - Protected Time',
                'bodyPreview': 'Lactation break. Meeting organizers: please reschedule conflicts.',
                'start': break_window['start'],
                'end': break_window['end'],
                'isReminderOn': True,
                'reminderMinutesBeforeStart': 10,
                'isCancelled': False,
                'isOrganizer': True,
                'busyStatus': 'busy'
            }
            await self.calendars['outlook'].post(f'/me/events', json=event)

    async def _update_slack_status(self, employee_id: str, breaks: List[Dict]):
        """Update Slack status to indicate unavailability during breaks."""
        for break_window in breaks:
            slack_status = {
                'status_text': 'On Lactation Break',
                'status_emoji': ':baby_bottle:',
                'expiration': int(datetime.fromisoformat(break_window['end']).timestamp())
            }
            await self.calendars['slack'].users_profile_set(
                user=employee_id,
                profile=slack_status
            )

    async def check_meeting_conflicts(self, meeting: Dict) -> Dict:
        """Validate proposed meeting against registered lactation breaks."""
        for employee in meeting['attendees']:
            if employee not in self.break_policies:
                continue

            policy = self.break_policies[employee]
            meeting_time = datetime.fromisoformat(meeting['start'])

            for break_window in policy['breaks']:
                break_start = datetime.fromisoformat(break_window['start'])
                break_end = datetime.fromisoformat(break_window['end'])

                if break_start <= meeting_time <= break_end:
                    return {
                        'conflict': True,
                        'employee': employee,
                        'break_window': break_window,
                        'message': f'{employee} has protected lactation break {break_window["start"]} - {break_window["end"]}'
                    }

        return {'conflict': False}

# Server-side validation: prevent meetings that violate policy
from fastapi import FastAPI, HTTPException, Header
from typing import List
import asyncio

app = FastAPI()

class MeetingValidator:
    def __init__(self, calendar_service, policy_store):
        self.calendar = calendar_service
        self.policies = policy_store

    async def validate_meeting(self, meeting: dict) -> tuple[bool, str]:
        """
        Validate meeting against all registered lactation policies.
        Returns (is_valid, error_message_if_invalid)
        """
        meeting_start = meeting['start']
        meeting_end = meeting['end']
        attendees = meeting['attendees']

        violations = []

        for attendee in attendees:
            policy = await self.policies.get_lactation_policy(attendee)

            if not policy or not policy.get('breaks'):
                continue

            for break_window in policy['breaks']:
                if self._times_overlap(
                    (meeting_start, meeting_end),
                    (break_window['start'], break_window['end'])
                ):
                    violations.append({
                        'attendee': attendee,
                        'break': break_window,
                        'type': 'protected_time'
                    })

        if violations:
            error_msg = self._build_error_message(violations)
            return False, error_msg

        return True, None

    def _times_overlap(self, time_range_1: tuple, time_range_2: tuple) -> bool:
        """Check if two time ranges overlap."""
        start1, end1 = time_range_1
        start2, end2 = time_range_2
        return start1 < end2 and start2 < end1

    def _build_error_message(self, violations: List[dict]) -> str:
        msg = "Cannot schedule meeting at this time. Conflicts with protected lactation breaks:\n"
        for v in violations:
            msg += f"- {v['attendee']} has break {v['break']['start']} - {v['break']['end']}\n"
        return msg

@app.post('/api/meetings/validate')
async def validate_meeting_endpoint(
    meeting: dict,
    authorization: str = Header(...)
):
    validator = MeetingValidator(calendar_service, policy_store)
    is_valid, error = await validator.validate_meeting(meeting)

    if not is_valid:
        raise HTTPException(status_code=409, detail=error)

    return {'valid': True, 'message': 'Meeting can be scheduled'}