room_cal/room_cal/actions/diff.py

import asyncio
from datetime import date, timedelta
from typing import TYPE_CHECKING

from room_cal.cal import get_calendar
from room_cal.closed import Closed
from room_cal.discount import Discount
from room_cal.pricing.price_calendar import CalPrice
from room_cal.reservations import Reservation
from room_cal.user_cal import UserCal
from room_cal._utils import (
  safe_json_loads, iter_dates, filter_events, services as _services,
  get_config, event_dates, registered_domains, local_today,
)
import room_cal._api_source  # ensures 'api' is registered
import room_cal.rules  # ensures 'rules' is registered

if TYPE_CHECKING:
  from room_cal.service_api import ServiceAPI

ACTION_SPEC = ('diff', [])

_PRICE_PREFIX = 'Price: $'


async def diff(
  start_date: date,
  end_date: date,
  *,
  api: 'ServiceAPI | None' = None,
) -> dict:
  """Compare the Room calendar to all data sources.

  Returns:
    prices          — Room Price events vs service_api list prices
    closed          — Room Closed events vs service_api availability
    reservations    — Room Guest events vs service_api reservations
    user_cal_closed — Room Closed (user_cal-sourced) vs user_cal Room Closed events
    ical_feeds_closed     — {feed_name: [...]} Room Closed (feed-sourced) vs iCal feed content
    rule_discounts        — {pipeline_name: [...]} Room Discount (rule-sourced) vs rule output
    rule_closed           — {pipeline_name: [...]} Room Closed (rule-sourced) vs rule output
    orphans         — Room Closed/Discount events with missing or unrecognized source

  No writes are performed.
  """
  from room_cal.service_api import ServiceAPI as _ServiceAPI
  if api is None:
    api = _ServiceAPI()
  results = await asyncio.gather(
    _diff_prices(start_date, end_date, api),
    _diff_closed(start_date, end_date, api),
    _diff_reservations(start_date, end_date, api),
    _diff_user_cal_closed(start_date, end_date),
    _diff_ical_feeds_closed(start_date, end_date),
    _diff_rule_discounts(start_date, end_date),
    _diff_rule_closed(start_date, end_date),
    _diff_rule_prices(start_date, end_date),
    _diff_orphans(start_date, end_date),
  )
  keys = ['prices', 'closed', 'reservations', 'user_cal_closed', 'ical_feeds_closed', 'rule_discounts', 'rule_closed', 'rule_prices', 'orphans']
  return dict(zip(keys, results))


# ── prices ────────────────────────────────────────────────────────────────────

async def _diff_prices(
  start_date: date,
  end_date: date,
  api: 'ServiceAPI',
) -> list[dict]:
  """Room Price: events vs service_api list prices.

  Each row: {'date', 'net': float|None, 'per_service': {svc: {'local', 'remote'}}}
  """
  from room_cal.reservations import Reservation

  cal = get_calendar()
  events, api_prices, res_events = await asyncio.gather(
    cal.fetch_date_range(start_date, end_date),
    api.get_prices_range(start_date, end_date),
    Reservation().list(start_date, end_date),
  )

  from room_cal.pricing.price_calendar import PriceData

  svc_keys = [s.key for s in _services()]
  cal_prices: dict[str, PriceData] = {}
  for e in filter_events(events, _PRICE_PREFIX, all_day=True):
    d = safe_json_loads(e['x_data'])
    if d is not None:
      cal_prices[e['start'].date().isoformat()] = PriceData.from_dict(d, svc_keys)


  booked_svc_by_date: dict[date, str] = {}
  for e in res_events:
    xd = safe_json_loads(e['x_data'])
    if xd:
      svc = xd.get('service')
      if svc:
        last_night = e['end'].date() - timedelta(days=1)
        for d in iter_dates(e['start'].date(), last_night):
          booked_svc_by_date[d] = svc

  today = local_today()
  results: list[dict] = []
  for ds in (d.isoformat() for d in iter_dates(start_date, end_date)):
    d = date.fromisoformat(ds)
    is_past = d < today
    local = cal_prices.get(ds)
    remote = api_prices.get(ds, {})
    has_diff = False
    per_service: dict[str, dict] = {}
    for svc in svc_keys:
      lp = local.service_prices.get(svc) if local else None
      rp = remote.get(svc)
      if lp is None and rp is None:
        continue
      if svc == 'booking' and is_past and rp is None:
        continue
      booked_svc = booked_svc_by_date.get(d)
      if booked_svc is not None and svc != booked_svc:
        continue
      per_service[svc] = {'local': lp, 'remote': rp}
      if lp is None or rp is None or lp != rp:
        has_diff = True
    if has_diff:
      results.append({
        'date': d,
        'net': local.net if local else None,
        'per_service': per_service,
      })
  return results


# ── closed (service_api) ──────────────────────────────────────────────────────

async def _diff_closed(
  start_date: date,
  end_date: date,
  api: 'ServiceAPI',
) -> list[dict]:
  """Room Closed events vs service_api availability.

  Each row: {'date', 'local': list[str]|None, 'remote': list[str]|None}
  """
  closed_cal = Closed()
  cal_events = await closed_cal.list(start_date, end_date)
  cal_by_date: dict[str, list[str]] = {}
  for e in cal_events:
    d = safe_json_loads(e['x_data'])
    if d is not None:
      cal_by_date[e['start'].date().isoformat()] = sorted(d.get('closed_services', []))

  api_by_date = await api.get_closed_by_date(start_date, end_date)
  api_by_date = {ds: sorted(svcs) for ds, svcs in api_by_date.items()}

  today = local_today()
  all_dates = sorted(set(cal_by_date) | set(api_by_date))
  results: list[dict] = []
  for ds in all_dates:
    local = cal_by_date.get(ds)
    remote = api_by_date.get(ds)
    if date.fromisoformat(ds) < today and (remote is None or 'booking' not in remote):
      local_cmp = [s for s in (local or []) if s != 'booking'] or None
      remote_cmp = [s for s in (remote or []) if s != 'booking'] or None
    else:
      local_cmp, remote_cmp = local, remote
    if local_cmp != remote_cmp:
      results.append({'date': date.fromisoformat(ds), 'local': local, 'remote': remote})
  return results


# ── reservations ──────────────────────────────────────────────────────────────

async def _diff_reservations(
  start_date: date,
  end_date: date,
  api: 'ServiceAPI',
) -> list[dict]:
  """Room Guest events vs service_api reservations.

  Each row: {'status': 'added'|'removed'|'changed', ...}
  """
  res_cal = Reservation()
  cal_events = await res_cal.list(start_date, end_date)
  cal_by_id: dict[str, dict] = {}
  for e in cal_events:
    if e['start'].date() < start_date:
      continue  # checkin before range — belongs to a prior period's scope
    d = safe_json_loads(e['x_data'])
    if d:
      rid = d.get('reservation_id')
      if rid:
        cal_by_id[rid] = {
          'reservation_id': rid,
          'guest_name':     d.get('guest_name', ''),
          'service':        d.get('service', ''),
          'checkin_date':   e['start'].date(),
          'checkout_date':  e['end'].date(),
        }

  service_reservations = await api.get_reservations(start_date, end_date)
  api_by_id: dict[str, dict] = {
    r['id']: {
      'reservation_id': r['id'],
      'guest_name':     r['guest_name'] or '<None>',
      'service':        r['service'],
      'checkin_date':   r['start_date'],
      'checkout_date':  r['end_date'],
    }
    for r in service_reservations
  }

  diffs: list[dict] = []
  for rid, api_r in sorted(api_by_id.items(), key=lambda x: x[1]['checkin_date']):
    if rid not in cal_by_id:
      diffs.append({'status': 'added', **api_r})
    else:
      cal_r = cal_by_id[rid]
      changes = []
      for field in ('checkin_date', 'checkout_date', 'guest_name', 'service'):
        if cal_r[field] != api_r[field]:
          changes.append({'field': field, 'local': cal_r[field], 'remote': api_r[field]})
      if changes:
        diffs.append({'status': 'changed', 'reservation_id': rid, 'changes': changes})

  for rid, cal_r in sorted(cal_by_id.items(), key=lambda x: x[1]['checkin_date']):
    if rid not in api_by_id:
      diffs.append({'status': 'removed', **cal_r})

  return diffs


# ── closed (user_cal) ─────────────────────────────────────────────────────────

async def _diff_user_cal_closed(
  start_date: date,
  end_date: date,
) -> list[dict]:
  """Room Closed events (user_cal-sourced) vs current user_cal Room Closed events.

  Each row: {'date', 'in_room': bool, 'in_user_cal': bool}
  """
  closed_cal = Closed()
  user_cal = UserCal()

  room_events, user_cal_events = await asyncio.gather(
    closed_cal.list(start_date, end_date),
    user_cal.find_closed(start_date, end_date),
  )

  room_dates: set[date] = set()
  for e in room_events:
    xd = safe_json_loads(e['x_data'])
    if xd and xd.get('source', {}).get('domain') == 'user_cal':
      room_dates.add(e['start'].date())

  user_cal_dates: set[date] = set()
  for ev in user_cal_events:
    for d in event_dates(ev, start_date, end_date):
      user_cal_dates.add(d)

  all_dates = sorted(room_dates | user_cal_dates)
  return [
    {'date': d, 'in_room': d in room_dates, 'in_user_cal': d in user_cal_dates}
    for d in all_dates
    if (d in room_dates) != (d in user_cal_dates)
  ]


# ── closed (iCal feeds) ───────────────────────────────────────────────────────

async def _diff_ical_feeds_closed(
  start_date: date,
  end_date: date,
) -> dict[str, list[dict]]:
  """Room Closed events (feed-sourced) vs current iCal feed content.

  Returns {feed_name: [{'date', 'in_room': bool, 'in_feed': bool}]}
  Only includes feeds with at least one difference.
  """
  from room_cal.ical_feeds import fetch_calendar

  entries = get_config().calendars
  if not entries:
    return {}

  closed_cal = Closed()
  room_events = await closed_cal.list(start_date, end_date)

  async def _check_feed(entry) -> tuple[str, list[dict]]:
    feed_name = entry.name
    room_dates: set[date] = set()
    for e in room_events:
      xd = safe_json_loads(e['x_data'])
      if xd:
        src = xd.get('source', {})
        if src.get('domain') == 'ical_feeds' and src.get('id') == feed_name:
          room_dates.add(e['start'].date())

    feed_events = await fetch_calendar(entry)
    feed_dates: set[date] = set()
    for ev in feed_events:
      for d in event_dates(ev, start_date, end_date):
        feed_dates.add(d)

    all_dates = sorted(room_dates | feed_dates)
    diffs = [
      {'date': d, 'in_room': d in room_dates, 'in_ical_feeds': d in feed_dates}
      for d in all_dates
      if (d in room_dates) != (d in feed_dates)
    ]
    return feed_name, diffs

  results = await asyncio.gather(*[_check_feed(e) for e in entries])
  return {name: diffs for name, diffs in results if diffs}


# ── discounts (rules) ────────────────────────────────────────────────────────

async def _diff_rule_discounts(
  start_date: date,
  end_date: date,
) -> dict[str, list[dict]]:
  """Room Discount events (rule-sourced) vs what each discount pipeline generates.

  Returns {pipeline_name: [{'date', 'local', 'rule'}]}, only pipelines with diffs.
  """
  disc_cal = Discount()
  room_events = await disc_cal.list(start_date, end_date)

  results: dict[str, list[dict]] = {}
  for name in room_cal.rules.list_pipelines(type_='discount'):
    room_by_date: dict[date, dict] = {}
    for e in room_events:
      xd = safe_json_loads(e['x_data'])
      if xd:
        src = xd.get('source', {})
        if src.get('domain') == 'rules' and src.get('id') == name:
          room_by_date[e['start'].date()] = {'type': xd['type'], 'value': xd['value']}

    pipeline_out = await room_cal.rules.run_pipeline(name, start_date, end_date)
    rule_by_date = {d: {'type': rec.type, 'value': rec.value} for d, rec in pipeline_out.items()}

    all_dates = sorted(set(room_by_date) | set(rule_by_date))
    diffs = [
      {'date': d, 'local': room_by_date.get(d), 'rule': rule_by_date.get(d)}
      for d in all_dates
      if room_by_date.get(d) != rule_by_date.get(d)
    ]
    if diffs:
      results[name] = diffs

  return results


# ── closed (rules) ───────────────────────────────────────────────────────────

async def _diff_rule_closed(
  start_date: date,
  end_date: date,
) -> dict[str, list[dict]]:
  """Room Closed events (rule-sourced) vs what each closed pipeline generates.

  Returns {pipeline_name: [{'date', 'in_room': bool, 'in_rule': bool}]}, only pipelines with diffs.
  """
  closed_cal = Closed()
  room_events = await closed_cal.list(start_date, end_date)

  results: dict[str, list[dict]] = {}
  for name in room_cal.rules.list_pipelines(type_='closed'):
    room_dates: set[date] = set()
    for e in room_events:
      xd = safe_json_loads(e['x_data'])
      if xd:
        src = xd.get('source', {})
        if src.get('domain') == 'rules' and src.get('id') == name:
          room_dates.add(e['start'].date())

    pipeline_out = await room_cal.rules.run_pipeline(name, start_date, end_date)
    rule_dates: set[date] = {d for d, rec in pipeline_out.items() if rec.services}

    all_dates = sorted(room_dates | rule_dates)
    diffs = [
      {'date': d, 'in_room': d in room_dates, 'in_rule': d in rule_dates}
      for d in all_dates
      if (d in room_dates) != (d in rule_dates)
    ]
    if diffs:
      results[name] = diffs

  return results


# ── prices (rules) ───────────────────────────────────────────────────────────

async def _diff_rule_prices(
  start_date: date,
  end_date: date,
) -> dict[str, list[dict]]:
  """Room Price events vs minimum floors required by each price pipeline.

  Returns {pipeline_name: [{'date', 'local_base', 'rule_min'}]}, only pipelines with diffs.
  As-booked dates are excluded: the booking price is always authoritative.
  """
  price_events, res_events = await asyncio.gather(
    CalPrice().list(start_date, end_date),
    Reservation().list(start_date, end_date),
  )

  booked: set[date] = set()
  for e in res_events:
    last_night = e['end'].date() - timedelta(days=1)
    for d in iter_dates(e['start'].date(), last_night):
      booked.add(d)

  local_base_by_date: dict[date, int] = {}
  for e in price_events:
    xd = safe_json_loads(e['x_data'])
    if xd:
      base = xd.get('base') or xd.get('net')
      if base is not None:
        local_base_by_date[e['start'].date()] = base

  results: dict[str, list[dict]] = {}
  for name in room_cal.rules.list_pipelines(type_='price'):
    pipeline_out = await room_cal.rules.run_pipeline(name, start_date, end_date)
    diffs = []
    for d in sorted(pipeline_out):
      if d in booked:
        continue
      rule_min = pipeline_out[d].min_base
      local_base = local_base_by_date.get(d)
      if local_base is None or local_base < rule_min:
        diffs.append({'date': d, 'local_base': local_base, 'rule_min': rule_min})
    if diffs:
      results[name] = diffs
  return results


# ── orphans ───────────────────────────────────────────────────────────────────

async def _diff_orphans(
  start_date: date,
  end_date: date,
) -> list[dict]:
  """Room Closed and Discount events with missing or unrecognized source.

  Each row: {'date', 'event_type': 'closed'|'discount', 'title', 'source': dict|None}
  """
  events = await get_calendar().fetch_date_range(start_date, end_date)

  closed_events   = filter_events(events, 'Closed: ',   all_day=True, require_x_data=False)
  discount_events = filter_events(events, 'Discount: ', all_day=True, require_x_data=False)

  orphans: list[dict] = []

  for e in closed_events:
    xd = safe_json_loads(e['x_data'])
    domain = xd.get('source', {}).get('domain') if xd else None
    if domain not in registered_domains():
      orphans.append({
        'date':       e['start'].date(),
        'event_type': 'closed',
        'title':      e['title'],
        'source':     (xd.get('source') if xd else None),
      })

  for e in discount_events:
    xd = safe_json_loads(e['x_data'])
    domain = xd.get('source', {}).get('domain') if xd else None
    if domain not in registered_domains():
      orphans.append({
        'date':       e['start'].date(),
        'event_type': 'discount',
        'title':      e['title'],
        'source':     (xd.get('source') if xd else None),
      })

  orphans.sort(key=lambda x: x['date'])
  return orphans