# headquarters/api/pos_webhook.py
from fastapi import FastAPI, BackgroundTasks, Header, HTTPException
from pydantic import BaseModel
from datetime import datetime
import hashlib, hmac, json

app = FastAPI()
SECRET_KEY = "your-franchise-webhook-secret"

class OrderEvent(BaseModel):
    store_id: str
    order_id: str
    items: list
    total: int
    payment_method: str
    timestamp: datetime

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

@app.post("/webhook/order")
async def receive_order(
    event: OrderEvent,
    background_tasks: BackgroundTasks,
    x_signature: str = Header(...)
):
    payload = event.model_dump_json().encode()
    if not verify_signature(payload, x_signature):
        raise HTTPException(status_code=401, detail="Invalid signature")
    background_tasks.add_task(aggregate_order, event)
    return {"status": "accepted", "order_id": event.order_id}

async def aggregate_order(event: OrderEvent):
    import redis.asyncio as redis
    r = await redis.from_url("redis://localhost")
    today = event.timestamp.strftime("%Y%m%d")
    await r.incrby(f"sales:{today}:{event.store_id}", event.total)
    await r.incrby(f"orders:{today}:{event.store_id}", 1)

# headquarters/api/dashboard.py
from fastapi.responses import StreamingResponse
import asyncio, json, redis.asyncio as redis
from datetime import datetime

@app.get("/dashboard/live-sales")
async def live_sales_stream():
    async def event_generator():
        r = await redis.from_url("redis://localhost")
        while True:
            today = datetime.now().strftime("%Y%m%d")
            store_ids = await r.smembers("active_stores")
            sales_data = {}
            for store_id in store_ids:
                sid = store_id.decode()
                sales = await r.get(f"sales:{today}:{sid}") or 0
                orders = await r.get(f"orders:{today}:{sid}") or 0
                sales_data[sid] = {
                    "total_sales": int(sales),
                    "order_count": int(orders),
                    "avg_order": int(sales) // max(int(orders), 1)
                }
            yield f"data: {json.dumps(sales_data, ensure_ascii=False)}\n\n"
            await asyncio.sleep(30)
    return StreamingResponse(
        event_generator(),
        media_type="text/event-stream",
        headers={"Cache-Control": "no-cache"}
    )