events.py

from flask import render_template, request, jsonify, redirect, url_for, flash, abort, session as flask_session
from sqlalchemy import case, text
from datetime import datetime, timedelta, time as dt_time
from cacheout import Cache
from dateutil.rrule import rrulestr
from contextlib import contextmanager
from sqlalchemy.orm import joinedload
from types import SimpleNamespace
import logging
import os
import pytz
from urllib.parse import quote_plus

from database import SessionLocal, Event, Venue, Category, get_next_event_id
from auth import login_required
from urls import safe_http_url

logger = logging.getLogger(__name__)

# Global cache configuration - can be adjusted
CACHE_TTL_SECONDS = 5 * 60  # 5 minutes

# Initialize cache for complete day events
# Key format: f"{date_str}" (e.g., "2025-01-15")
# Value: complete list of events (non-recurring + expanded recurring) for that day
day_events_cache = Cache(maxsize=30, ttl=CACHE_TTL_SECONDS)

# Initialize cache for calendar range events
# Key format: f"calendar_{start_str}_{end_str}"
# Value: list of events for the calendar range
calendar_events_cache = Cache(maxsize=40, ttl=CACHE_TTL_SECONDS)

# Default; overridden from app config in register_events()
LOCAL_TIMEZONE = pytz.timezone('America/New_York')

# Shared event link arrow (events list + venue upcoming events)
EVENT_LINK_ARROW = '→'

# Previous-day events only count as "ongoing" if they run past this hour on the viewed day
ONGOING_CUTOFF_HOUR = 6

@contextmanager
def get_db_session():
    """Context manager for database sessions"""
    session = SessionLocal()
    try:
        yield session
    finally:
        session.close()

def get_form_venues(session):
    """Venues for event form dropdown: open first (A-Z), closed last (A-Z)."""
    is_closed = Venue.name.ilike('%closed%')
    return session.query(Venue).order_by(case((is_closed, 1), else_=0), Venue.name).all()

def get_cached_day_events(date_str):
    """Get complete day events for a specific date from cache"""
    if day_events_cache is not None:
        cached = day_events_cache.get(date_str)
        return cached
    return None

def set_cached_day_events(date_str, events):
    """Cache complete day events for a specific date"""
    if day_events_cache is not None:
        day_events_cache.set(date_str, events)

def get_cached_calendar_events(start_str, end_str):
    """Get calendar events for a date range from cache"""
    if calendar_events_cache is not None:
        cache_key = f"calendar_{start_str}_{end_str}"
        return calendar_events_cache.get(cache_key)
    return None

def set_cached_calendar_events(start_str, end_str, events):
    """Cache calendar events for a date range"""
    if calendar_events_cache is not None:
        cache_key = f"calendar_{start_str}_{end_str}"
        calendar_events_cache.set(cache_key, events)

def clear_day_events_cache():
    """Clear the complete day events cache - call this when events are modified"""
    if day_events_cache is not None:
        day_events_cache.clear()

def clear_calendar_events_cache():
    """Clear the calendar events cache - call this when events are modified"""
    if calendar_events_cache is not None:
        calendar_events_cache.clear()

def _event_venue_name(event):
    """Venue name for persisted or expanded (transient) event instances."""
    venue = getattr(event, 'venue', None)
    if venue is not None:
        return venue.name
    return getattr(event, '_venue_name', None)

def serialize_event(event, *, slim=False):
    """Serialize an Event (or lightweight occurrence) for JSON API responses.

    slim=True omits description/rrule/flags — enough for FullCalendar month views.
    """
    payload = {
        'id': event.id,
        'title': event.title,
        'start': event.start.isoformat(),
        'end': event.end.isoformat(),
        'venue': _event_venue_name(event),
        'color': event.color,
        'backgroundColor': event.bg,
    }
    if slim:
        return payload
    payload.update({
        'start_date': event.start_date.isoformat() if event.start_date else None,
        'description': event.description,
        'venue_id': event.venue_id,
        'is_virtual': event.is_virtual,
        'is_hybrid': event.is_hybrid,
        'url': event.url,
        'is_recurring': event.is_recurring,
        'rrule': event.rrule,
        'recurring_until': event.recurring_until.isoformat() if event.recurring_until else None,
    })
    return payload

def normalize_rrule(raw):
    """Strip noise and empty segments (no silent syntax rewrites)."""
    if raw is None:
        return ''
    s = str(raw).strip()
    if not s:
        return ''
    if s.upper().startswith('RRULE:'):
        s = s[6:].strip()
    parts = [p.strip() for p in s.split(';') if p.strip()]
    return ';'.join(parts)


def validate_rrule(raw, dtstart=None):
    """Return (normalized, None) or (None, error_message). Blank input -> (None, None)."""
    if raw is None or not str(raw).strip():
        return None, None
    normalized = normalize_rrule(raw)
    if not normalized:
        return None, None
    if not any(p.upper().startswith('FREQ=') for p in normalized.split(';')):
        return None, 'must include FREQ=... (example: FREQ=WEEKLY;BYDAY=MO)'
    try:
        rrulestr(normalized, dtstart=dtstart or datetime(2020, 1, 1))
    except (ValueError, TypeError) as exc:
        return None, str(exc)
    return normalized, None


def expand_recurring_events(event, start_date, end_date):
    """Expand an RRULE into lightweight occurrence objects (not ORM Event instances)."""
    raw = event.rrule
    if not raw or not str(raw).strip():
        return [event]

    normalized = normalize_rrule(raw)
    if not normalized:
        logger.error(
            'Invalid empty RRULE after normalize for event id=%s title=%r rrule=%r',
            getattr(event, 'id', None), getattr(event, 'title', None), raw,
        )
        return []

    try:
        rule = rrulestr(normalized, dtstart=event.start)
        instances = rule.between(start_date, end_date)
    except (ValueError, TypeError) as exc:
        logger.error(
            'Invalid RRULE for event id=%s title=%r rrule=%r: %s',
            getattr(event, 'id', None), getattr(event, 'title', None), raw, exc,
        )
        return []

    duration = event.end - event.start
    venue_name = _event_venue_name(event)
    expanded_events = []
    for instance_start in instances:
        expanded_events.append(SimpleNamespace(
            id=event.id,
            start_date=event.start_date,
            title=event.title,
            description=event.description,
            start=instance_start,
            end=instance_start + duration,
            venue_id=event.venue_id,
            venue=None,
            _venue_name=venue_name,
            color=event.color,
            bg=event.bg,
            is_virtual=event.is_virtual,
            is_hybrid=event.is_hybrid,
            url=event.url,
            is_recurring=True,
            rrule=normalized,
            recurring_until=event.recurring_until,
        ))

    return expanded_events

def get_upcoming_events_for_venue(session, venue_id, min_count=10, window_days=14, horizon_days=90):
    """Return upcoming events at a venue: all in the next window_days, or at least min_count."""
    # Events are stored as America/New_York naive; never compare to UTC datetime.now().
    now = datetime.now(pytz.UTC).astimezone(LOCAL_TIMEZONE).replace(tzinfo=None)
    horizon_end = now + timedelta(days=horizon_days)
    window_end = now + timedelta(days=window_days)
    today = now.date()
    fetch_limit = max(min_count * 3, 50)

    # Bound by horizon + LIMIT so popular venues don't load 1000+ future rows
    non_recurring = session.query(Event).options(joinedload(Event.venue)).filter(
        Event.venue_id == venue_id,
        Event.is_recurring == False,
        Event.end >= now,
        Event.start <= horizon_end,
    ).order_by(Event.start).limit(fetch_limit).all()

    recurring = session.query(Event).options(joinedload(Event.venue)).filter(
        Event.venue_id == venue_id,
        Event.is_recurring == True,
        (Event.recurring_until == None) | (Event.recurring_until >= today)
    ).all()

    expanded = []
    for event in recurring:
        instances = expand_recurring_events(event, now, horizon_end)
        for instance in instances:
            if instance.end >= now:
                expanded.append(instance)

    all_events = list(non_recurring) + expanded
    all_events.sort(key=lambda x: x.start)
    in_window = [e for e in all_events if e.start <= window_end]
    if len(in_window) >= min_count:
        return in_window
    return all_events[:min_count]

DOWNTOWN_DETROIT_MAP_QUERY = "Downtown Detroit, MI"

def get_venue_map_embed(venue):
    """Build legacy Google Maps iframe URL (no API key required)."""
    if venue.address and venue.address.strip():
        query = venue.address.strip()
        is_fallback = False
    else:
        query = DOWNTOWN_DETROIT_MAP_QUERY
        is_fallback = True
    embed_url = (
        "https://maps.google.com/maps?"
        f"q={quote_plus(query)}&z=15&ie=UTF8&iwloc=&output=embed"
    )
    return embed_url, is_fallback

def register_events(app):
    global LOCAL_TIMEZONE
    tz = app.config.get('LOCAL_TIMEZONE')
    if tz is not None:
        LOCAL_TIMEZONE = tz

    @app.template_filter('safe_url')
    def safe_url_filter(url):
        return safe_http_url(url) or ''

    def get_events_in_batches(session, start_date, end_date, batch_size=1000):
        events = []
        offset = 0
        while True:
            batch = session.query(Event).filter(
                Event.start_date >= start_date,
                Event.start_date <= end_date
            ).order_by(Event.start_date, Event.start).offset(offset).limit(batch_size).all()
            if not batch:
                break
            events.extend(batch)
            offset += batch_size
            if len(batch) < batch_size:
                break
        return events

    @app.route('/events')
    def get_events():
        # Check if this is a single-day request (from events list widget)
        date = request.args.get('date')
        if date:
            target_date = datetime.strptime(date, '%Y-%m-%d').date()
            use_cache = not flask_session.get('logged_in')
            
            # Check cache first for complete day events (anonymous only)
            cached_day_events = get_cached_day_events(date) if use_cache else None
            
            if cached_day_events is not None:
                event_list = cached_day_events
            else:
                previous_date = target_date - timedelta(days=1)
                ongoing_cutoff = datetime.combine(target_date, dt_time(hour=ONGOING_CUTOFF_HOUR))
                midnight = datetime.combine(target_date, dt_time.min)
                expand_start = datetime.combine(previous_date, datetime.min.time())
                expand_end = datetime.combine(target_date, datetime.max.time())

                with get_db_session() as session:
                    # PK seek on start_date only (avoid idx_recurring full scan); split in Python
                    day_rows = session.query(Event).options(joinedload(Event.venue)).filter(
                        Event.start_date.in_([previous_date, target_date])
                    ).order_by(Event.start).all()

                    day_events = []
                    ongoing_events = []
                    for event in day_rows:
                        if event.is_recurring:
                            continue
                        if event.start_date == target_date:
                            day_events.append(event)
                        elif event.end > midnight and event.end > ongoing_cutoff:
                            ongoing_events.append(event)

                    # One recurring query covering both target and previous-day ongoing
                    recurring_events = session.query(Event).options(joinedload(Event.venue)).filter(
                        Event.is_recurring == True,
                        Event.start_date <= target_date,
                        (Event.recurring_until == None) | (Event.recurring_until >= previous_date)
                    ).all()

                    expanded_events = []
                    ongoing_expanded = []
                    for event in recurring_events:
                        for instance in expand_recurring_events(event, expand_start, expand_end):
                            inst_date = instance.start.date()
                            if inst_date == target_date:
                                expanded_events.append(instance)
                            elif inst_date == previous_date and instance.end > midnight and instance.end > ongoing_cutoff:
                                ongoing_expanded.append(instance)

                all_events = day_events + expanded_events + ongoing_events + ongoing_expanded
                all_events.sort(key=lambda x: x.start)
                event_list = [serialize_event(event) for event in all_events]

                if use_cache:
                    set_cached_day_events(date, event_list)
            
            response = jsonify(event_list)
            return set_cache_headers(response, max_age=300)  # Cache for 5 minutes
        
        # Calendar widget request (date range)
        start = request.args.get('start')
        end = request.args.get('end')
        if not start or not end:
            return jsonify({'error': 'start and end query parameters are required'}), 400
        try:
            start_date = datetime.fromisoformat(start.replace('Z', '+00:00'))
            end_date = datetime.fromisoformat(end.replace('Z', '+00:00'))
        except (ValueError, TypeError, AttributeError):
            return jsonify({'error': 'Invalid start or end datetime'}), 400
        
        # Check cache first for calendar range (anonymous only)
        use_cache = not flask_session.get('logged_in')
        start_str = start_date.date().isoformat()
        end_str = end_date.date().isoformat()
        cached_calendar = get_cached_calendar_events(start_str, end_str) if use_cache else None
        
        if cached_calendar is not None:
            event_list = cached_calendar
        else:
            with get_db_session() as session:
                # PK range seek: filter by start_date only, then drop recurring in Python
                range_rows = session.query(Event).filter(
                    Event.start_date >= start_date.date(),
                    Event.start_date <= end_date.date()
                ).options(joinedload(Event.venue)).all()
                non_recurring = [e for e in range_rows if not e.is_recurring]

                recurring = session.query(Event).filter(
                    Event.is_recurring == True,
                    Event.start_date <= end_date.date(),
                    (Event.recurring_until == None) | (Event.recurring_until >= start_date.date())
                ).options(joinedload(Event.venue)).all()
                
                expanded_events = []
                for event in recurring:
                    expanded_events.extend(expand_recurring_events(event, start_date, end_date))
                
                all_events = non_recurring + expanded_events
                all_events.sort(key=lambda x: x.start)
                event_list = [serialize_event(event, slim=True) for event in all_events]
                
                if use_cache:
                    set_cached_calendar_events(start_str, end_str, event_list)
        
        response = jsonify(event_list)
        return set_cache_headers(response, max_age=300)  # Cache for 5 minutes

    def venue_to_dict(venue):
        return {
            'id': venue.id,
            'name': venue.name,
            'address': venue.address,
            'neighborhood': venue.neighborhood,
            'venue_type': venue.venue_type,
        }

    @app.route('/venues')
    def list_venues():
        neighborhood = request.args.get('neighborhood', '').strip()
        venue_type = request.args.get('venue_type', '').strip()

        with get_db_session() as session:
            query = session.query(Venue)

            if neighborhood:
                query = query.filter(Venue.neighborhood == neighborhood)
            if venue_type:
                query = query.filter(Venue.venue_type == venue_type)

            venues = query.order_by(Venue.venue_type, Venue.name).all()
            venue_list = [venue_to_dict(v) for v in venues]

        response = jsonify(venue_list)
        return set_cache_headers(response, max_age=300)

    @app.route('/venues/<int:id>')
    def venue_detail(id):
        with get_db_session() as session:
            venue = session.query(Venue).filter(Venue.id == id).first()
            if not venue:
                abort(404)
            upcoming_events = get_upcoming_events_for_venue(session, id)
            map_embed_url, map_is_fallback = get_venue_map_embed(venue)
            return render_template(
                'venue_detail.html',
                venue=venue,
                upcoming_events=upcoming_events,
                map_embed_url=map_embed_url,
                map_is_fallback=map_is_fallback,
                debug_event_url='https://thedetroitilove.com',
            )

    @app.route('/event/new', methods=['GET', 'POST'])
    @login_required
    def add_event():
        if request.method == 'POST':
            title = request.form['title']
            description = request.form['description']
            start = datetime.fromisoformat(request.form['start'])
            end = datetime.fromisoformat(request.form['end'])
            rrule_str = request.form.get('rrule')
            venue_id = request.form.get('venue_id')
            color = request.form.get('color', '#3788d8')
            bg = request.form.get('bg', '#3788d8')
            url = safe_http_url(request.form.get('url', ''))

            normalized_rrule, rrule_error = validate_rrule(rrule_str, dtstart=start)
            if rrule_error:
                flash(f'Invalid recurrence rule: {rrule_error}', 'error')
                with get_db_session() as session:
                    venues = get_form_venues(session)
                    categories = session.query(Category).filter(Category.is_active == True).order_by(Category.usage_count.desc(), Category.name).all()
                    return render_template(
                        'event_form.html',
                        venues=venues,
                        categories=categories,
                        title=title,
                        description=description,
                        start=start,
                        end=end,
                        rrule=rrule_str or '',
                        color=color,
                        bg=bg,
                        url=url or '',
                        recurring_until=request.form.get('recurring_until', '').strip(),
                    )
            
            # Get recurring event fields
            recurring_until_str = request.form.get('recurring_until', '').strip()
            recurring_until = None
            if recurring_until_str:
                try:
                    recurring_until = datetime.strptime(recurring_until_str, '%Y-%m-%d').date()
                except ValueError:
                    # If invalid date, use default
                    pass
            
            # Get category IDs from form
            category_ids = request.form.getlist('category_ids')
            
            # Convert category IDs to category names
            categories_str = ','.join(category_ids) if category_ids else ''
            
            with get_db_session() as session:
                # Validate venue_id
                if not venue_id:
                    flash('Please select a venue', 'error')
                    venues = get_form_venues(session)
                    categories = session.query(Category).filter(Category.is_active == True).order_by(Category.usage_count.desc(), Category.name).all()
                    return render_template('event_form.html', 
                                        venues=venues,
                                        categories=categories,
                                        title=title,
                                        description=description,
                                        start=start,
                                        end=end,
                                        rrule=rrule_str,
                                        color=color,
                                        bg=bg,
                                        url=url or '',
                                        recurring_until=recurring_until_str)
                
                # Determine if this is a recurring event
                is_recurring = bool(normalized_rrule)
                
                # If recurring and no end date specified, use default (2 years from start)
                if is_recurring and not recurring_until:
                    recurring_until = start.date().replace(year=start.date().year + 2)
                
                event = Event(
                    title=title, 
                    description=description, 
                    start=start, 
                    end=end,
                    rrule=normalized_rrule, 
                    venue_id=venue_id, 
                    color=color, 
                    bg=bg,
                    is_recurring=is_recurring,
                    recurring_until=recurring_until,
                    is_virtual=False,
                    is_hybrid=False,
                    url=url,
                    categories=categories_str
                )
                
                # Generate ID for the new event based on its date
                event.id = get_next_event_id(session, event.start_date)
                
                session.add(event)
                session.commit()
            
            # Clear cache since we added a new event
            clear_day_events_cache()
            clear_calendar_events_cache()
            
            return redirect(url_for('home'))
        
        with get_db_session() as session:
            venues = get_form_venues(session)
            categories = session.query(Category).filter(Category.is_active == True).order_by(Category.usage_count.desc(), Category.name).all()
            return render_template('event_form.html', venues=venues, categories=categories)

    @app.route('/event/<start_date>/<int:id>/edit', methods=['GET', 'POST'])
    @login_required
    def edit_event(start_date, id):
        try:
            event_date = datetime.strptime(start_date, '%Y-%m-%d').date()
        except ValueError:
            flash('Invalid event date', 'error')
            return redirect(url_for('home'))

        if request.method == 'POST':
            title = request.form['title']
            description = request.form['description']
            start = datetime.fromisoformat(request.form['start'])
            end = datetime.fromisoformat(request.form['end'])
            rrule_str = request.form.get('rrule')
            venue_id = request.form.get('venue_id')
            color = request.form.get('color', '#3788d8')
            bg = request.form.get('bg', '#3788d8')
            url = safe_http_url(request.form.get('url', ''))

            normalized_rrule, rrule_error = validate_rrule(rrule_str, dtstart=start)
            if rrule_error:
                flash(f'Invalid recurrence rule: {rrule_error}', 'error')
                with get_db_session() as session:
                    event = session.query(Event).filter(
                        Event.start_date == event_date,
                        Event.id == id
                    ).first()
                    if not event:
                        abort(404)
                    venues = get_form_venues(session)
                    categories = session.query(Category).filter(Category.is_active == True).order_by(Category.usage_count.desc(), Category.name).all()
                    return render_template(
                        'event_form.html',
                        event=event,
                        venues=venues,
                        categories=categories,
                        rrule=rrule_str or '',
                    )
            
            # Get recurring event fields
            recurring_until_str = request.form.get('recurring_until', '').strip()
            recurring_until = None
            if recurring_until_str:
                try:
                    recurring_until = datetime.strptime(recurring_until_str, '%Y-%m-%d').date()
                except ValueError:
                    # If invalid date, use default
                    pass
            
            # Get category IDs from form
            category_ids = request.form.getlist('category_ids')
            
            # Convert category IDs to category names
            categories_str = ','.join(category_ids) if category_ids else ''
            
            with get_db_session() as session:
                event = session.query(Event).filter(
                    Event.start_date == event_date,
                    Event.id == id
                ).first()
                if not event:
                    abort(404)
                
                # Validate venue_id
                if not venue_id:
                    flash('Please select a venue', 'error')
                    venues = get_form_venues(session)
                    categories = session.query(Category).filter(Category.is_active == True).order_by(Category.usage_count.desc(), Category.name).all()
                    return render_template('event_form.html', 
                                        event=event,
                                        venues=venues,
                                        categories=categories,
                                        title=title,
                                        description=description,
                                        start=start,
                                        end=end,
                                        rrule=rrule_str,
                                        color=color,
                                        bg=bg,
                                        url=url or '',
                                        recurring_until=recurring_until_str)
                
                # Determine if this is a recurring event
                is_recurring = bool(normalized_rrule)
                
                # If recurring and no end date specified, use default (2 years from start)
                if is_recurring and not recurring_until:
                    recurring_until = start.date().replace(year=start.date().year + 2)

                new_date = start.date()
                if event.start_date != new_date:
                    # Composite PK includes start_date — recreate row for the new day
                    new_event = Event(
                        title=title,
                        description=description,
                        start=start,
                        end=end,
                        rrule=normalized_rrule,
                        venue_id=venue_id,
                        color=color,
                        bg=bg,
                        is_recurring=is_recurring,
                        recurring_until=recurring_until,
                        is_virtual=event.is_virtual,
                        is_hybrid=event.is_hybrid,
                        url=url,
                        categories=categories_str,
                    )
                    new_event.id = get_next_event_id(session, new_date)
                    session.delete(event)
                    session.add(new_event)
                else:
                    event.title = title
                    event.description = description
                    event.start = start
                    event.end = end
                    event.start_date = new_date
                    event.rrule = normalized_rrule
                    event.venue_id = venue_id
                    event.color = color
                    event.bg = bg
                    event.is_recurring = is_recurring
                    event.recurring_until = recurring_until
                    event.url = url
                    event.categories = categories_str
                
                session.commit()
            
            # Clear cache since we modified an event
            clear_day_events_cache()
            clear_calendar_events_cache()
            
            return redirect(url_for('home'))
        
        with get_db_session() as session:
            event = session.query(Event).filter(
                Event.start_date == event_date,
                Event.id == id
            ).first()
            if not event:
                abort(404)
            venues = get_form_venues(session)
            categories = session.query(Category).filter(Category.is_active == True).order_by(Category.usage_count.desc(), Category.name).all()
            return render_template('event_form.html', event=event, venues=venues, categories=categories)

    @app.route('/event/<start_date>/<int:id>/delete', methods=['POST'])
    @login_required
    def delete_event(start_date, id):
        try:
            event_date = datetime.strptime(start_date, '%Y-%m-%d').date()
        except ValueError:
            flash('Invalid event date', 'error')
            return redirect(url_for('home'))

        with get_db_session() as session:
            event = session.query(Event).filter(
                Event.start_date == event_date,
                Event.id == id
            ).first()
            if not event:
                abort(404)
            session.delete(event)
            session.commit()
        
        # Clear cache since we deleted an event
        clear_day_events_cache()
        clear_calendar_events_cache()
        
        return redirect(url_for('home'))

    def set_cache_headers(response, max_age=3600):
        """Set cache headers; skip browser caching for logged-in admins."""
        if flask_session.get('logged_in'):
            response.headers['Cache-Control'] = 'private, no-store'
        else:
            response.headers['Cache-Control'] = f'public, max-age={max_age}'
        response.headers['Vary'] = 'Accept-Encoding, Cookie'
        return response

    def get_local_now():
        """Get current datetime in local timezone"""
        utc_now = datetime.now(pytz.UTC)
        return utc_now.astimezone(LOCAL_TIMEZONE)