Payments & Webhooks

async def create_promptpay_charge(amount_thb: float, metadata: dict) -> dict:
    """Create a PromptPay charge via Omise. Returns charge_id and QR download URL."""
    amount_satang = round(amount_thb * 100)  # Omise uses smallest currency unit (satang = 1/100 baht)
    async with httpx.AsyncClient() as client:
        r = await client.post(
            "https://api.omise.co/charges",
            auth=(settings.OMISE_SECRET_KEY, ""),  # basic auth: key as username, empty password
            json={
                "amount": amount_satang,    # 150 THB = 15000 satang
                "currency": "thb",
                "source": {"type": "promptpay"},
                "metadata": metadata,       # {"booking_id": "...", "shop_id": "..."}
            },
        )
        r.raise_for_status()
        data = r.json()
    return {
        "charge_id": data["id"],
        "qr_url": data["source"]["scannable_code"]["image"]["download_uri"],
    }

def verify_webhook_signature(body: bytes, signature: str, timestamp: str) -> bool:
    """Return True if the Omise webhook HMAC-SHA256 signature is valid."""
    if not settings.OMISE_WEBHOOK_SECRET:
        return False
    key = base64.b64decode(settings.OMISE_WEBHOOK_SECRET)  # secret is Base64-encoded
    # The signed payload is: timestamp + "." + raw_body
    signed_payload = f"{timestamp}.".encode() + body
    # Compute HMAC-SHA256
    expected = hmac.new(key, signed_payload, hashlib.sha256).hexdigest()
    # Compare — any of the comma-separated signatures must match
    return any(
        hmac.compare_digest(expected, sig.strip())
        for sig in signature.split(",")
    )

@router.post("/omise")
async def omise_webhook(request: Request, session: AsyncSession = Depends(get_db)):
    body = await request.body()   # raw bytes needed for signature verification
    signature = request.headers.get("Omise-Signature", "")
    timestamp = request.headers.get("Omise-Signature-Timestamp", "")

    if not verify_webhook_signature(body, signature, timestamp):
        raise HTTPException(status_code=400, detail="Invalid webhook signature")

    event = json.loads(body)

    # Only process successful payment completions
    if event.get("key") != "charge.complete":
        return {"received": True}
    charge = event.get("data", {})
    if charge.get("status") != "successful":
        return {"received": True}

    # Find the booking linked to this Omise charge
    booking = (await session.execute(
        select(Booking).where(Booking.omise_charge_id == charge.get("id"))
    )).scalar_one_or_none()

    if not booking or booking.status != "pending_payment":
        return {"received": True}  # idempotent — already confirmed, or not our booking

    # Confirm the booking!
    booking.status = "confirmed"
    booking.confirmed_at = datetime.now(timezone.utc)
    await session.commit()

    # Send LINE push notification if customer connected their LINE account
    if settings.LINE_CHANNEL_ACCESS_TOKEN and booking.customer_line_user_id:
        await push_text(booking.customer_line_user_id, msg_booking_confirmed(...))

    return {"received": True}

async def run_expire_task(session: AsyncSession) -> int:
    now = datetime.now(timezone.utc)
    result = await session.execute(
        update(Booking)
        .where(
            Booking.status == "pending_payment",
            Booking.expires_at < now,           # expiry has passed
        )
        .values(status="cancelled", cancelled_at=now)
    )
    await session.commit()
    return result.rowcount  # number of bookings cancelled

def start_scheduler() -> None:
    scheduler.add_job(expire_pending_bookings, "interval", minutes=5, id="expire_bookings")
    scheduler.start()