Flightclaw

data/
__pycache__/
*.pyc
.flightclaw_api_key
.dev.vars

"""Credit card & points tools for FlightClaw — backend (D1) backed.

Records which cards and loyalty/points balances the user holds, for award and
transfer-partner awareness. NOTE: actual payment still routes through Link
virtual cards (duffel_book_with_link) — these records are for optimization, not
charging. Pair with the Card Links MCP (transfer partners) and the Award Travel
Finder MCP (award availability) at the agent layer.
"""

import profile_api


def register_cards_tools(mcp):
    """Register card + points tools on the MCP server."""

    @mcp.tool()
    def save_card(
        id: str,
        issuer: str,
        product: str,
        network: str | None = None,
        region: str | None = None,
        notes: str | None = None,
    ) -> str:
        """Save or update a credit card the user holds (for points/transfer awareness).

        Args:
            id: Short slug, e.g. 'amex-plat'
            issuer: Card issuer, e.g. 'American Express'
            product: Product name, e.g. 'Platinum'
            network: amex | visa | mastercard (optional)
            region: Card region, e.g. US, UK, AU (optional)
            notes: Free-form notes, e.g. transfer partners or perks (optional)
        """
        try:
            result = profile_api.upsert_card({
                "id": id, "issuer": issuer, "product": product,
                "network": network, "region": region, "notes": notes,
            })
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        if "error" in result:
            return f"Error: {result['error']}"
        return f"Saved card '{id.lower().strip()}'. {len(result.get('cards', []))} card(s) on file."

    @mcp.tool()
    def list_cards() -> str:
        """List the user's saved cards and points balances."""
        try:
            data = profile_api.get_cards()
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        cards = data.get("cards", [])
        points = data.get("points", [])
        if not cards and not points:
            return "No cards or points saved. Use save_card / set_points_balance."
        lines = []
        if cards:
            lines.append("Cards:")
            for c in cards:
                line = f"  {c['id']}: {c['issuer']} {c['product']}"
                if c.get("network"):
                    line += f" ({c['network']})"
                if c.get("region"):
                    line += f" [{c['region']}]"
                if c.get("notes"):
                    line += f" — {c['notes']}"
                lines.append(line)
        if points:
            lines.append("Points balances:")
            for p in points:
                lines.append(f"  {p['program']}: {p['balance']:,}")
        return "\n".join(lines)

    @mcp.tool()
    def delete_card(id: str) -> str:
        """Delete a saved card.

        Args:
            id: Card slug to delete (e.g. 'amex-plat')
        """
        try:
            result = profile_api.delete_card(id)
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        if not result.get("ok"):
            return f"No card '{id}' found."
        return f"Deleted card '{id}'."

    @mcp.tool()
    def set_points_balance(program: str, balance: int) -> str:
        """Set or update a loyalty/points balance.

        Args:
            program: Program name (e.g. 'Amex Membership Rewards', 'Avios', 'United MileagePlus')
            balance: Current points/miles balance
        """
        try:
            profile_api.set_points(program, balance)
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        return f"Set {program} balance to {balance:,}."

    @mcp.tool()
    def list_points() -> str:
        """List the user's loyalty/points balances."""
        try:
            data = profile_api.get_cards()
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        points = data.get("points", [])
        if not points:
            return "No points balances saved. Use set_points_balance."
        lines = [f"  {p['program']}: {p['balance']:,}" for p in points]
        return "Points balances:\n" + "\n".join(lines)

"""Thin HTTP client for the flightclaw-api wrapper (private Duffel proxy)."""

import json
import os
import urllib.error
import urllib.parse
import urllib.request


def _get_config():
    base_url = os.environ.get("FLIGHTCLAW_API_URL", "").rstrip("/")
    api_key = os.environ.get("FLIGHTCLAW_API_KEY", "")
    if not base_url or not api_key:
        raise RuntimeError(
            "FLIGHTCLAW_API_URL and FLIGHTCLAW_API_KEY must be set. "
            "These point to your private flightclaw-api Worker."
        )
    return base_url, api_key


def _request(method, path, body=None, params=None):
    """Make an authenticated request to flightclaw-api."""
    base_url, api_key = _get_config()
    url = f"{base_url}{path}"

    if params:
        qs = "&".join(f"{k}={urllib.parse.quote(str(v))}" for k, v in params.items())
        url = f"{url}?{qs}"

    data = json.dumps(body).encode() if body else None
    req = urllib.request.Request(
        url,
        data=data,
        method=method,
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
            "User-Agent": "flightclaw/1.0",
        },
    )

    try:
        with urllib.request.urlopen(req) as resp:
            return json.loads(resp.read())
    except urllib.error.HTTPError as e:
        error_body = e.read().decode()
        try:
            err = json.loads(error_body)
            msg = err.get("error", error_body)
        except json.JSONDecodeError:
            msg = error_body
        raise RuntimeError(f"API error ({e.code}): {msg}")


def is_configured():
    """Check if the API wrapper is configured."""
    return bool(
        os.environ.get("FLIGHTCLAW_API_URL")
        and os.environ.get("FLIGHTCLAW_API_KEY")
    )


def search(origin, destination, date, return_date=None, cabin="ECONOMY",
           adults=1, children=0, infants=0, max_connections=1):
    body = {
        "origin": origin, "destination": destination, "date": date,
        "cabin": cabin, "adults": adults, "children": children,
        "infants": infants, "max_connections": max_connections,
    }
    if return_date:
        body["return_date"] = return_date
    return _request("POST", "/search", body)


def search_multi(slices, cabin="ECONOMY", adults=1, children=0, infants=0, max_connections=1):
    """Multi-city search. slices is a list of {origin, destination, date} dicts."""
    body = {
        "slices": slices, "cabin": cabin, "adults": adults,
        "children": children, "infants": infants, "max_connections": max_connections,
    }
    return _request("POST", "/search/multi", body)


def get_offer(offer_id):
    return _request("GET", "/offer", params={"offer_id": offer_id})


def get_seat_map(offer_id):
    return _request("GET", "/seat-map", params={"offer_id": offer_id})


def book(offer_id, passengers, payment_type="balance", services=None):
    body = {
        "offer_id": offer_id,
        "passengers": passengers,
        "payment_type": payment_type,
    }
    if services:
        body["services"] = services
    return _request("POST", "/book", body)


def hold(offer_id, passengers, services=None):
    body = {
        "offer_id": offer_id,
        "passengers": passengers,
    }
    if services:
        body["services"] = services
    return _request("POST", "/hold", body)


def pay(order_id, amount, currency, payment_type="balance"):
    return _request("POST", "/pay", {
        "order_id": order_id,
        "amount": amount,
        "currency": currency,
        "payment_type": payment_type,
    })


def get_order(order_id):
    return _request("GET", "/order", params={"order_id": order_id})


def request_change(order_id, slices_to_remove, slices_to_add):
    return _request("POST", "/change/request", {
        "order_id": order_id,
        "slices_to_remove": slices_to_remove,
        "slices_to_add": slices_to_add,
    })


def get_change_request(change_request_id):
    return _request("GET", "/change/request",
                     params={"change_request_id": change_request_id})


def create_change(change_offer_id):
    return _request("POST", "/change/create",
                     {"change_offer_id": change_offer_id})


def confirm_change(change_id, amount, currency, payment_type="balance"):
    return _request("POST", "/change/confirm", {
        "change_id": change_id,
        "amount": amount,
        "currency": currency,
        "payment_type": payment_type,
    })


def cancel(order_id):
    return _request("POST", "/cancel", {"order_id": order_id})


def confirm_cancel(cancellation_id):
    return _request("POST", "/cancel/confirm",
                     {"cancellation_id": cancellation_id})


def create_checkout(offer_id, passengers, amount, currency,
                    flight_summary="", services=None):
    body = {
        "offer_id": offer_id,
        "passengers": passengers,
        "amount": amount,
        "currency": currency,
        "flight_summary": flight_summary,
    }
    if services:
        body["services"] = services
    return _request("POST", "/checkout/create", body)


def get_webhook_alerts(order_id=None):
    params = {}
    if order_id:
        params["order_id"] = order_id
    return _request("GET", "/webhooks/alerts", params=params)

"""Duffel response formatters, order persistence, and helpers for FlightClaw."""

import json
import os

DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
ORDERS_FILE = os.path.join(DATA_DIR, "duffel_orders.json")


def load_orders():
    if os.path.exists(ORDERS_FILE):
        with open(ORDERS_FILE, "r") as f:
            return json.load(f)
    return []


def save_orders(orders):
    os.makedirs(DATA_DIR, exist_ok=True)
    with open(ORDERS_FILE, "w") as f:
        json.dump(orders, f, indent=2)


def upsert_order(order_data):
    orders = load_orders()
    for i, o in enumerate(orders):
        if o["id"] == order_data["id"]:
            orders[i] = order_data
            save_orders(orders)
            return
    orders.append(order_data)
    save_orders(orders)


def fmt_segment(seg):
    carrier = seg.get("marketing_carrier", {}).get("iata_code", "?")
    fnum = seg.get("marketing_carrier_flight_number", "")
    orig = seg.get("origin", {}).get("iata_code", "?")
    dest = seg.get("destination", {}).get("iata_code", "?")
    dep = seg.get("departing_at", "")[:16].replace("T", " ")
    arr = seg.get("arriving_at", "")[:16].replace("T", " ")
    return f"    {carrier}{fnum}: {orig} {dep} -> {dest} {arr}"


def fmt_offer(offer, index=None):
    prefix = f"Option {index}: " if index else ""
    owner = offer.get("owner", {}).get("name", "?")
    lines = [f"{prefix}{offer.get('total_currency')} {offer.get('total_amount')} | {owner}"]

    for s in offer.get("slices", []):
        orig = s.get("origin", {}).get("iata_code", "?")
        dest = s.get("destination", {}).get("iata_code", "?")
        dur = s.get("duration", "?")
        lines.append(f"  {orig} -> {dest} ({dur})")
        for seg in s.get("segments", []):
            lines.append(fmt_segment(seg))

    cond = offer.get("conditions", {})
    chg = cond.get("change_before_departure")
    if chg:
        if chg.get("allowed"):
            pen = f" (penalty: {chg['penalty_currency']} {chg['penalty_amount']})" if chg.get("penalty_amount") else ""
            lines.append(f"  Changeable: Yes{pen}")
        else:
            lines.append("  Changeable: No")

    ref = cond.get("refund_before_departure")
    if ref:
        if ref.get("allowed"):
            pen = f" (penalty: {ref['penalty_currency']} {ref['penalty_amount']})" if ref.get("penalty_amount") else ""
            lines.append(f"  Refundable: Yes{pen}")
        else:
            lines.append("  Refundable: No")

    lines.append(f"  Offer ID: {offer.get('id')}")
    expires = offer.get("expires_at", "")[:16].replace("T", " ")
    lines.append(f"  Expires: {expires}")
    return "\n".join(lines)


def fmt_order(order):
    lines = [
        f"Order: {order.get('id')}",
        f"Booking ref: {order.get('booking_reference')}",
        f"Airline: {order.get('owner', {}).get('name', '?')}",
        f"Total: {order.get('total_currency')} {order.get('total_amount')}",
    ]
    pax = ", ".join(
        f"{p.get('given_name')} {p.get('family_name')}"
        for p in order.get("passengers", [])
    )
    lines.append(f"Passengers: {pax}")

    for s in order.get("slices", []):
        orig = s.get("origin", {}).get("iata_code", "?")
        dest = s.get("destination", {}).get("iata_code", "?")
        changeable = "changeable" if s.get("changeable") else "not changeable"
        lines.append(f"  {orig} -> {dest} ({changeable})")
        for seg in s.get("segments", []):
            lines.append(fmt_segment(seg))

    if order.get("cancelled_at"):
        lines.append(f"  CANCELLED at {order['cancelled_at']}")
    return "\n".join(lines)


def fmt_change_offer(co, index=None):
    prefix = f"Option {index}: " if index else ""
    cost = float(co.get("change_total_amount", "0"))
    currency = co.get("change_total_currency") or co.get("new_total_currency", "?")
    penalty = ""
    if co.get("penalty_amount"):
        penalty = f" (penalty: {co['penalty_currency']} {co['penalty_amount']})"

    if cost > 0:
        cost_str = f"Additional cost: {currency} {co['change_total_amount']}{penalty}"
    elif cost < 0:
        cost_str = f"Refund: {currency} {abs(cost):.2f}{penalty}"
    else:
        cost_str = f"No additional cost{penalty}"

    lines = [f"{prefix}{cost_str}"]
    lines.append(f"  New total: {co.get('new_total_currency')} {co.get('new_total_amount')}")

    for s in co.get("slices", {}).get("add", []):
        orig = s.get("origin", {}).get("iata_code", "?")
        dest = s.get("destination", {}).get("iata_code", "?")
        dur = s.get("duration", "?")
        lines.append(f"  NEW: {orig} -> {dest} ({dur})")
        for seg in s.get("segments", []):
            lines.append(fmt_segment(seg))

    lines.append(f"  Change offer ID: {co.get('id')}")
    expires = co.get("expires_at", "")[:16].replace("T", " ")
    lines.append(f"  Expires: {expires}")
    return "\n".join(lines)


def _load_traveler_map():
    """Build {name: profile} from the backend, falling back to local JSON."""
    try:
        import profile_api
        if profile_api.is_configured():
            return {t["name"]: t for t in profile_api.list_travelers()}
    except Exception:
        pass
    from passenger_profiles import load_passengers
    return {p["name"]: p for p in load_passengers()}


def resolve_passengers(passengers_str):
    """Resolve passenger string to list of dicts.
    Accepts JSON array or comma-separated traveler profile names.
    Names resolve from the backend traveler store (falls back to local JSON).
    Returns (list, None) on success or (None, error_str) on failure.
    """
    try:
        return json.loads(passengers_str), None
    except (json.JSONDecodeError, ValueError):
        pass

    profile_map = _load_traveler_map()
    names = [n.strip().lower() for n in passengers_str.split(",")]
    pax = []
    for name in names:
        if name not in profile_map:
            return None, f"Unknown traveler '{name}'. Use list_travelers."
        p = profile_map[name]
        pax.append({
            "given_name": p["given_name"],
            "family_name": p["family_name"],
            "born_on": p.get("born_on"),
            "gender": p.get("gender"),
            "title": p.get("title"),
            "email": p.get("email"),
            "phone_number": p.get("phone_number"),
        })
    return pax, None

"""Duffel + Link agent-billing tools — pay for Duffel bookings via a Link virtual card."""

import json
import os

import duffel_api
import link_payment
from duffel_fmt import fmt_offer, resolve_passengers


def _amount_to_cents(amount_str, currency):
    """Convert a Duffel amount string ('234.50') + currency to integer minor units."""
    zero_decimal = {"JPY", "KRW", "VND", "CLP", "ISK", "UGX", "RWF", "PYG"}
    amount = float(amount_str)
    if currency.upper() in zero_decimal:
        return int(round(amount))
    return int(round(amount * 100))


def _build_context(offer, passengers):
    """Produce the >=100-char context string the user sees in the approval dialog."""
    pax_count = len(passengers) if passengers else 1
    legs = []
    for s in offer.get("slices", []):
        orig = s.get("origin", {}).get("iata_code", "?")
        dest = s.get("destination", {}).get("iata_code", "?")
        segs = s.get("segments", [])
        dep = segs[0].get("departing_at", "")[:10] if segs else ""
        legs.append(f"{orig}->{dest} {dep}".strip())
    route = "; ".join(legs) or "flight booking"
    owner = offer.get("owner", {}).get("name", "airline")
    total = f"{offer.get('total_currency')} {offer.get('total_amount')}"
    ctx = (
        f"Flight booking via Duffel on {owner}. "
        f"Route: {route}. Passengers: {pax_count}. Total: {total}. "
        f"Payment will be charged to the airline/OTA at checkout."
    )
    while len(ctx) < 100:
        ctx += " Booked through FlightClaw."
    return ctx


def _build_line_items(offer):
    items = []
    base = offer.get("base_amount")
    tax = offer.get("tax_amount")
    currency = offer.get("total_currency", "")
    if base:
        items.append(f"description:Base fare,amount:{_amount_to_cents(base, currency)}")
    if tax:
        items.append(f"description:Taxes & fees,amount:{_amount_to_cents(tax, currency)}")
    return items


def register_duffel_link_tools(mcp):
    """Register the Duffel + Link agent-billing tools on the MCP server."""

    @mcp.tool()
    def link_list_payment_methods() -> str:
        """List Link payment methods on the user's account. Use to pick a payment_method_id."""
        try:
            methods = link_payment.list_payment_methods()
        except link_payment.LinkError as e:
            return f"Link error: {e}"
        if not methods:
            return "No payment methods. Run `link-cli payment-methods add` to add one."
        lines = []
        for m in methods:
            brand = m.get("brand") or m.get("card_brand") or ""
            last4 = m.get("last4") or m.get("card_last4") or ""
            label = f"{brand} ****{last4}".strip()
            lines.append(f"  {m.get('id', '?')}  {label}")
        return "\n".join(lines)

    @mcp.tool()
    def duffel_book_with_link(
        offer_id: str,
        passengers: str,
        payment_method_id: str | None = None,
        services: str | None = None,
        test: bool = False,
    ) -> str:
        """Pay for a Duffel offer with a Link virtual card. Returns card details + Duffel checkout URL.

        Flow:
          1. Fetches the offer to get amount/currency/summary.
          2. Creates a Duffel hosted checkout page (server-side).
          3. Creates a Link spend request for the offer amount and waits for user approval.
          4. On approval, returns the virtual card credential and the checkout URL.
          5. The agent then uses Chrome browser automation to enter the card on the checkout page.

        Args:
            offer_id: Duffel offer ID (from duffel_search_flights).
            passengers: Comma-separated profile names ("jack,jane") or JSON passenger array.
            payment_method_id: Link payment method ID. Omit to use the first one on the account.
            services: Optional JSON array of extras, e.g. [{"id":"ase_xxx","quantity":1}].
            test: If True, creates a Link testmode credential.
        """
        if not link_payment.is_authenticated():
            return "Not signed in to link-cli. Run `link-cli auth login` first."

        pax, err = resolve_passengers(passengers)
        if err:
            return err

        try:
            offer = duffel_api.get_offer(offer_id)
        except Exception as e:
            return f"Could not fetch offer: {e}"

        amount_str = offer.get("total_amount")
        currency = offer.get("total_currency")
        if not amount_str or not currency:
            return "Offer is missing total_amount/total_currency."

        if pax and not pax[0].get("id"):
            offer_pax = offer.get("passengers", [])
            for i, p in enumerate(pax):
                if i < len(offer_pax):
                    p["id"] = offer_pax[i]["id"]

        svc_list = None
        if services:
            try:
                svc_list = json.loads(services)
            except json.JSONDecodeError as e:
                return f"Invalid services JSON: {e}"

        summary = fmt_offer(offer)

        try:
            checkout = duffel_api.create_checkout(
                offer_id, pax, amount_str, currency, summary, svc_list,
            )
        except Exception as e:
            return f"Checkout creation failed: {e}"

        base = os.environ.get("FLIGHTCLAW_API_URL", "").rstrip("/")
        checkout_url = f"{base}{checkout.get('checkout_url', '')}"
        fee = checkout.get("fee", 0)

        amount_cents = _amount_to_cents(amount_str, currency)
        if amount_cents > 50000:
            return (
                f"Offer total {currency} {amount_str} ({amount_cents}c) exceeds Link's "
                f"$500 spend-request limit. Use duffel_book_flight (Duffel balance) instead."
            )

        try:
            pm_id = payment_method_id or link_payment.first_payment_method_id()
        except link_payment.LinkError as e:
            return f"Link error: {e}"

        context = _build_context(offer, pax)
        line_items = _build_line_items(offer)
        total = [f"description:Total,amount:{amount_cents}"]

        try:
            spend_request = link_payment.create_card_spend_request(
                payment_method_id=pm_id,
                amount_cents=amount_cents,
                currency=currency,
                merchant_name=offer.get("owner", {}).get("name") or "Duffel",
                merchant_url=checkout_url,
                context=context,
                line_items=line_items,
                total=total,
                test=test,
            )
        except link_payment.LinkError as e:
            return f"Spend request failed: {e}"

        sr = spend_request[0] if isinstance(spend_request, list) else spend_request
        status = (sr or {}).get("status", "unknown")
        sr_id = (sr or {}).get("id", "")

        if status != "approved":
            return f"Spend request {sr_id} ended with status: {status}."

        try:
            full = link_payment.retrieve_with_card(sr_id)
        except link_payment.LinkError as e:
            return f"Could not retrieve card: {e}"

        full = full[0] if isinstance(full, list) else full
        card = link_payment.extract_card(full or {})
        if not card or not card.get("number"):
            return f"Spend request {sr_id} approved but no card credential was returned."

        return (
            f"Link payment approved (spend_request={sr_id}).\n\n"
            f"Duffel checkout URL: {checkout_url}\n"
            f"Service fee included: {currency} {fee:.2f}\n\n"
            f"Virtual card to enter on the checkout page:\n"
            f"  Number: {card['number']}\n"
            f"  Expiry: {card['exp_month']:02d}/{card['exp_year']}\n"
            f"  CVC:    {card['cvc']}\n"
            f"  Holder: {card.get('holder_name') or '(use any name)'}\n\n"
            f"{summary}\n\n"
            f"Next step: use Chrome automation to navigate to the checkout URL and "
            f"submit these card details. Confirm with the user before submitting."
        )

"""Duffel MCP tools for FlightClaw - search, booking, and order management."""

import json

import duffel_api
from duffel_fmt import (
    fmt_change_offer,
    fmt_offer,
    fmt_order,
    load_orders,
    resolve_passengers,
    upsert_order,
)


def register_duffel_tools(mcp):
    """Register all Duffel tools on the MCP server."""

    @mcp.tool(annotations={"readOnlyHint": True, "idempotentHint": True})
    def duffel_search_flights(
        origin: str,
        destination: str,
        date: str,
        return_date: str | None = None,
        cabin: str = "ECONOMY",
        adults: int = 1,
        children: int = 0,
        infants: int = 0,
        results: int = 5,
        max_connections: int = 1,
    ) -> str:
        """Search bookable flights via Duffel with real-time fares and conditions.

        Args:
            origin: Origin IATA code (e.g. LHR)
            destination: Destination IATA code (e.g. JFK)
            date: Departure date (YYYY-MM-DD)
            return_date: Return date for round trips (YYYY-MM-DD)
            cabin: ECONOMY, PREMIUM_ECONOMY, BUSINESS, or FIRST
            adults: Adults (default 1)
            children: Children (default 0)
            infants: Infants (default 0)
            results: Max results (default 5)
            max_connections: Max connections per slice (default 1)
        """
        try:
            data = duffel_api.search(
                origin.strip().upper(), destination.strip().upper(),
                date, return_date, cabin, adults, children, infants,
                max_connections,
            )
        except Exception as e:
            return f"Search error: {e}"

        offers = data.get("offers", [])
        if not offers:
            return f"No flights found for {origin} -> {destination} on {date}"

        offers.sort(key=lambda o: float(o.get("total_amount", "999999")))
        show = offers[:results]

        route = f"{origin} -> {destination}"
        if return_date:
            route += f" (return {return_date})"

        output = [f"Duffel search: {route} on {date} ({cabin})", ""]
        for i, offer in enumerate(show, 1):
            output.append(fmt_offer(offer, index=i))
            output.append("")

        output.append(f"{len(offers)} offer(s) found. Showing top {len(show)}.")
        output.append("Use duffel_book_flight with an offer ID to book.")
        return "\n".join(output)

    @mcp.tool(annotations={"readOnlyHint": True, "idempotentHint": True})
    def duffel_search_multi_city(
        slices: str,
        cabin: str = "ECONOMY",
        adults: int = 1,
        children: int = 0,
        infants: int = 0,
        results: int = 5,
        max_connections: int = 1,
    ) -> str:
        """Search multi-city flights via Duffel.

        Args:
            slices: JSON array, e.g. [{"origin":"LHR","destination":"JFK","date":"2026-07-01"},
                {"origin":"JFK","destination":"LAX","date":"2026-07-05"}]
            cabin: ECONOMY, PREMIUM_ECONOMY, BUSINESS, or FIRST
            adults: Adults (default 1)
            children: Children (default 0)
            infants: Infants (default 0)
            results: Max results (default 5)
            max_connections: Max connections per slice (default 1)
        """
        try:
            slice_list = json.loads(slices)
        except json.JSONDecodeError as e:
            return f"Invalid slices JSON: {e}"

        if not isinstance(slice_list, list) or len(slice_list) < 2:
            return "Slices must be a JSON array with at least 2 segments."

        for s in slice_list:
            if not all(k in s for k in ("origin", "destination", "date")):
                return "Each slice must have origin, destination, and date."

        try:
            data = duffel_api.search_multi(
                slice_list, cabin, adults, children, infants, max_connections,
            )
        except Exception as e:
            return f"Search error: {e}"

        offers = data.get("offers", [])
        if not offers:
            route = " -> ".join(
                f"{s['origin']}-{s['destination']}" for s in slice_list
            )
            return f"No multi-city flights found for {route}"

        offers.sort(key=lambda o: float(o.get("total_amount", "999999")))
        show = offers[:results]

        route = " -> ".join(
            f"{s['origin']}-{s['destination']}" for s in slice_list
        )
        output = [f"Multi-city search: {route} ({cabin})", ""]
        for i, offer in enumerate(show, 1):
            output.append(fmt_offer(offer, index=i))
            output.append("")

        output.append(f"{len(offers)} offer(s) found. Showing top {len(show)}.")
        output.append("Use duffel_book_flight with an offer ID to book.")
        return "\n".join(output)

    @mcp.tool(annotations={"readOnlyHint": True, "idempotentHint": True})
    def duffel_get_offer(offer_id: str) -> str:
        """Get offer details including conditions and available extras.

        Args:
            offer_id: Duffel offer ID from search results
        """
        try:
            offer = duffel_api.get_offer(offer_id)
        except Exception as e:
            return f"Error: {e}"

        lines = [fmt_offer(offer)]

        services = offer.get("available_services") or []
        if services:
            lines.append("\nAvailable extras:")
            for svc in services:
                stype = svc.get("type", "?")
                price = f"{offer.get('total_currency')} {svc.get('total_amount')}"
                meta = svc.get("metadata", {})
                desc = meta.get("type", stype)
                if meta.get("maximum_weight_kg"):
                    desc += f" ({meta['maximum_weight_kg']}kg)"
                lines.append(f"  {desc}: {price} (max qty: {svc.get('maximum_quantity', 1)}) | ID: {svc['id']}")
            lines.append("\nPass service IDs to duffel_book_flight via services parameter.")

        return "\n".join(lines)

    @mcp.tool(annotations={"readOnlyHint": True, "idempotentHint": True})
    def duffel_get_seat_map(offer_id: str) -> str:
        """Get seat map with available seats and prices.

        Args:
            offer_id: Duffel offer ID from search results
        """
        try:
            seat_maps = duffel_api.get_seat_map(offer_id)
        except Exception as e:
            return f"Error: {e}"

        if not seat_maps:
            return "No seat map available for this offer."

        output = []
        for sm in seat_maps:
            segment = sm.get("segment_id", "?")
            output.append(f"Segment: {segment}")
            cabins = sm.get("cabins", [])
            for cabin_info in cabins:
                cabin_class = cabin_info.get("cabin_class", "?")
                output.append(f"  Cabin: {cabin_class}")
                rows = cabin_info.get("rows", [])
                for row in rows:
                    sections = row.get("sections", [])
                    for section in sections:
                        seats = section.get("elements", [])
                        for seat in seats:
                            if seat.get("type") != "seat":
                                continue
                            designator = seat.get("designator", "?")
                            available = seat.get("available_services", [])
                            if not available:
                                continue
                            svc = available[0]
                            price = f"{svc.get('total_currency', '?')} {svc.get('total_amount', '?')}"
                            disclosures = ", ".join(seat.get("disclosures", []))
                            extra = f" ({disclosures})" if disclosures else ""
                            output.append(f"    {designator}: {price}{extra} | ID: {svc.get('id', '?')}")
            output.append("")

        output.append("Pass seat service IDs to duffel_book_flight via services parameter.")
        return "\n".join(output)

    @mcp.tool(annotations={"idempotentHint": False})
    def duffel_book_flight(
        offer_id: str,
        passengers: str,
        payment_type: str = "balance",
        services: str | None = None,
    ) -> str:
        """Book a flight. Accepts profile names or JSON passenger array.

        Args:
            offer_id: Offer ID from search results
            passengers: Comma-separated profile names (e.g. "jack,jane") or
                JSON array with given_name, family_name, born_on, gender, title, email, phone_number
            payment_type: "balance" or "arc_bsp_cash"
            services: Optional JSON array e.g. [{"id":"ase_xxx","quantity":1}]
        """
        pax, err = resolve_passengers(passengers)
        if err:
            return err

        # Auto-assign offer passenger IDs if missing
        if pax and not pax[0].get("id"):
            try:
                offer = duffel_api.get_offer(offer_id)
                offer_pax = offer.get("passengers", [])
                for i, p in enumerate(pax):
                    if i < len(offer_pax):
                        p["id"] = offer_pax[i]["id"]
            except Exception:
                pass  # Let Duffel return the error if IDs are wrong

        svc_list = None
        if services:
            try:
                svc_list = json.loads(services)
            except json.JSONDecodeError as e:
                return f"Invalid services JSON: {e}"

        try:
            order = duffel_api.book(offer_id, pax, payment_type, svc_list)
        except Exception as e:
            return f"Booking failed: {e}"

        upsert_order(order)
        return "Flight booked!\n\n" + fmt_order(order)

    @mcp.tool(annotations={"readOnlyHint": True})
    def duffel_list_orders() -> str:
        """List all Duffel orders stored locally."""
        orders = load_orders()
        if not orders:
            return "No Duffel orders. Use duffel_book_flight to create one."
        output = [fmt_order(o) for o in orders]
        output.append(f"\n{len(orders)} order(s).")
        return "\n\n".join(output)

    @mcp.tool(annotations={"idempotentHint": True})  # persists via upsert_order; not read-only
    def duffel_get_order(order_id: str) -> str:
        """Get live order status from Duffel.

        Args:
            order_id: Duffel order ID (e.g. ord_xxx)"""
        try:
            order = duffel_api.get_order(order_id)
        except Exception as e:
            return f"Error: {e}"
        upsert_order(order)
        return fmt_order(order)

    @mcp.tool(annotations={"idempotentHint": False})
    def duffel_request_change(
        order_id: str,
        new_date: str,
        slice_index: int = 0,
        new_origin: str | None = None,
        new_destination: str | None = None,
        cabin: str | None = None,
    ) -> str:
        """Request a flight change. Returns options with fees.

        Args:
            order_id: Duffel order ID
            new_date: New departure date (YYYY-MM-DD)
            slice_index: 0=outbound, 1=return
            new_origin: New origin IATA (optional)
            new_destination: New destination IATA (optional)
            cabin: ECONOMY, PREMIUM_ECONOMY, BUSINESS, or FIRST (optional)
        """
        try:
            order = duffel_api.get_order(order_id)
        except Exception as e:
            return f"Error: {e}"

        slices = order.get("slices", [])
        if slice_index >= len(slices):
            return f"Invalid slice_index {slice_index}. Order has {len(slices)} slice(s)."

        target = slices[slice_index]
        if not target.get("changeable"):
            orig = target.get("origin", {}).get("iata_code", "?")
            dest = target.get("destination", {}).get("iata_code", "?")
            return f"Slice {slice_index} ({orig} -> {dest}) is not changeable."

        origin = new_origin or target["origin"]["iata_code"]
        destination = new_destination or target["destination"]["iata_code"]

        cabin_map = {"ECONOMY": "economy", "PREMIUM_ECONOMY": "premium_economy",
                     "BUSINESS": "business", "FIRST": "first"}
        if cabin and cabin not in cabin_map:
            return f"Unknown cabin '{cabin}'. Use ECONOMY, PREMIUM_ECONOMY, BUSINESS, or FIRST."
        cabin_class = cabin_map.get(cabin) if cabin else None
        if not cabin_class:
            segs = target.get("segments", [])
            if segs and segs[0].get("passengers"):
                cabin_class = segs[0]["passengers"][0].get("cabin_class", "economy")
            else:
                cabin_class = "economy"

        try:
            result = duffel_api.request_change(
                order_id,
                [{"slice_id": target["id"]}],
                [{"origin": origin.upper(), "destination": destination.upper(),
                  "departure_date": new_date, "cabin_class": cabin_class}],
            )
        except Exception as e:
            return f"Change request failed: {e}"

        offers = result.get("order_change_offers", [])
        if not offers:
            return f"No change options for {origin} -> {destination} on {new_date}."

        output = [f"Change options for order {order_id}:", ""]
        for i, co in enumerate(offers, 1):
            output.append(fmt_change_offer(co, index=i))
            output.append("")

        output.append(f"{len(offers)} option(s). Use duffel_confirm_change with a change_offer_id.")
        return "\n".join(output)

    @mcp.tool(annotations={"idempotentHint": False})
    def duffel_confirm_change(
        change_offer_id: str,
        payment_type: str = "balance",
    ) -> str:
        """Confirm a flight change from duffel_request_change.

        Args:
            change_offer_id: Change offer ID
            payment_type: "balance" or "arc_bsp_cash" """
        try:
            change = duffel_api.create_change(change_offer_id)
        except Exception as e:
            return f"Change failed: {e}"

        amount = float(change.get("change_total_amount", "0"))
        currency = change.get("change_total_currency", "GBP")

        try:
            duffel_api.confirm_change(
                change["id"], change.get("change_total_amount", "0"), currency, payment_type,
            )
        except Exception as e:
            return f"Confirm failed: {e}"

        lines = ["Flight changed!", f"Order {change.get('order_id')} updated."]
        if amount > 0:
            lines.append(f"Charged: {currency} {amount:.2f}")
        elif amount < 0:
            lines.append(f"Refund: {currency} {abs(amount):.2f}")
        lines.append("\nUse duffel_get_order to see updated details.")
        return "\n".join(lines)

    @mcp.tool(annotations={"destructiveHint": True})
    def duffel_cancel_order(order_id: str) -> str:
        """Request cancellation quote. Shows refund before confirming.

        Args:
            order_id: Duffel order ID"""
        try:
            cancellation = duffel_api.cancel(order_id)
        except Exception as e:
            return f"Cancel failed: {e}"

        lines = [
            f"Cancel quote for {order_id}:",
            f"  Refund: {cancellation.get('refund_currency')} {cancellation.get('refund_amount')}",
            f"  Refund to: {cancellation.get('refund_to')}",
            "",
            f"Confirm with duffel_confirm_cancel(cancellation_id=\"{cancellation.get('id')}\")",
        ]
        return "\n".join(lines)

    @mcp.tool(annotations={"destructiveHint": True, "idempotentHint": False})
    def duffel_confirm_cancel(cancellation_id: str) -> str:
        """Confirm cancellation. Irreversible.

        Args:
            cancellation_id: From duffel_cancel_order"""
        try:
            result = duffel_api.confirm_cancel(cancellation_id)
        except Exception as e:
            return f"Confirm failed: {e}"

        return (
            f"Order {result.get('order_id')} cancelled. "
            f"Refund: {result.get('refund_currency')} {result.get('refund_amount')}"
        )

    @mcp.tool(annotations={"idempotentHint": False})
    def duffel_create_checkout(
        offer_id: str,
        passengers: str,
        services: str | None = None,
    ) -> str:
        """Create a checkout page for card payment. Returns URL for user to pay.

        Args:
            offer_id: Offer ID from search results
            passengers: Profile names (e.g. "jack,jane") or JSON passenger array
            services: Optional JSON array e.g. [{"id":"ase_xxx","quantity":1}]
        """
        pax, err = resolve_passengers(passengers)
        if err:
            return err

        svc_list = None
        if services:
            try:
                svc_list = json.loads(services)
            except json.JSONDecodeError as e:
                return f"Invalid services JSON: {e}"

        # Get offer to know amount/currency and assign passenger IDs
        try:
            offer = duffel_api.get_offer(offer_id)
        except Exception as e:
            return f"Error: {e}"

        if pax and not pax[0].get("id"):
            offer_pax = offer.get("passengers", [])
            for i, p in enumerate(pax):
                if i < len(offer_pax):
                    p["id"] = offer_pax[i]["id"]

        summary = fmt_offer(offer)

        try:
            result = duffel_api.create_checkout(
                offer_id, pax,
                offer.get("total_amount"), offer.get("total_currency"),
                summary, svc_list,
            )
        except Exception as e:
            return f"Checkout creation failed: {e}"

        import os
        base = os.environ.get("FLIGHTCLAW_API_URL", "").rstrip("/")
        checkout_path = result.get("checkout_url", "")
        url = f"{base}{checkout_path}"
        fee = result.get("fee", 0)
        return (
            f"Checkout page created.\n\nURL: {url}\n"
            f"Fee included: {offer.get('total_currency')} {fee:.2f}\n\n"
            f"Send this URL to the passenger to complete card payment."
        )

    @mcp.tool(annotations={"readOnlyHint": True, "idempotentHint": True})
    def duffel_check_alerts(order_id: str | None = None) -> str:
        """Check for airline-initiated changes or updates on orders.

        Args:
            order_id: Order ID to check (optional, omit for all recent)
        """
        try:
            result = duffel_api.get_webhook_alerts(order_id)
        except Exception as e:
            return f"Error: {e}"

        alerts = result.get("alerts", [])
        events = result.get("events", [])
        items = alerts or events

        if not items:
            return "No alerts." if not order_id else f"No alerts for {order_id}."
        lines = []
        for item in items:
            lines.append(f"  {item.get('type', item.get('summary', '?'))} ({item.get('created_at', '?')})")
        return f"{len(items)} alert(s):\n" + "\n".join(lines)

"""Booking fulfillment beyond Duffel.

Extends bookable coverage with Kiwi.com (Tequila API) when a key is configured,
and always offers an affiliate / deep-link hand-off as the universal fallback so
no recommended flight is ever a dead end.

Env:
  KIWI_API_KEY   Tequila API key — enables the Kiwi bookability check (search).
  KIWI_AFFILID   Kiwi affiliate id — used for monetised hand-off deep links.
Note: Kiwi *search* works with an API key; actually *booking* via Kiwi's API
needs a commercial deposit account. Until then, Kiwi-covered flights are handed
off via deep link.
"""

import json
import os
import urllib.parse
import urllib.request

GOOGLE_BOOKING_URL = "https://www.google.com/travel/flights/booking?tfs="
TEQUILA_SEARCH = "https://api.tequila.kiwi.com/v2/search"


def _digits(n):
    return "".join(c for c in str(n) if c.isdigit())


def _kiwi_date(d):
    """YYYY-MM-DD -> dd/mm/yyyy (Tequila format)."""
    try:
        y, m, day = d.split("-")
        return f"{day}/{m}/{y}"
    except ValueError:
        return d


def kiwi_configured():
    return bool(os.environ.get("KIWI_API_KEY"))


def kiwi_index(origin, destination, date, return_date=None):
    """Look up what Kiwi can book on this route.

    Returns {segments:set[(carrier,fnum)], deep_link:str|None} or None if Kiwi
    isn't configured or the search fails.
    """
    key = os.environ.get("KIWI_API_KEY")
    if not key:
        return None
    params = {
        "fly_from": origin,
        "fly_to": destination,
        "date_from": _kiwi_date(date),
        "date_to": _kiwi_date(date),
        "curr": "GBP",
        "limit": 200,
        "vehicle_type": "aircraft",
    }
    if return_date:
        params["return_from"] = _kiwi_date(return_date)
        params["return_to"] = _kiwi_date(return_date)
    url = f"{TEQUILA_SEARCH}?{urllib.parse.urlencode(params)}"
    req = urllib.request.Request(url, headers={"apikey": key, "accept": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=20) as r:
            data = json.loads(r.read())
    except Exception:
        return None
    segments = set()
    itineraries = data.get("data", []) or []
    for it in itineraries:
        for leg in it.get("route", []):
            c = leg.get("airline")
            fn = _digits(leg.get("flight_no", ""))
            if c and fn:
                segments.add((c, fn))
    deep = itineraries[0].get("deep_link") if itineraries else None
    return {"segments": segments, "deep_link": deep}


def book_direct_link(origin, destination, date, google_token=None):
    """A tappable hand-off link for flights we can't book in-app.

    Prefers a monetised Kiwi affiliate deep link, then the precise Google Flights
    booking link, then a generic Skyscanner search.
    """
    affil = os.environ.get("KIWI_AFFILID")
    if affil:
        q = urllib.parse.urlencode({
            "from": origin, "to": destination,
            "departure": date, "affilid": affil,
        })
        return f"https://www.kiwi.com/deep?{q}"
    if google_token:
        return GOOGLE_BOOKING_URL + urllib.parse.quote(google_token, safe="")
    ymd = date.replace("-", "")[2:]  # yymmdd
    return f"https://www.skyscanner.net/transport/flights/{origin}/{destination}/{ymd}/"

"""Companion group tools for FlightClaw — backend (D1) backed.

Save named groups of travelers (e.g. 'family' = jack,jane,kid) so "who are you
travelling with?" is answered once and reused. Group members are traveler name
keys; pass the returned comma-separated names straight to booking tools.
"""

import profile_api


def register_group_tools(mcp):
    """Register companion-group tools on the MCP server."""

    @mcp.tool()
    def save_group(name: str, members: str) -> str:
        """Save or update a named travel group for reuse.

        Args:
            name: Group name, e.g. 'family' or 'work-trip'
            members: Comma-separated traveler name keys (e.g. 'jack,jane'). Save each
                traveler with save_traveler first.
        """
        member_list = [m.strip().lower() for m in members.split(",") if m.strip()]
        if not member_list:
            return "Provide at least one member name."
        # Warn about unknown members but still save (they can be added later).
        try:
            known = {t["name"] for t in profile_api.list_travelers()}
            unknown = [m for m in member_list if m not in known]
            result = profile_api.upsert_group(name, member_list)
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        out = f"Saved group '{result['name']}': {', '.join(result['members'])}."
        if unknown:
            out += f"\nWarning: not yet saved as travelers: {', '.join(unknown)} (use save_traveler)."
        return out

    @mcp.tool()
    def list_groups() -> str:
        """List all saved travel groups."""
        try:
            groups = profile_api.get_groups()
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        if not groups:
            return "No groups saved. Use save_group."
        lines = [f"  {g['name']}: {', '.join(g['members']) or '(empty)'}" for g in groups]
        lines.append(f"\n{len(groups)} group(s).")
        return "\n".join(lines)

    @mcp.tool()
    def get_group(name: str) -> str:
        """Get a group's members, ready to pass to booking/recommendation tools.

        Returns the comma-separated traveler names (use directly as the `passengers`
        argument of duffel_book_with_link / duffel_book_flight) plus a roster.

        Args:
            name: Group name (e.g. 'family')
        """
        key = name.lower().strip()
        try:
            groups = profile_api.get_groups()
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        group = next((g for g in groups if g["name"] == key), None)
        if not group:
            return f"No group '{key}'. Use list_groups to see saved groups."
        members = group["members"]
        if not members:
            return f"Group '{key}' has no members."
        lines = [f"Group '{key}' — passengers: {','.join(members)}", "Roster:"]
        for m in members:
            try:
                t = profile_api.get_traveler(m)
            except profile_api.ProfileError:
                t = {"error": "lookup failed"}
            if "error" in t:
                lines.append(f"  {m}: (not found — save with save_traveler)")
            else:
                lines.append(f"  {m}: {t['given_name']} {t['family_name']}")
        return "\n".join(lines)

    @mcp.tool()
    def delete_group(name: str) -> str:
        """Delete a saved travel group.

        Args:
            name: Group name to delete
        """
        try:
            result = profile_api.delete_group(name)
        except profile_api.ProfileError as e:
            return f"Error: {e}"
        if not result.get("ok"):
            return f"No group '{name}' found."
        return f"Deleted group '{name}'."

"""Shared helpers for FlightClaw - filters, formatting, data persistence."""

import json
import os
from datetime import datetime, timedelta
from itertools import product

from fli.core import (
    build_date_search_segments,
    build_flight_segments,
    build_time_restrictions,
    parse_airlines as fli_parse_airlines,
    parse_cabin_class,
    parse_emissions,
    parse_max_stops,
    parse_sort_by,
    resolve_airport,
)
from fli.core.parsers import ParseError
from fli.models import (
    BagsFilter,
    DateSearchFilters,
    FlightSearchFilters,
    LayoverRestrictions,
    PassengerInfo,
    PriceLimit,
    SortBy,
)

from search_utils import fmt_price

DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
TRACKED_FILE = os.path.join(DATA_DIR, "tracked.json")


def load_tracked():
    if os.path.exists(TRACKED_FILE):
        with open(TRACKED_FILE, "r") as f:
            return json.load(f)
    return []


def save_tracked(tracked):
    os.makedirs(DATA_DIR, exist_ok=True)
    with open(TRACKED_FILE, "w") as f:
        json.dump(tracked, f, indent=2)


def expand_routes(origins_str, destinations_str, date_str, date_to_str=None):
    origins = [o.strip().upper() for o in origins_str.split(",")]
    destinations = [d.strip().upper() for d in destinations_str.split(",")]
    start = datetime.strptime(date_str, "%Y-%m-%d").date()
    end = datetime.strptime(date_to_str, "%Y-%m-%d").date() if date_to_str else start
    dates = []
    current = start
    while current <= end:
        dates.append(current.strftime("%Y-%m-%d"))
        current += timedelta(days=1)
    return list(product(origins, destinations, dates))


def parse_airlines(airlines_str):
    """Parse comma-separated airline codes string into Airline enums."""
    if not airlines_str:
        return None
    codes = [c.strip().upper() for c in airlines_str.split(",")]
    try:
        return fli_parse_airlines(codes)
    except ParseError:
        # Silently skip invalid codes for backwards compat
        from fli.models import Airline
        result = []
        for code in codes:
            try:
                result.append(getattr(Airline, code))
            except AttributeError:
                pass
        return result or None


def _build_departure_window(earliest_departure, latest_departure):
    """Convert individual hour ints to 'HH-HH' window string."""
    if earliest_departure is not None and latest_departure is not None:
        return f"{earliest_departure}-{latest_departure}"
    if earliest_departure is not None:
        return f"{earliest_departure}-23"
    if latest_departure is not None:
        return f"0-{latest_departure}"
    return None


def build_filters(
    orig_code, dest_code, date, return_date=None, cabin="ECONOMY", stops="ANY",
    adults=1, children=0, infants_in_seat=0, infants_on_lap=0,
    airlines=None, max_price=None, max_duration=None,
    earliest_departure=None, latest_departure=None,
    earliest_arrival=None, latest_arrival=None,
    max_layover_duration=None, sort_by=None,
    exclude_basic_economy=False, emissions="ALL",
    checked_bags=0, carry_on=False, show_all_results=True,
):
    if not 0 <= checked_bags <= 2:
        raise ParseError("checked_bags must be between 0 and 2")
    origin = resolve_airport(orig_code)
    destination = resolve_airport(dest_code)

    dep_window = _build_departure_window(earliest_departure, latest_departure)
    arr_window = _build_departure_window(earliest_arrival, latest_arrival)
    time_restrictions = build_time_restrictions(dep_window, arr_window)

    segments, trip_type = build_flight_segments(
        origin=origin,
        destination=destination,
        departure_date=date,
        return_date=return_date,
        time_restrictions=time_restrictions,
    )

    price_limit = PriceLimit(max_price=max_price) if max_price else None
    layover = LayoverRestrictions(max_duration=max_layover_duration) if max_layover_duration else None
    bags = BagsFilter(checked_bags=checked_bags, carry_on=carry_on) if checked_bags or carry_on else None

    return FlightSearchFilters(
        trip_type=trip_type,
        passenger_info=PassengerInfo(
            adults=adults, children=children,
            infants_in_seat=infants_in_seat, infants_on_lap=infants_on_lap,
        ),
        flight_segments=segments,
        seat_type=parse_cabin_class(cabin),
        stops=parse_max_stops(stops),
        airlines=parse_airlines(airlines),
        price_limit=price_limit,
        max_duration=max_duration,
        layover_restrictions=layover,
        sort_by=parse_sort_by(sort_by) if sort_by else SortBy.BEST,
        exclude_basic_economy=exclude_basic_economy,
        emissions=parse_emissions(emissions),
        bags=bags,
        show_all_results=show_all_results,
    )


def build_date_filters(
    orig_code, dest_code, from_date, to_date,
    duration=None, is_round_trip=False,
    cabin="ECONOMY", stops="ANY",
    adults=1, children=0, infants_in_seat=0, infants_on_lap=0,
    airlines=None, max_price=None, max_duration=None,
    earliest_departure=None, latest_departure=None,
    earliest_arrival=None, latest_arrival=None,
    emissions="ALL", checked_bags=0, carry_on=False,
):
    if not 0 <= checked_bags <= 2:
        raise ParseError("checked_bags must be between 0 and 2")
    origin = resolve_airport(orig_code)
    destination = resolve_airport(dest_code)

    dep_window = _build_departure_window(earliest_departure, latest_departure)
    arr_window = _build_departure_window(earliest_arrival, latest_arrival)
    time_restrictions = build_time_restrictions(dep_window, arr_window)

    segments, trip_type = build_date_search_segments(
        origin=origin,
        destination=destination,
        start_date=from_date,
        trip_duration=duration,
        is_round_trip=is_round_trip,
        time_restrictions=time_restrictions,
    )

    price_limit = PriceLimit(max_price=max_price) if max_price else None
    bags = BagsFilter(checked_bags=checked_bags, carry_on=carry_on) if checked_bags or carry_on else None

    return DateSearchFilters(
        trip_type=trip_type,
        passenger_info=PassengerInfo(
            adults=adults, children=children,
            infants_in_seat=infants_in_seat, infants_on_lap=infants_on_lap,
        ),
        flight_segments=segments,
        seat_type=parse_cabin_class(cabin),
        stops=parse_max_stops(stops),
        airlines=parse_airlines(airlines),
        price_limit=price_limit,
        max_duration=max_duration,
        emissions=parse_emissions(emissions),
        bags=bags,
        from_date=from_date,
        to_date=to_date,
        duration=duration,
    )


def format_duration(minutes):
    h, m = divmod(minutes, 60)
    return f"{h}h {m}m"


def format_flight(flight, currency, index=None):
    cur = getattr(flight, "currency", None) or currency
    prefix = f"Option {index}: " if index else ""
    lines = [f"{prefix}{fmt_price(flight.price, cur)} | {format_duration(flight.duration)} | {flight.stops} stop(s)"]
    for leg in flight.legs:
        airline_code = leg.airline.name.lstrip("_")
        lines.append(f"  {airline_code} {leg.flight_number}: {leg.departure_airport.name} {leg.departure_datetime.strftime('%H:%M')} -> {leg.arrival_airport.name} {leg.arrival_datetime.strftime('%H:%M')}")
    return "\n".join(lines)