kitchen/backend/api/budget.py

"""
Budget API endpoints for Spend Budget feature.

Calculates spending budgets based on forecasted revenue and target GP%,
allocated to suppliers based on their historical spending percentage.
"""
from datetime import date, timedelta
from decimal import Decimal
from typing import Optional
from collections import defaultdict
import logging

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, func, case, and_, or_, text
from sqlalchemy.orm import selectinload
from pydantic import BaseModel, field_serializer

from database import get_db
from models.user import User
from models.invoice import Invoice, InvoiceStatus
from models.supplier import Supplier
from models.line_item import LineItem
from models.settings import KitchenSettings
from models.purchase_order import PurchaseOrder
from models.cost_distribution import CostDistribution, CostDistributionEntry, DistributionStatus
from auth import get_current_user, require_cap
from services.forecast_api import ForecastAPIClient, ForecastAPIError

logger = logging.getLogger(__name__)

router = APIRouter()


# Response Models

class BudgetInvoice(BaseModel):
    """Individual invoice in budget table"""
    id: int
    invoice_number: Optional[str]
    invoice_date: Optional[date]
    net_stock: Decimal
    document_type: Optional[str] = None

    @field_serializer('net_stock')
    def serialize_net_stock(self, v: Decimal) -> float:
        return float(v)


class BudgetPOItem(BaseModel):
    """Individual PO in budget table"""
    id: int
    order_type: str
    status: str
    total_amount: Optional[Decimal]
    order_reference: Optional[str]

    @field_serializer('total_amount')
    def serialize_total(self, v: Optional[Decimal]) -> Optional[float]:
        return float(v) if v is not None else None


class SupplierBudgetRow(BaseModel):
    """Supplier row in weekly budget table"""
    supplier_id: Optional[int]
    supplier_name: str
    historical_pct: Decimal  # 4-week average percentage
    allocated_budget: Decimal  # total_budget * historical_pct
    invoices_by_date: dict[str, list[BudgetInvoice]]  # date -> invoices
    purchase_orders_by_date: dict[str, list[BudgetPOItem]]  # date -> POs
    actual_spent: Decimal  # Sum of invoices this week (excluding CD)
    cd_adjustments_by_date: dict[str, float] = {}  # date -> CD +/- for this supplier
    cd_total: float = 0  # Total CD adjustment for this supplier
    po_ordered: Decimal  # Sum of pending PO totals this week
    remaining: Decimal  # allocated - (spent + cd) - po_ordered
    status: str  # "under", "on_track", "over"

    @field_serializer('historical_pct', 'allocated_budget', 'actual_spent', 'po_ordered', 'remaining')
    def serialize_decimals(self, v: Decimal) -> float:
        return float(v)


class DailyBudgetData(BaseModel):
    """Daily budget tracking data"""
    date: date
    day_name: str
    forecast_revenue: Decimal
    budget_split_pct: Decimal  # % of weekly budget this day gets (from historical spend)
    historical_budget: Decimal  # Budget allocated based on historical spend patterns
    revenue_budget: Decimal  # Budget allocated based on forecast revenue proportion
    actual_spent: Optional[Decimal]  # Only for past/today
    cumulative_budget: Decimal
    cumulative_spent: Optional[Decimal]

    @field_serializer('forecast_revenue', 'budget_split_pct', 'historical_budget', 'revenue_budget', 'cumulative_budget')
    def serialize_decimals(self, v: Decimal) -> float:
        return float(v)

    @field_serializer('actual_spent', 'cumulative_spent')
    def serialize_optional_decimals(self, v: Optional[Decimal]) -> Optional[float]:
        return float(v) if v is not None else None


class CoversSummary(BaseModel):
    """Covers summary for a meal period"""
    otb: int
    pickup: int
    forecast: int


class DailyCoverData(BaseModel):
    """Daily covers breakdown for a single day"""
    date: date
    day_name: str
    otb_rooms: int = 0
    pickup_rooms: int = 0
    otb_guests: int = 0
    pickup_guests: int = 0
    breakfast: CoversSummary = CoversSummary(otb=0, pickup=0, forecast=0)
    lunch: CoversSummary = CoversSummary(otb=0, pickup=0, forecast=0)
    dinner: CoversSummary = CoversSummary(otb=0, pickup=0, forecast=0)


class ForecastSummary(BaseModel):
    """Weekly forecast summary for rooms and covers"""
    otb_rooms: int = 0
    pickup_rooms: int = 0
    forecast_rooms: int = 0
    otb_guests: int = 0
    pickup_guests: int = 0
    forecast_guests: int = 0
    breakfast: CoversSummary = CoversSummary(otb=0, pickup=0, forecast=0)
    lunch: CoversSummary = CoversSummary(otb=0, pickup=0, forecast=0)
    dinner: CoversSummary = CoversSummary(otb=0, pickup=0, forecast=0)
    daily_covers: list[DailyCoverData] = []


class WeeklyBudgetResponse(BaseModel):
    """Response for weekly budget endpoint"""
    week_start: date
    week_end: date
    dates: list[date]  # All 7 days of the week

    # Forecast data
    otb_revenue: Decimal  # On The Books revenue (current bookings only)
    forecast_revenue: Decimal  # Full forecast revenue (OTB + expected pickup)
    forecast_source: str  # "forecast_api" or "fallback"

    # Forecast summary (rooms + covers)
    forecast_summary: Optional[ForecastSummary] = None

    # Override info
    has_overrides: bool = False
    snapshot_revenue: Optional[Decimal] = None  # Original snapshotted revenue
    adjusted_revenue: Optional[Decimal] = None  # Revenue after applying overrides

    # Budget calculation
    gp_target_pct: Decimal  # e.g., 65.00
    min_budget: Decimal  # Minimum budget based on OTB only
    total_budget: Decimal  # Full budget based on forecast

    # Actuals
    total_spent: Decimal  # Actual spend from confirmed invoices
    total_po_ordered: Decimal  # Sum of pending PO totals
    total_remaining: Decimal  # budget - spent - po_ordered (negative = overspend)
    cd_budget_reservation: Decimal = Decimal("0")  # Budget reserved for cost distributions

    # Supplier breakdown
    suppliers: list[SupplierBudgetRow]
    all_supplier_names: list[str]

    # Daily breakdown
    daily_data: list[DailyBudgetData]
    daily_totals: dict[str, Decimal]  # date -> actual spend

    @field_serializer('otb_revenue', 'forecast_revenue', 'gp_target_pct', 'min_budget', 'total_budget', 'total_spent', 'total_po_ordered', 'total_remaining', 'cd_budget_reservation')
    def serialize_decimals(self, v: Decimal) -> float:
        return float(v)

    @field_serializer('snapshot_revenue', 'adjusted_revenue')
    def serialize_optional_revenue(self, v: Optional[Decimal]) -> Optional[float]:
        return float(v) if v is not None else None

    @field_serializer('daily_totals')
    def serialize_daily_totals(self, v: dict[str, Decimal]) -> dict[str, float]:
        return {k: float(val) for k, val in v.items()}


class BudgetSettingsResponse(BaseModel):
    """Budget settings response"""
    forecast_api_url: Optional[str]
    forecast_api_configured: bool
    budget_gp_target: Decimal
    budget_lookback_weeks: int

    @field_serializer('budget_gp_target')
    def serialize_gp_target(self, v: Decimal) -> float:
        return float(v)


class BudgetSettingsUpdate(BaseModel):
    """Budget settings update request"""
    forecast_api_url: Optional[str] = None
    forecast_api_key: Optional[str] = None
    budget_gp_target: Optional[Decimal] = None
    budget_lookback_weeks: Optional[int] = None


class TestConnectionResponse(BaseModel):
    """Response for forecast API connection test"""
    success: bool
    message: str


# Helper Functions

async def get_settings(db: AsyncSession, kitchen_id: int) -> KitchenSettings:
    """Get kitchen settings, creating if not exists"""
    result = await db.execute(
        select(KitchenSettings).where(KitchenSettings.kitchen_id == kitchen_id)
    )
    settings = result.scalar_one_or_none()

    if not settings:
        settings = KitchenSettings(kitchen_id=kitchen_id)
        db.add(settings)
        await db.commit()
        await db.refresh(settings)

    return settings


async def get_historical_supplier_percentages(
    db: AsyncSession,
    kitchen_id: int,
    lookback_start: date,
    lookback_end: date
) -> list[tuple[int | None, str, Decimal]]:
    """
    Calculate supplier spend percentages over the lookback period.

    Returns list of (supplier_id, supplier_name, percentage) sorted by percentage desc.
    """
    # Build subquery to sum per invoice first (for credit note handling)
    invoice_stock_subq = (
        select(
            Invoice.id.label('inv_id'),
            Invoice.supplier_id.label('supplier_id'),
            Invoice.document_type.label('doc_type'),
            func.sum(LineItem.amount).label('stock_total')
        )
        .join(Invoice, LineItem.invoice_id == Invoice.id)
        .where(
            Invoice.kitchen_id == kitchen_id,
            Invoice.invoice_date >= lookback_start,
            Invoice.invoice_date <= lookback_end,
            Invoice.status == InvoiceStatus.CONFIRMED,
            LineItem.amount.isnot(None),
            or_(LineItem.is_non_stock == False, LineItem.is_non_stock.is_(None))
        )
        .group_by(Invoice.id, Invoice.supplier_id, Invoice.document_type)
        .subquery()
    )

    # Get total for period
    total_result = await db.execute(
        select(func.sum(
            case(
                (and_(invoice_stock_subq.c.doc_type == 'credit_note',
                      invoice_stock_subq.c.stock_total > 0),
                 -invoice_stock_subq.c.stock_total),
                else_=invoice_stock_subq.c.stock_total
            )
        ))
        .select_from(invoice_stock_subq)
    )
    total_spend = total_result.scalar() or Decimal("0")

    if total_spend <= 0:
        return []

    # Get supplier breakdown
    supplier_result = await db.execute(
        select(
            invoice_stock_subq.c.supplier_id,
            Supplier.name,
            func.sum(
                case(
                    (and_(invoice_stock_subq.c.doc_type == 'credit_note',
                          invoice_stock_subq.c.stock_total > 0),
                     -invoice_stock_subq.c.stock_total),
                    else_=invoice_stock_subq.c.stock_total
                )
            ).label('net_total')
        )
        .select_from(invoice_stock_subq)
        .outerjoin(Supplier, invoice_stock_subq.c.supplier_id == Supplier.id)
        .group_by(invoice_stock_subq.c.supplier_id, Supplier.name)
        .order_by(func.sum(
            case(
                (and_(invoice_stock_subq.c.doc_type == 'credit_note',
                      invoice_stock_subq.c.stock_total > 0),
                 -invoice_stock_subq.c.stock_total),
                else_=invoice_stock_subq.c.stock_total
            )
        ).desc())
    )

    result = []
    for supplier_id, supplier_name, net_total in supplier_result.all():
        if net_total and net_total != 0:
            pct = (net_total / total_spend * 100)
            result.append((
                supplier_id,
                supplier_name or "Unmatched",
                round(pct, 2)
            ))

    return result


async def get_historical_daily_distribution(
    db: AsyncSession,
    kitchen_id: int,
    lookback_start: date,
    lookback_end: date
) -> dict[int, Decimal]:
    """
    Calculate historical spend distribution by day of week.

    Returns dict of weekday (0=Mon, 6=Sun) -> percentage of weekly spend
    """
    # Get all confirmed invoices in the lookback period with their totals
    invoice_subq = (
        select(
            Invoice.id.label('inv_id'),
            Invoice.invoice_date.label('inv_date'),
            Invoice.document_type.label('doc_type'),
            func.sum(LineItem.amount).label('stock_total')
        )
        .join(Invoice, LineItem.invoice_id == Invoice.id)
        .where(
            Invoice.kitchen_id == kitchen_id,
            Invoice.invoice_date >= lookback_start,
            Invoice.invoice_date <= lookback_end,
            Invoice.status == InvoiceStatus.CONFIRMED,
            LineItem.amount.isnot(None),
            or_(LineItem.is_non_stock == False, LineItem.is_non_stock.is_(None))
        )
        .group_by(Invoice.id, Invoice.invoice_date, Invoice.document_type)
        .subquery()
    )

    # Get spend by day
    result = await db.execute(
        select(
            invoice_subq.c.inv_date,
            func.sum(
                case(
                    (and_(invoice_subq.c.doc_type == 'credit_note',
                          invoice_subq.c.stock_total > 0),
                     -invoice_subq.c.stock_total),
                    else_=invoice_subq.c.stock_total
                )
            ).label('net_total')
        )
        .select_from(invoice_subq)
        .group_by(invoice_subq.c.inv_date)
    )

    # Aggregate by day of week
    weekday_totals: dict[int, Decimal] = {i: Decimal("0") for i in range(7)}
    total_spend = Decimal("0")

    for inv_date, net_total in result.all():
        if inv_date and net_total:
            weekday = inv_date.weekday()  # 0=Monday, 6=Sunday
            weekday_totals[weekday] += Decimal(str(net_total))
            total_spend += Decimal(str(net_total))

    # Convert to percentages
    if total_spend > 0:
        return {day: (amount / total_spend * 100).quantize(Decimal("0.01"))
                for day, amount in weekday_totals.items()}
    else:
        # Default to even distribution if no historical data
        return {i: Decimal("14.29") for i in range(7)}


async def get_weekly_invoices_by_supplier(
    db: AsyncSession,
    kitchen_id: int,
    week_start: date,
    week_end: date
) -> dict[tuple[int | None, str], list[dict]]:
    """
    Get all confirmed invoices for the week grouped by supplier.

    Returns dict of (supplier_id, supplier_name) -> list of invoice data
    """
    # Get all confirmed invoices for the week with line items
    result = await db.execute(
        select(Invoice)
        .where(
            Invoice.kitchen_id == kitchen_id,
            Invoice.status == InvoiceStatus.CONFIRMED,
            Invoice.invoice_date >= week_start,
            Invoice.invoice_date <= week_end,
        )
        .options(selectinload(Invoice.line_items))
        .order_by(Invoice.invoice_date)
    )
    invoices = result.scalars().all()

    # Get supplier names
    supplier_result = await db.execute(
        select(Supplier).where(Supplier.kitchen_id == kitchen_id)
    )
    suppliers_map = {s.id: s.name for s in supplier_result.scalars().all()}

    # Group invoices by supplier
    supplier_invoices: dict[tuple[int | None, str], list[dict]] = defaultdict(list)

    for inv in invoices:
        # Calculate net stock for this invoice
        net_stock = Decimal("0")
        if inv.line_items:
            for item in inv.line_items:
                if not (item.is_non_stock or False):
                    net_stock += item.amount or Decimal("0")

        # Handle credit notes
        if inv.document_type == 'credit_note' and net_stock > 0:
            net_stock = -net_stock

        # Skip invoices with no stock value (non-stock only invoices)
        if net_stock == 0:
            continue

        # Get supplier key
        if inv.supplier_id:
            supplier_name = suppliers_map.get(inv.supplier_id, "Unknown")
            key = (inv.supplier_id, supplier_name)
        else:
            vendor = inv.vendor_name or "Unknown Supplier"
            key = (None, vendor)

        supplier_invoices[key].append({
            "id": inv.id,
            "invoice_number": inv.invoice_number,
            "invoice_date": inv.invoice_date,
            "net_stock": net_stock,
            "document_type": inv.document_type,
        })

    return supplier_invoices


# API Endpoints

@router.get("/weekly", response_model=WeeklyBudgetResponse)
async def get_weekly_budget(
    week_offset: int = 0,  # 0 = current week, -1 = last week, etc.
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """
    Get weekly budget breakdown with supplier allocations.

    week_offset: 0 = current week (Mon-Sun), -1 = previous week, etc.
    """
    # Calculate week dates (Mon-Sun)
    today = date.today()
    current_monday = today - timedelta(days=today.weekday())
    week_start = current_monday + timedelta(weeks=week_offset)
    week_end = week_start + timedelta(days=6)
    week_dates = [week_start + timedelta(days=i) for i in range(7)]

    # Get settings
    settings = await get_settings(db, current_user.kitchen_id)

    # Get forecast revenue + rooms + covers
    otb_revenue = Decimal("0")
    forecast_revenue = Decimal("0")
    forecast_source = "fallback"
    forecast_data = None  # Keep the daily forecast data
    forecast_summary = None

    api_spend_rates = {}  # spend rates from API for override recalculation
    covers_data_raw = []  # raw covers data from API for override recalculation

    if settings.forecast_api_url and settings.forecast_api_key:
        try:
            async with ForecastAPIClient(
                settings.forecast_api_url,
                settings.forecast_api_key
            ) as client:
                forecast_data = await client.get_revenue_forecast(week_start, days=7)
                otb_revenue, forecast_revenue = client.calculate_food_revenue(forecast_data)
                forecast_source = "forecast_api"
                logger.info(f"Fetched revenue - OTB: {otb_revenue}, Forecast: {forecast_revenue}")

                # Fetch rooms and covers for summary banner
                try:
                    rooms_data = await client.get_rooms_forecast(week_start, days=7)
                    covers_data = await client.get_covers_forecast(week_start, days=7)
                    covers_data_raw = covers_data  # Save for override recalculation
                    rooms_agg = client.aggregate_rooms(rooms_data)
                    covers_agg = client.aggregate_covers(covers_data)

                    # Index rooms data by date for matching
                    rooms_by_date = {d.get("date", ""): d for d in rooms_data}

                    # Build daily covers breakdown
                    daily_covers_list = []
                    for day in covers_data:
                        day_date_str = day.get("date", "")
                        day_name = day.get("day", "")
                        room_day = rooms_by_date.get(day_date_str, {})
                        daily_covers_list.append(DailyCoverData(
                            date=day_date_str,
                            day_name=day_name,
                            otb_rooms=room_day.get("otb_rooms", 0) or 0,
                            pickup_rooms=(room_day.get("forecast_rooms", 0) or 0) - (room_day.get("otb_rooms", 0) or 0),
                            otb_guests=room_day.get("otb_guests", 0) or 0,
                            pickup_guests=(room_day.get("forecast_guests", 0) or 0) - (room_day.get("otb_guests", 0) or 0),
                            breakfast=CoversSummary(
                                otb=day.get("breakfast", {}).get("otb", 0) or 0,
                                pickup=(day.get("breakfast", {}).get("forecast", 0) or 0) - (day.get("breakfast", {}).get("otb", 0) or 0),
                                forecast=day.get("breakfast", {}).get("forecast", 0) or 0,
                            ),
                            lunch=CoversSummary(
                                otb=day.get("lunch", {}).get("otb", 0) or 0,
                                pickup=(day.get("lunch", {}).get("forecast", 0) or 0) - (day.get("lunch", {}).get("otb", 0) or 0),
                                forecast=day.get("lunch", {}).get("forecast", 0) or 0,
                            ),
                            dinner=CoversSummary(
                                otb=day.get("dinner", {}).get("otb", 0) or 0,
                                pickup=(day.get("dinner", {}).get("forecast", 0) or 0) - (day.get("dinner", {}).get("otb", 0) or 0),
                                forecast=day.get("dinner", {}).get("forecast", 0) or 0,
                            ),
                        ))

                    forecast_summary = ForecastSummary(
                        otb_rooms=rooms_agg["otb_rooms"],
                        pickup_rooms=rooms_agg["pickup_rooms"],
                        forecast_rooms=rooms_agg["forecast_rooms"],
                        otb_guests=rooms_agg["otb_guests"],
                        pickup_guests=rooms_agg["pickup_guests"],
                        forecast_guests=rooms_agg["forecast_guests"],
                        breakfast=CoversSummary(**covers_agg["breakfast"]),
                        lunch=CoversSummary(**covers_agg["lunch"]),
                        dinner=CoversSummary(**covers_agg["dinner"]),
                        daily_covers=daily_covers_list,
                    )
                except Exception as e:
                    logger.warning(f"Failed to fetch rooms/covers forecast: {e}")

                # Fetch spend rates for override recalculation
                try:
                    sr_response = await client.get_spend_rates()
                    api_spend_rates = sr_response.get("periods", {})
                except Exception as e:
                    logger.warning(f"Failed to fetch spend rates: {e}")
        except ForecastAPIError as e:
            logger.warning(f"Failed to fetch forecast: {e.message}")
            forecast_data = None

    # Calculate budgets
    gp_target = settings.budget_gp_target or Decimal("65.00")
    cost_target_pct = (100 - gp_target) / 100
    min_budget = (otb_revenue * cost_target_pct).quantize(Decimal("0.01"))
    total_budget = (forecast_revenue * cost_target_pct).quantize(Decimal("0.01"))

    # --- Apply cover/spend rate overrides to adjust forecast revenue ---
    has_overrides_flag = False
    snapshot_revenue_val = None
    adjusted_revenue_val = None
    adjusted_daily = {}  # date_str -> adjusted revenue for daily breakdown

    if forecast_source == "forecast_api":
        # Check if a forecast snapshot exists for this week
        week_snap_result = await db.execute(text("""
            SELECT total_forecast_revenue FROM forecast_week_snapshots
            WHERE kitchen_id = :kid AND week_start = :ws
        """), {"kid": current_user.kitchen_id, "ws": week_start})
        week_snap = week_snap_result.fetchone()

        if week_snap:
            snapshot_revenue_val = Decimal(str(week_snap.total_forecast_revenue)) if week_snap.total_forecast_revenue else None
            has_overrides_flag = True

            # Only recalculate if we have live covers data
            if covers_data_raw:
                # Load cover overrides for this week
                ovr_result = await db.execute(text("""
                    SELECT override_date, period, override_covers
                    FROM cover_overrides
                    WHERE kitchen_id = :kid AND override_date >= :ws AND override_date <= :we
                """), {"kid": current_user.kitchen_id, "ws": week_start, "we": week_end})
                override_lookup = {}
                for row in ovr_result.fetchall():
                    override_lookup[(row.override_date.isoformat(), row.period)] = row.override_covers

                # Load snapshot spend rates
                snap_spend_result = await db.execute(text("""
                    SELECT snapshot_date, period, food_spend, drinks_spend
                    FROM forecast_snapshots
                    WHERE kitchen_id = :kid AND week_start = :ws
                """), {"kid": current_user.kitchen_id, "ws": week_start})
                snap_spend_lookup = {}
                for row in snap_spend_result.fetchall():
                    snap_spend_lookup[(row.snapshot_date.isoformat(), row.period)] = row

                # Load spend rate overrides
                spend_ovr_result = await db.execute(text("""
                    SELECT period, food_spend, drinks_spend
                    FROM spend_rate_overrides
                    WHERE kitchen_id = :kid AND week_start = :ws
                """), {"kid": current_user.kitchen_id, "ws": week_start})
                spend_ovr_lookup = {row.period: row for row in spend_ovr_result.fetchall()}

                # Resolve effective spend rates per period (override > snapshot > API)
                spend_effective = {}
                for period in ("breakfast", "lunch", "dinner"):
                    api_food = api_spend_rates.get(period, {}).get("food_spend_net", 0)
                    api_drinks = api_spend_rates.get(period, {}).get("drinks_spend_net", 0)

                    snap_food = snap_drinks = None
                    for d_check in week_dates:
                        key = (d_check.isoformat(), period)
                        if key in snap_spend_lookup:
                            snap_food = float(snap_spend_lookup[key].food_spend) if snap_spend_lookup[key].food_spend else None
                            snap_drinks = float(snap_spend_lookup[key].drinks_spend) if snap_spend_lookup[key].drinks_spend else None
                            break

                    ovr_sp = spend_ovr_lookup.get(period)
                    ovr_food = float(ovr_sp.food_spend) if ovr_sp and ovr_sp.food_spend else None
                    ovr_drinks = float(ovr_sp.drinks_spend) if ovr_sp and ovr_sp.drinks_spend else None

                    eff_food = ovr_food if ovr_food is not None else (snap_food if snap_food is not None else api_food)
                    eff_drinks = ovr_drinks if ovr_drinks is not None else (snap_drinks if snap_drinks is not None else api_drinks)
                    spend_effective[period] = {"food": eff_food, "drinks": eff_drinks}

                # Recalculate revenue per day
                covers_by_date_ovr = {d.get("date", ""): d for d in covers_data_raw}
                adjusted_total = Decimal("0")

                for d in week_dates:
                    date_str = d.isoformat()
                    is_past = d < today

                    if is_past and forecast_data:
                        # Past: use actual dry revenue from forecast API
                        day_rev = Decimal("0")
                        for fd in forecast_data:
                            if fd.get("date") == date_str:
                                dry = fd.get("dry", {})
                                day_rev = Decimal(str(dry.get("forecast", 0) or 0))
                                break
                    else:
                        # Today/future: recalculate from effective covers × effective spend
                        day_covers = covers_by_date_ovr.get(date_str, {})
                        day_rev = Decimal("0")

                        for period in ("breakfast", "lunch", "dinner"):
                            p_covers = day_covers.get(period, {})
                            otb_cvr = p_covers.get("otb", 0) or 0
                            forecast_cvr = p_covers.get("forecast", 0) or 0

                            ovr_val = override_lookup.get((date_str, period))
                            if ovr_val is not None:
                                effective = max(otb_cvr, ovr_val)  # OTB always supersedes upward
                            else:
                                effective = forecast_cvr

                            eff_food = Decimal(str(spend_effective.get(period, {}).get("food", 0)))
                            day_rev += Decimal(str(effective)) * eff_food

                    adjusted_daily[date_str] = day_rev.quantize(Decimal("0.01"))
                    adjusted_total += day_rev

                adjusted_revenue_val = adjusted_total.quantize(Decimal("0.01"))

                # Replace forecast_revenue and recalculate budget with adjusted values
                forecast_revenue = adjusted_revenue_val
                total_budget = (forecast_revenue * cost_target_pct).quantize(Decimal("0.01"))

    # Get historical supplier percentages
    lookback_weeks = settings.budget_lookback_weeks or 4
    lookback_start = week_start - timedelta(weeks=lookback_weeks)
    lookback_end = week_start - timedelta(days=1)

    supplier_pcts = await get_historical_supplier_percentages(
        db, current_user.kitchen_id, lookback_start, lookback_end
    )

    # Get historical daily distribution (for budget allocation by day of week)
    daily_distribution = await get_historical_daily_distribution(
        db, current_user.kitchen_id, lookback_start, lookback_end
    )

    # Get this week's invoices by supplier
    weekly_invoices = await get_weekly_invoices_by_supplier(
        db, current_user.kitchen_id, week_start, week_end
    )

    # Get this week's purchase orders (DRAFT + PENDING) grouped by supplier
    po_result = await db.execute(
        select(PurchaseOrder)
        .where(
            PurchaseOrder.kitchen_id == current_user.kitchen_id,
            PurchaseOrder.status.in_(["DRAFT", "PENDING"]),
            PurchaseOrder.order_date >= week_start,
            PurchaseOrder.order_date <= week_end,
        )
    )
    weekly_pos = po_result.scalars().all()

    # Group POs by supplier_id -> {date_str -> [BudgetPOItem]}
    po_by_supplier: dict[int, dict[str, list[BudgetPOItem]]] = defaultdict(lambda: defaultdict(list))
    po_totals_by_supplier: dict[int, Decimal] = defaultdict(lambda: Decimal("0"))
    po_supplier_names: dict[int, str] = {}

    for po in weekly_pos:
        sid = po.supplier_id
        ds = po.order_date.isoformat()
        amt = po.total_amount or Decimal("0")
        po_by_supplier[sid][ds].append(BudgetPOItem(
            id=po.id,
            order_type=po.order_type,
            status=po.status,
            total_amount=amt,
            order_reference=po.order_reference,
        ))
        po_totals_by_supplier[sid] += amt

    # Get supplier names for PO-only suppliers
    if po_by_supplier:
        sup_ids = list(po_by_supplier.keys())
        sup_result = await db.execute(
            select(Supplier.id, Supplier.name).where(Supplier.id.in_(sup_ids))
        )
        for sid, sname in sup_result.all():
            po_supplier_names[sid] = sname

    # Compute cost distribution adjustments per supplier per date.
    # CD entries are attributed back to the supplier whose invoice was distributed.
    cd_supplier_result = await db.execute(
        select(
            Invoice.supplier_id,
            CostDistributionEntry.entry_date,
            func.sum(CostDistributionEntry.amount)
        )
        .join(CostDistribution, CostDistributionEntry.distribution_id == CostDistribution.id)
        .join(Invoice, CostDistribution.invoice_id == Invoice.id)
        .where(
            CostDistributionEntry.kitchen_id == current_user.kitchen_id,
            CostDistributionEntry.entry_date >= week_start,
            CostDistributionEntry.entry_date <= week_end,
            CostDistribution.status.in_([DistributionStatus.ACTIVE.value, DistributionStatus.COMPLETED.value]),
        )
        .group_by(Invoice.supplier_id, CostDistributionEntry.entry_date)
    )
    # Per-supplier per-date amounts, plus aggregated totals
    cd_by_supplier_date: dict[Optional[int], dict[str, Decimal]] = defaultdict(lambda: defaultdict(lambda: Decimal("0")))
    cd_total_by_supplier: dict[Optional[int], Decimal] = defaultdict(lambda: Decimal("0"))
    cd_daily_amounts: dict[str, Decimal] = defaultdict(lambda: Decimal("0"))
    cd_total_adjustment = Decimal("0")
    for row in cd_supplier_result.all():
        sup_id, cd_date, cd_amount = row[0], row[1], row[2] or Decimal("0")
        date_str = cd_date.isoformat()
        cd_by_supplier_date[sup_id][date_str] += cd_amount
        cd_total_by_supplier[sup_id] += cd_amount
        cd_daily_amounts[date_str] += cd_amount
        cd_total_adjustment += cd_amount

    # Build supplier rows
    supplier_rows = []
    all_supplier_names = []
    total_spent = Decimal("0")
    total_po_ordered = Decimal("0")

    # Process historical suppliers first
    processed_suppliers = set()
    processed_po_suppliers = set()
    for supplier_id, supplier_name, hist_pct in supplier_pcts:
        key = (supplier_id, supplier_name)
        processed_suppliers.add(key)
        if supplier_id:
            processed_po_suppliers.add(supplier_id)
        all_supplier_names.append(supplier_name)

        # Calculate allocated budget from full total_budget
        allocated = (total_budget * Decimal(str(hist_pct)) / 100).quantize(Decimal("0.01"))

        # Get invoices for this supplier this week
        invoices = weekly_invoices.get(key, [])

        # Organize invoices by date
        invoices_by_date: dict[str, list[BudgetInvoice]] = defaultdict(list)
        actual_spent = Decimal("0")

        for inv in invoices:
            date_str = inv["invoice_date"].isoformat() if inv["invoice_date"] else ""
            if date_str:
                invoices_by_date[date_str].append(BudgetInvoice(
                    id=inv["id"],
                    invoice_number=inv["invoice_number"],
                    invoice_date=inv["invoice_date"],
                    net_stock=inv["net_stock"],
                    document_type=inv["document_type"],
                ))
            actual_spent += inv["net_stock"]

        # Get POs for this supplier
        supplier_po_dates = dict(po_by_supplier.get(supplier_id, {})) if supplier_id else {}
        supplier_po_total = po_totals_by_supplier.get(supplier_id, Decimal("0")) if supplier_id else Decimal("0")

        # Get CD adjustments for this supplier
        supplier_cd_dates = {k: float(v) for k, v in cd_by_supplier_date.get(supplier_id, {}).items()}
        supplier_cd_total = cd_total_by_supplier.get(supplier_id, Decimal("0"))

        total_spent += actual_spent
        total_po_ordered += supplier_po_total
        remaining = allocated - actual_spent - supplier_cd_total - supplier_po_total

        # Determine status
        if remaining < 0:
            status = "over"
        elif remaining < allocated * Decimal("0.1"):  # Less than 10% remaining
            status = "on_track"
        else:
            status = "under"

        supplier_rows.append(SupplierBudgetRow(
            supplier_id=supplier_id,
            supplier_name=supplier_name,
            historical_pct=hist_pct,
            allocated_budget=allocated,
            invoices_by_date=dict(invoices_by_date),
            purchase_orders_by_date=supplier_po_dates,
            actual_spent=actual_spent,
            cd_adjustments_by_date=supplier_cd_dates,
            cd_total=float(supplier_cd_total),
            po_ordered=supplier_po_total,
            remaining=remaining,
            status=status,
        ))

    # Add any suppliers with invoices this week that weren't in historical data
    for key, invoices in weekly_invoices.items():
        if key not in processed_suppliers:
            supplier_id, supplier_name = key
            if supplier_id:
                processed_po_suppliers.add(supplier_id)
            all_supplier_names.append(supplier_name)

            invoices_by_date: dict[str, list[BudgetInvoice]] = defaultdict(list)
            actual_spent = Decimal("0")

            for inv in invoices:
                date_str = inv["invoice_date"].isoformat() if inv["invoice_date"] else ""
                if date_str:
                    invoices_by_date[date_str].append(BudgetInvoice(
                        id=inv["id"],
                        invoice_number=inv["invoice_number"],
                        invoice_date=inv["invoice_date"],
                        net_stock=inv["net_stock"],
                        document_type=inv["document_type"],
                    ))
                actual_spent += inv["net_stock"]

            supplier_po_dates = dict(po_by_supplier.get(supplier_id, {})) if supplier_id else {}
            supplier_po_total = po_totals_by_supplier.get(supplier_id, Decimal("0")) if supplier_id else Decimal("0")

            supplier_cd_dates = {k: float(v) for k, v in cd_by_supplier_date.get(supplier_id, {}).items()}
            supplier_cd_total = cd_total_by_supplier.get(supplier_id, Decimal("0"))

            total_spent += actual_spent
            total_po_ordered += supplier_po_total
            combined = actual_spent + supplier_cd_total + supplier_po_total

            supplier_rows.append(SupplierBudgetRow(
                supplier_id=supplier_id,
                supplier_name=supplier_name,
                historical_pct=Decimal("0"),  # No historical data
                allocated_budget=Decimal("0"),
                invoices_by_date=dict(invoices_by_date),
                purchase_orders_by_date=supplier_po_dates,
                actual_spent=actual_spent,
                cd_adjustments_by_date=supplier_cd_dates,
                cd_total=float(supplier_cd_total),
                po_ordered=supplier_po_total,
                remaining=-combined,  # Over by definition
                status="over" if combined > 0 else "under",
            ))

    # Add suppliers with POs but no invoices and no historical data
    for sid, po_dates in po_by_supplier.items():
        if sid not in processed_po_suppliers:
            sname = po_supplier_names.get(sid, f"Supplier #{sid}")
            all_supplier_names.append(sname)
            supplier_po_total = po_totals_by_supplier.get(sid, Decimal("0"))
            total_po_ordered += supplier_po_total

            supplier_rows.append(SupplierBudgetRow(
                supplier_id=sid,
                supplier_name=sname,
                historical_pct=Decimal("0"),
                allocated_budget=Decimal("0"),
                invoices_by_date={},
                purchase_orders_by_date=dict(po_dates),
                actual_spent=Decimal("0"),
                po_ordered=supplier_po_total,
                remaining=-supplier_po_total,
                status="over" if supplier_po_total > 0 else "under",
            ))

    # Build daily breakdown with both historical and revenue-based budgets
    daily_data = []
    daily_totals: dict[str, Decimal] = {}
    cumulative_budget = Decimal("0")
    cumulative_spent = Decimal("0")

    # Extract daily revenue from forecast API data
    daily_forecast_revenue: dict[str, Decimal] = {}
    total_forecast_rev = Decimal("0")

    if forecast_data:
        # Use actual daily forecast from API
        for day in forecast_data:
            date_str = day.get("date")
            if date_str:
                dry = day.get("dry", {})
                dry_forecast = Decimal(str(dry.get("forecast", 0) or 0))
                daily_forecast_revenue[date_str] = dry_forecast
                total_forecast_rev += dry_forecast
    else:
        # Fallback: distribute total forecast using historical patterns
        for d in week_dates:
            weekday = d.weekday()
            day_pct = daily_distribution.get(weekday, Decimal("14.29"))
            day_forecast_rev = (forecast_revenue * day_pct / 100).quantize(Decimal("0.01"))
            daily_forecast_revenue[d.isoformat()] = day_forecast_rev
            total_forecast_rev += day_forecast_rev

    # Apply adjusted daily revenue from overrides
    if adjusted_daily:
        for adj_date_str, adj_rev in adjusted_daily.items():
            daily_forecast_revenue[adj_date_str] = adj_rev
        total_forecast_rev = sum(daily_forecast_revenue.values())

    for d in week_dates:
        date_str = d.isoformat()
        day_name = d.strftime("%a")
        weekday = d.weekday()  # 0=Monday, 6=Sunday

        # Historical spend-based budget
        budget_split_pct = daily_distribution.get(weekday, Decimal("14.29"))
        historical_budget = (total_budget * budget_split_pct / 100).quantize(Decimal("0.01"))

        # Revenue-based budget (proportional to actual daily forecast revenue)
        day_forecast_rev = daily_forecast_revenue.get(date_str, Decimal("0"))
        if total_forecast_rev > 0:
            revenue_pct = (day_forecast_rev / total_forecast_rev * 100).quantize(Decimal("0.01"))
            revenue_budget = (total_budget * revenue_pct / 100).quantize(Decimal("0.01"))
        else:
            revenue_budget = (total_budget / 7).quantize(Decimal("0.01"))

        # Get actual spend for this day
        day_spent = Decimal("0")
        for supplier_row in supplier_rows:
            for inv in supplier_row.invoices_by_date.get(date_str, []):
                day_spent += inv.net_stock

        daily_totals[date_str] = day_spent
        cumulative_budget += historical_budget  # Use historical for cumulative

        # Only show cumulative spent for past/today
        if d <= today:
            cumulative_spent += day_spent
            daily_data.append(DailyBudgetData(
                date=d,
                day_name=day_name,
                forecast_revenue=day_forecast_rev,
                budget_split_pct=budget_split_pct,
                historical_budget=historical_budget,
                revenue_budget=revenue_budget,
                actual_spent=day_spent,
                cumulative_budget=cumulative_budget,
                cumulative_spent=cumulative_spent,
            ))
        else:
            daily_data.append(DailyBudgetData(
                date=d,
                day_name=day_name,
                forecast_revenue=day_forecast_rev,
                budget_split_pct=budget_split_pct,
                historical_budget=historical_budget,
                revenue_budget=revenue_budget,
                actual_spent=None,
                cumulative_budget=cumulative_budget,
                cumulative_spent=None,
            ))

    # Apply pre-computed cost distribution adjustments to daily totals and total_spent
    for date_str, cd_amount in cd_daily_amounts.items():
        if date_str in daily_totals:
            daily_totals[date_str] += cd_amount
        else:
            daily_totals[date_str] = cd_amount
    total_spent += cd_total_adjustment

    total_remaining = total_budget - total_spent - total_po_ordered

    return WeeklyBudgetResponse(
        week_start=week_start,
        week_end=week_end,
        dates=week_dates,
        otb_revenue=otb_revenue,
        forecast_revenue=forecast_revenue,
        forecast_source=forecast_source,
        forecast_summary=forecast_summary,
        has_overrides=has_overrides_flag,
        snapshot_revenue=snapshot_revenue_val,
        adjusted_revenue=adjusted_revenue_val,
        gp_target_pct=gp_target,
        min_budget=min_budget,
        total_budget=total_budget,
        total_spent=total_spent,
        total_po_ordered=total_po_ordered,
        total_remaining=total_remaining,
        cd_budget_reservation=Decimal("0"),  # Not used; CD is attributed per-supplier
        suppliers=supplier_rows,
        all_supplier_names=all_supplier_names,
        daily_data=daily_data,
        daily_totals=daily_totals,
    )


@router.get("/settings", response_model=BudgetSettingsResponse)
async def get_budget_settings(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """Get current budget settings"""
    settings = await get_settings(db, current_user.kitchen_id)

    return BudgetSettingsResponse(
        forecast_api_url=settings.forecast_api_url,
        forecast_api_configured=bool(settings.forecast_api_url and settings.forecast_api_key),
        budget_gp_target=settings.budget_gp_target or Decimal("65.00"),
        budget_lookback_weeks=settings.budget_lookback_weeks or 4,
    )


@router.patch("/settings", response_model=BudgetSettingsResponse)
async def update_budget_settings(
    updates: BudgetSettingsUpdate,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """Update budget settings"""
    settings = await get_settings(db, current_user.kitchen_id)

    if updates.forecast_api_url is not None:
        settings.forecast_api_url = updates.forecast_api_url or None

    if updates.forecast_api_key is not None:
        settings.forecast_api_key = updates.forecast_api_key or None

    if updates.budget_gp_target is not None:
        settings.budget_gp_target = updates.budget_gp_target

    if updates.budget_lookback_weeks is not None:
        settings.budget_lookback_weeks = updates.budget_lookback_weeks

    await db.commit()
    await db.refresh(settings)

    return BudgetSettingsResponse(
        forecast_api_url=settings.forecast_api_url,
        forecast_api_configured=bool(settings.forecast_api_url and settings.forecast_api_key),
        budget_gp_target=settings.budget_gp_target or Decimal("65.00"),
        budget_lookback_weeks=settings.budget_lookback_weeks or 4,
    )


@router.post("/test-forecast-connection", response_model=TestConnectionResponse)
async def test_forecast_connection(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """Test connection to forecast API"""
    settings = await get_settings(db, current_user.kitchen_id)

    if not settings.forecast_api_url:
        return TestConnectionResponse(
            success=False,
            message="Forecast API URL not configured"
        )

    if not settings.forecast_api_key:
        return TestConnectionResponse(
            success=False,
            message="Forecast API key not configured"
        )

    try:
        async with ForecastAPIClient(
            settings.forecast_api_url,
            settings.forecast_api_key
        ) as client:
            success, message = await client.test_connection()
            return TestConnectionResponse(success=success, message=message)
    except Exception as e:
        return TestConnectionResponse(
            success=False,
            message=f"Connection failed: {str(e)}"
        )