#!/usr/bin/env python3
"""
Smart meeting scheduler for multi-timezone remote agencies.
Tracks team availability, client preferences, and optimal meeting times.
"""

from datetime import datetime, timedelta
import pytz
from typing import List, Dict

class AgencyScheduler:
    def __init__(self):
        self.team_timezones = {
            "alex": "America/New_York",
            "maria": "Europe/London",
            "tokyo": "Asia/Tokyo",
            "sydney": "Australia/Sydney"
        }
        self.client_timezones = {
            "acme_corp": "America/Los_Angeles",
            "eu_startup": "Europe/Berlin",
            "apac_client": "Asia/Singapore"
        }

    def find_optimal_slots(self,
                          team_members: List[str],
                          client: str,
                          duration_min: int = 60,
                          max_slots: int = 5) -> List[Dict]:
        """Find best meeting times across multiple time zones."""

        working_hours = (9, 17)  # 9am-5pm local time
        slots = []

        # Check next 14 days
        for days_ahead in range(14):
            base_date = datetime.now() + timedelta(days=days_ahead)

            # Iterate through possible meeting hours
            for hour in range(8, 20):
                meeting_time_utc = pytz.UTC.localize(
                    datetime(base_date.year, base_date.month, base_date.day, hour, 0)
                )

                # Check if time works for all team members and client
                team_viable = all(
                    self._is_working_hours(meeting_time_utc, self.team_timezones[tm])
                    for tm in team_members
                )

                client_viable = self._is_working_hours(
                    meeting_time_utc, self.client_timezones[client]
                )

                if team_viable and client_viable:
                    # Calculate "spread" - how far from ideal times is each timezone?
                    spread_score = sum(
                        self._calc_spread(meeting_time_utc, self.team_timezones[tm])
                        for tm in team_members
                    )
                    spread_score += self._calc_spread(
                        meeting_time_utc, self.client_timezones[client]
                    )

                    slots.append({
                        'time_utc': meeting_time_utc.isoformat(),
                        'spread_score': spread_score,
                        'local_times': {
                            tm: meeting_time_utc.astimezone(
                                pytz.timezone(self.team_timezones[tm])
                            ).strftime("%H:%M %Z")
                            for tm in team_members
                        },
                        'client_time': meeting_time_utc.astimezone(
                            pytz.timezone(self.client_timezones[client])
                        ).strftime("%H:%M %Z")
                    })

            if len(slots) >= max_slots:
                break

        # Sort by best score (lowest spread = most balanced)
        slots.sort(key=lambda x: x['spread_score'])
        return slots[:max_slots]

    def _is_working_hours(self, meeting_time_utc, timezone: str) -> bool:
        """Check if meeting falls within working hours for timezone."""
        local_time = meeting_time_utc.astimezone(pytz.timezone(timezone))
        hour = local_time.hour
        return 9 <= hour <= 17

    def _calc_spread(self, meeting_time_utc, timezone: str) -> float:
        """Calculate how far from ideal noon meeting time."""
        local_time = meeting_time_utc.astimezone(pytz.timezone(timezone))
        hour = local_time.hour
        ideal_hour = 13  # 1pm is ideal (mid-day focus)
        return abs(hour - ideal_hour)

# Usage
scheduler = AgencyScheduler()
slots = scheduler.find_optimal_slots(
    team_members=["alex", "maria", "tokyo"],
    client="acme_corp",
    duration_min=60,
    max_slots=3
)

for i, slot in enumerate(slots, 1):
    print(f"\nOption {i}: {slot['time_utc']}")
    print(f"Spread score: {slot['spread_score']:.1f}")
    print("Local times:")
    for person, time in slot['local_times'].items():
        print(f"  {person}: {time}")
    print(f"  Client: {slot['client_time']}")

class MeetingAnalytics:
    def analyze_effectiveness(self,
                             past_meetings: List[Dict]) -> Dict:
        """
        Analyze which time zone combinations lead to better outcomes.
        Measures: decision quality, action items, follow-up resolution
        """
        timezone_pairs = {}

        for meeting in past_meetings:
            key = tuple(sorted([meeting['team_tz'], meeting['client_tz']]))

            if key not in timezone_pairs:
                timezone_pairs[key] = {
                    'count': 0,
                    'action_items': 0,
                    'items_completed': 0,
                    'follow_ups_scheduled': 0,
                    'client_satisfaction': 0
                }

            pair_data = timezone_pairs[key]
            pair_data['count'] += 1
            pair_data['action_items'] += meeting.get('action_count', 0)
            pair_data['items_completed'] += meeting.get('completed_actions', 0)
            pair_data['follow_ups_scheduled'] += 1 if meeting.get('has_followup') else 0
            pair_data['client_satisfaction'] += meeting.get('satisfaction_score', 0)

        # Calculate metrics
        effectiveness = {}
        for tz_pair, data in timezone_pairs.items():
            completion_rate = (
                data['items_completed'] / data['action_items']
                if data['action_items'] > 0 else 0
            )
            avg_satisfaction = (
                data['client_satisfaction'] / data['count']
            )

            effectiveness[tz_pair] = {
                'meeting_count': data['count'],
                'action_completion_rate': completion_rate,
                'avg_satisfaction': avg_satisfaction,
                'followup_rate': data['follow_ups_scheduled'] / data['count']
            }

        return effectiveness