export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    // Stream Multi-Chunk File directly from Telegram Bot API to Recipient
    if (url.pathname.startsWith("/stream/")) {
      const slug = url.pathname.replace("/stream/", "");
      const metaRes = await fetch(`${env.API_BASE_URL}/api/files/${slug}/stream-meta`, {
        headers: { "X-Edge-Secret": env.EDGE_SECRET }
      });
      if (!metaRes.ok) return new Response("Link Expired or Invalid", { status: 404 });

      const { fileName, mimeType, chunks, botTokens } = await metaRes.json();
      const { readable, writable } = new TransformStream();
      const writer = writable.getWriter();

      (async () => {
        for (let i = 0; i < chunks.length; i++) {
          const token = botTokens[i % botTokens.length];
          const pathRes = await fetch(`https://api.telegram.org/bot${token}/getFile?file_id=${chunks[i]}`);
          const pathJson = await pathRes.json();
          const tgUrl = `https://api.telegram.org/file/bot${token}/${pathJson.result.file_path}`;

          const chunkRes = await fetch(tgUrl);
          for await (const slice of chunkRes.body) {
            await writer.write(slice);
          }
        }
        await writer.close();
      })();

      return new Response(readable, {
        headers: {
          "Content-Type": mimeType || "application/octet-stream",
          "Content-Disposition": `attachment; filename="${fileName}"`,
          "Cache-Control": "private, no-transform"
        }
      });
    }
    return new Response("T-Rex Edge Network Active", { status: 200 });
  }
};

from fastapi import FastAPI, Request, HTTPException, Depends
from motor.motor_asyncio import AsyncIOMotorClient
from datetime import datetime, timedelta
import os

app = FastAPI(title="T-Rex Cloud API")
mongo = AsyncIOMotorClient(os.getenv("MONGODB_URI"))
db = mongo.trex_cloud

# MongoDB TTL Index automatically deletes expired Guest files while keeping User files permanent:
# db.files.create_index("expiresAt", expireAfterSeconds=0)

@app.post("/api/files/create")
async def register_uploaded_file(payload: dict):
    settings = await db.system_config.find_one({"_id": "global"}) or {"guestExpiryDays": 3}
    is_guest = payload.get("role") == "guest"
    expires_at = datetime.utcnow() + timedelta(days=settings["guestExpiryDays"]) if is_guest else None

    doc = {
        "slug": payload["slug"],
        "name": payload["name"],
        "size": payload["size"],
        "chunks": payload["chunks"],
        "note": payload.get("note", ""),
        "ownerEmail": payload.get("ownerEmail", "guest"),
        "isGuest": is_guest,
        "createdAt": datetime.utcnow(),
        "expiresAt": expires_at,
        "active": True
    }
    await db.files.insert_one(doc)
    return {"status": "ok", "slug": doc["slug"], "expiresAt": expires_at}

@app.post("/api/telemetry/heartbeat")
async def record_heartbeat(request: Request, data: dict):
    city = request.headers.get("cf-ipcity", "Mumbai")
    ip = request.headers.get("cf-connecting-ip", request.client.host)
    await db.analytics_logs.update_one(
        {"sessionId": data["sessionId"], "slug": data["slug"]},
        {
            "$set": {
                "ip": ip,
                "city": city,
                "device": data.get("device"),
                "noteRead": data.get("noteRead", True),
                "downloadStatus": data.get("downloadStatus", "OPENED"),
                "lastPingAt": datetime.utcnow()
            },
            "$inc": {"durationSeconds": 5},
            "$setOnInsert": {"openedAt": datetime.utcnow()}
        },
        upsert=True
    )
    return {"ok": True}

@app.put("/api/admin/storage-config")
async def update_telegram_config(cfg: dict):
    await db.system_config.update_one(
        {"_id": "global"},
        {"$set": {
            "primaryChannelId": cfg["primaryChannelId"],
            "backupChannelId": cfg.get("backupChannelId"),
            "botTokens": cfg["botTokens"],
            "guestExpiryDays": int(cfg.get("guestExpiryDays", 3))
        }},
        upsert=True
    )
    return {"updated": True}