events/bp/day/routes.py

from __future__ import annotations
from datetime import datetime, timezone, date, timedelta

from quart import (
    request, render_template, make_response, Blueprint, g, abort, session as qsession
)

from bp.calendar.services import get_visible_entries_for_period

from bp.calendar_entries.routes import register as register_calendar_entries
from .admin.routes import register as register_admin

from shared.browser.app.redis_cacher import cache_page
from shared.services.widget_registry import widgets

from models.calendars import CalendarSlot  # add this import

from sqlalchemy import select

from shared.browser.app.utils.htmx import is_htmx_request


def register():
    bp = Blueprint("day", __name__, url_prefix='/day/<int:year>/<int:month>/<int:day>')

    bp.register_blueprint(
        register_calendar_entries()
    )
    bp.register_blueprint(
        register_admin()
    )

    @bp.context_processor
    async def inject_root():
        view_args = getattr(request, "view_args", {}) or {}
        day = view_args.get("day")
        month = view_args.get("month")
        year = view_args.get("year")

        calendar = getattr(g, "calendar", None)
        if not calendar:
            return {}

        try:
            day_date = date(year, month, day)
        except (ValueError, TypeError):
            return {}

        # Period: this day only
        period_start = datetime(year, month, day, tzinfo=timezone.utc)
        period_end = period_start + timedelta(days=1)

        # Identity & admin flag
        user = getattr(g, "user", None)
        session_id = qsession.get("calendar_sid")

        visible = await get_visible_entries_for_period(
            sess=g.s,
            calendar_id=calendar.id,
            period_start=period_start,
            period_end=period_end,
            user=user,
            session_id=session_id,
        )

        # --- NEW: slots for this weekday ---
        weekday_attr = ["mon","tue","wed","thu","fri","sat","sun"][day_date.weekday()]

        stmt = (
            select(CalendarSlot)
            .where(
                CalendarSlot.calendar_id == calendar.id,
                getattr(CalendarSlot, weekday_attr) == True,  # noqa: E712
                CalendarSlot.deleted_at.is_(None),
            )
            .order_by(CalendarSlot.time_start.asc(), CalendarSlot.id.asc())
        )
        result = await g.s.execute(stmt)
        day_slots = list(result.scalars())

        # Widget-driven container nav (market links, etc.)
        container_nav_loaded = []
        post_data = getattr(g, "post_data", None)
        if post_data:
            post_id = post_data["post"]["id"]
            post_slug = post_data["post"]["slug"]
            for w in widgets.container_nav:
                if w.domain.startswith("calendar"):
                    continue  # skip — we're already on a calendar page
                try:
                    wctx = await w.context_fn(
                        g.s, container_type="page", container_id=post_id,
                        post_slug=post_slug,
                    )
                    has_data = any(v for v in wctx.values() if isinstance(v, list) and v)
                    if has_data:
                        container_nav_loaded.append({"widget": w, "ctx": wctx})
                except Exception:
                    pass

        return {
            "qsession": qsession,
            "day_date": day_date,
            "day": day,
            "year": year,
            "month": month,
            "day_entries": visible.merged_entries,
            "user_entries": visible.user_entries,
            "confirmed_entries": visible.confirmed_entries,
            "day_slots": day_slots,
            "container_nav_widgets": container_nav_loaded,
        }


    
    @bp.get("/")
    @cache_page(tag="calendars")
    async def show_day(year: int, month: int, day: int, **kwargs):
        """
        Show a detail view for a single calendar day.

        Visibility rules:
        - Non-admin:
            - all *confirmed* entries for that day (any user)
            - all entries for current user/session (any state) for that day
              (pending/ordered/provisional/confirmed)
        - Admin:
            - all confirmed + provisional + ordered entries for that day (all users)
            - pending only for current user/session
        """
        if not is_htmx_request():
          # Normal browser request: full page with layout
          html = await render_template(
            "_types/day/index.html",
            )
        else:
            
            html = await render_template(
              "_types/day/_oob_elements.html",
            )
        return await make_response(html)

    @bp.get("/w/<widget_domain>/")
    async def widget_paginate(widget_domain: str, **kwargs):
        """Generic paginated widget endpoint for infinite scroll."""
        page = int(request.args.get("page", 1))
        post_data = getattr(g, "post_data", None)
        if not post_data:
            abort(404)
        post_id = post_data["post"]["id"]
        post_slug = post_data["post"]["slug"]
        for w in widgets.container_nav:
            if w.domain == widget_domain:
                ctx = await w.context_fn(
                    g.s, container_type="page", container_id=post_id,
                    post_slug=post_slug, page=page,
                )
                html = await render_template(
                    w.template, ctx=ctx, post=post_data["post"],
                )
                return await make_response(html)
        abort(404)

    return bp