"""
Rate Parity Check Job

Compares our own hotel's scraped Booking.com rate against our Newbook rate
for each date, allowing for a configured expected markup — we deliberately
price Booking.com higher to cover commission, so parity is measured against
expected = newbook × (1 + markup%), not raw equality. Deviations beyond the
tolerance are persisted as rate_parity_alerts rows (feeding the Market View
badge); dates back within tolerance auto-resolve their active alert.
Acknowledged alerts are left alone — acknowledging a date suppresses
re-alerting for it until the alert is resolved by the rates coming back
in line.

Config (system_config):
  parity_check_enabled        true/false (default true)
  parity_expected_markup_pct  expected Booking.com premium over Newbook (default 0)
  parity_tolerance_pct        allowed deviation from expected before alerting (default 2)

Schedule: daily at 06:45, after the 05:20 Newbook fetch and 05:30 scrape.
"""
import logging
from datetime import date, timedelta

from sqlalchemy import text

from database import SyncSessionLocal

logger = logging.getLogger(__name__)

HORIZON_DAYS = 90


def get_parity_config(db) -> dict:
    rows = db.execute(
        text("""SELECT config_key, config_value FROM system_config
                WHERE config_key IN ('parity_check_enabled',
                                     'parity_expected_markup_pct',
                                     'parity_tolerance_pct')""")
    ).fetchall()
    cfg = {r[0]: r[1] for r in rows}

    def num(key: str, default: float) -> float:
        try:
            return float(cfg.get(key) or default)
        except (TypeError, ValueError):
            return default

    enabled_raw = (cfg.get('parity_check_enabled') or 'true').lower()
    return {
        "enabled": enabled_raw in ('true', '1', 'yes', 'enabled'),
        "markup_pct": num('parity_expected_markup_pct', 0.0),
        "tolerance_pct": num('parity_tolerance_pct', 2.0),
    }


def deviation_from_expected(booking_rate: float, newbook_rate: float, markup_pct: float) -> float | None:
    """% deviation of the actual Booking.com rate from the expected
    (Newbook × (1 + markup%)) rate. None if expected is not positive."""
    expected = newbook_rate * (1 + markup_pct / 100)
    if expected <= 0:
        return None
    return (booking_rate - expected) / expected * 100


def run_parity_check() -> dict:
    db = SyncSessionLocal()
    try:
        cfg = get_parity_config(db)
        if not cfg["enabled"]:
            logger.info("Parity check skipped (disabled)")
            return {"status": "disabled"}

        start = date.today()
        end = start + timedelta(days=HORIZON_DAYS)

        # Own hotel's latest Booking.com lead-in rate per date
        booking_rows = db.execute(text("""
            SELECT DISTINCT ON (r.rate_date)
                r.rate_date, r.rate_gross, r.room_type
            FROM booking_com_rates r
            JOIN booking_com_hotels h ON r.hotel_id = h.id
            WHERE h.tier = 'own'
              AND r.rate_date BETWEEN :fd AND :td
              AND r.rate_gross IS NOT NULL
            ORDER BY r.rate_date, r.scraped_at DESC
        """), {"fd": start, "td": end}).fetchall()
        booking = {r[0]: {"rate": float(r[1]), "room": r[2]} for r in booking_rows}

        # Cheapest current Newbook rate per date (latest snapshot per category)
        newbook_rows = db.execute(text("""
            SELECT rate_date, MIN(rate_gross) AS newbook_rate FROM (
                SELECT DISTINCT ON (rate_date, category_id)
                    rate_date, rate_gross
                FROM newbook_current_rates
                WHERE rate_date BETWEEN :fd AND :td
                  AND rate_gross IS NOT NULL AND rate_gross > 0
                ORDER BY rate_date, category_id, valid_from DESC
            ) t GROUP BY rate_date
        """), {"fd": start, "td": end}).fetchall()
        newbook = {r[0]: float(r[1]) for r in newbook_rows}

        # Latest alert per date in the horizon
        alert_rows = db.execute(text("""
            SELECT DISTINCT ON (rate_date)
                id, rate_date, alert_status, difference_pct
            FROM rate_parity_alerts
            WHERE rate_date BETWEEN :fd AND :td
            ORDER BY rate_date, created_at DESC
        """), {"fd": start, "td": end}).fetchall()
        latest_alert = {r[1]: {"id": r[0], "status": r[2], "diff": float(r[3] or 0)} for r in alert_rows}

        common_dates = sorted(set(booking) & set(newbook))
        created = updated = resolved = 0

        for d in common_dates:
            dev = deviation_from_expected(booking[d]["rate"], newbook[d], cfg["markup_pct"])
            if dev is None:
                continue
            alert = latest_alert.get(d)

            if abs(dev) > cfg["tolerance_pct"]:
                if alert and alert["status"] == "active":
                    if round(dev, 2) != round(alert["diff"], 2):
                        db.execute(text("""
                            UPDATE rate_parity_alerts
                            SET newbook_rate = :nb, booking_com_rate = :bc,
                                difference_pct = :diff, alert_type = :atype,
                                room_category = :room
                            WHERE id = :id
                        """), {
                            "id": alert["id"], "nb": newbook[d], "bc": booking[d]["rate"],
                            "diff": round(dev, 2),
                            "atype": "higher" if dev > 0 else "lower",
                            "room": booking[d]["room"],
                        })
                        updated += 1
                elif alert and alert["status"] == "acknowledged":
                    pass  # user has dealt with this date — don't nag
                else:
                    db.execute(text("""
                        INSERT INTO rate_parity_alerts
                            (rate_date, room_category, newbook_rate, booking_com_rate,
                             difference_pct, alert_type, alert_status)
                        VALUES (:date, :room, :nb, :bc, :diff, :atype, 'active')
                    """), {
                        "date": d, "room": booking[d]["room"],
                        "nb": newbook[d], "bc": booking[d]["rate"],
                        "diff": round(dev, 2),
                        "atype": "higher" if dev > 0 else "lower",
                    })
                    created += 1
            else:
                if alert and alert["status"] in ("active", "acknowledged"):
                    db.execute(
                        text("UPDATE rate_parity_alerts SET alert_status = 'resolved' WHERE id = :id"),
                        {"id": alert["id"]}
                    )
                    resolved += 1

        db.commit()
        summary = {
            "status": "ok",
            "dates_compared": len(common_dates),
            "created": created,
            "updated": updated,
            "resolved": resolved,
            "markup_pct": cfg["markup_pct"],
            "tolerance_pct": cfg["tolerance_pct"],
        }
        logger.info(f"Parity check: {summary}")
        return summary
    except Exception:
        db.rollback()
        raise
    finally:
        db.close()