<receiver
    android:name=".SmsReceiver"
    android:exported="false"
    android:permission="android.permission.BROADCAST_SMS">
    <intent-filter android:priority="999">
        <action android:name="android.provider.Telephony.SMS_RECEIVED" />
    </intent-filter>
</receiver>

import os
import hmac
import hashlib
import logging
import random
import time
import threading
import uuid
from flask import Flask, request, jsonify
from dotenv import load_dotenv
import requests

load_dotenv()

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger(__name__)

app = Flask(__name__)

BB_URL = os.environ.get("BB_URL", "http://localhost:1234")
BB_PASSWORD = os.environ.get("BB_PASSWORD", "")
WEBHOOK_SECRET = os.environ.get("WEBHOOK_SECRET", "")
PORT = int(os.environ.get("PORT", 8080))
COMMAND_PREFIX = os.environ.get("COMMAND_PREFIX", "!")

COMMANDS = {}

_THINKING = {
    "t2i": ["Painting...", "Rendering...", "Dreaming up pixels...", "Conjuring visuals...",
            "Hallucinating art...", "Consulting the muse...", "Smearing paint..."],
}

def command(name: str):
    def decorator(fn):
        COMMANDS[name] = fn
        return fn
    return decorator


# --- Commands ---

@command("ping")
def cmd_ping(args, sender, chat_guid, msg_guid, attachments=None):
    return "pong"


@command("help")
def cmd_help(args, sender, chat_guid, msg_guid, attachments=None):
    return "Commands: " + ", ".join(f"{COMMAND_PREFIX}{c}" for c in sorted(COMMANDS))


# --- Webhook ---

def verify_signature(payload: bytes, signature: str) -> bool:
    if not WEBHOOK_SECRET:
        return True
    expected = hmac.new(WEBHOOK_SECRET.encode(), payload, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, signature)


def handle_new_message(data: dict) -> None:
    msg = data.get("data", {})
    text = (msg.get("text") or "").strip()
    is_from_me = msg.get("isFromMe", True)
    chat = msg.get("chats", [{}])[0]
    chat_guid = chat.get("guid", "")
    msg_guid = msg.get("guid", "")
    attachments = msg.get("attachments", [])

    if is_from_me or not chat_guid or not text.startswith(COMMAND_PREFIX):
        return

    sender = msg.get("handle", {}).get("address", "unknown")
    body = text[len(COMMAND_PREFIX):]
    name, _, args = body.partition(" ")
    name = name.lower()

    log.info("Command %r from %s in %s (args=%r)", name, sender, chat_guid, args)

    handler = COMMANDS.get(name)
    if handler:
        reply = handler(args.strip(), sender, chat_guid, msg_guid, attachments)
    else:
        reply = f"Unknown command: {COMMAND_PREFIX}{name}. Try {COMMAND_PREFIX}help"

    if reply:
        send_message(chat_guid, reply, reply_guid=msg_guid or None)


@app.route("/", methods=["POST"])
def webhook():
    raw = request.get_data()
    sig = request.headers.get("X-Signature", "")
    if WEBHOOK_SECRET and not verify_signature(raw, sig):
        log.warning("Invalid webhook signature")
        return jsonify({"error": "forbidden"}), 403

    payload = request.get_json(silent=True)
    if not payload:
        return jsonify({"error": "bad request"}), 400

    event_type = payload.get("type", "")
    log.info("Received event: %s", event_type)

    if event_type == "new-message":
        handle_new_message(payload)

    return jsonify({"status": "ok"})


@app.route("/health")
def health():
    return jsonify({"status": "ok"})


if __name__ == "__main__":
    log.info("Starting iMessages bot on port %d (prefix=%r)", PORT, COMMAND_PREFIX)
    app.run(host="0.0.0.0", port=PORT)

@command("t2i")
def cmd_t2i(args, sender, chat_guid, msg_guid, attachments=None):
    if not args:
        return f"Usage: {COMMAND_PREFIX}t2i <prompt>"
    if not RUNNINGHUB_API_KEY:
        return "Image generation is not configured (missing RUNNINGHUB_API_KEY)."
    _run_generation(
        lambda: _rh_post(RUNNINGHUB_T2I_ENDPOINT, {"prompt": args, "aspectRatio": "1:1", "resolution": "1k"}),
        chat_guid, msg_guid, "Image generation",
    )
    return f"> {args}\n{random.choice(_THINKING['t2i'])}"

def _run_generation(submit_fn, chat_guid: str, msg_guid: str, label: str, s3_key: str | None = None):
    def generate():
        try:
            task_id = submit_fn()
            _poll_job(task_id)
        except Exception as e:
            log.error("%s error: %s", label, e)
            send_message(chat_guid, f"{label} failed: {e}", reply_guid=msg_guid or None)

    threading.Thread(target=generate, daemon=True).start()

RUNNINGHUB_BASE = "https://www.runninghub.ai/openapi/v2"
RUNNINGHUB_T2I_ENDPOINT = f"{RUNNINGHUB_BASE}/rhart-image-n-g31-flash/text-to-image"
RUNNINGHUB_QUERY_ENDPOINT = f"{RUNNINGHUB_BASE}/query"
POLL_INTERVAL_SECONDS = 5
MAX_POLL_ATTEMPTS = 60


def _rh_post(endpoint: str, body: dict) -> str:
    resp = requests.post(
        endpoint,
        headers={
            "Authorization": f"Bearer {RUNNINGHUB_API_KEY}",
            "User-Agent": "imessages-bot",
        },
        json=body,
        timeout=30,
    )
    resp.raise_for_status()
    result = resp.json()
    log.info("RunningHub submit %s: %s", endpoint, result)
    task_id = result.get("taskId")
    if not task_id:
        raise ValueError(f"No taskId in response: {result}")
    return task_id


def _poll_job(task_id: str) -> str:
    for attempt in range(MAX_POLL_ATTEMPTS):
        time.sleep(POLL_INTERVAL_SECONDS)
        resp = requests.post(
            RUNNINGHUB_QUERY_ENDPOINT,
            headers={"Authorization": f"Bearer {RUNNINGHUB_API_KEY}", "User-Agent": "imessages-bot"},
            json={"taskId": task_id},
            timeout=15,
        )
        resp.raise_for_status()
        body = resp.json()
        log.info("RunningHub poll %d: %s", attempt + 1, body)
        status = body.get("status", "")
        if status == "SUCCESS":
            results = body.get("results") or []
            if results and results[0].get("url"):
                return results[0]["url"]
            raise ValueError(f"SUCCESS but no result URL: {body}")
        if status not in ("RUNNING", "PENDING", "QUEUED"):
            raise ValueError(f"Task failed status={status!r}: {body}")
    raise TimeoutError(f"Task {task_id} timed out after {MAX_POLL_ATTEMPTS} polls")