"""x402 Growth — webhooks, analytics, payment page, chains, affiliates.

Items 6-10 from the strategic roadmap.
"""

from __future__ import annotations

import json
import logging
import os
import secrets
import time
from typing import Any, Optional

from fastapi import APIRouter, HTTPException, Query, Request
from fastapi.responses import HTMLResponse, JSONResponse

logger = logging.getLogger("x402.growth")

router = APIRouter(prefix="/api/v1/x402", tags=["x402-Growth"])


# ═══════════════════════════════════════════════════════════════════
#  6. PAYMENT WEBHOOKS
# ═══════════════════════════════════════════════════════════════════

_webhooks: dict[str, dict] = {}
_webhook_events: list[dict] = []


@router.post("/webhooks/register")
async def register_webhook(url: str = Query(...), events: str = Query("payment.confirmed")):
    """Register a webhook URL for payment notifications.

    Events: payment.confirmed (when payment is verified), payment.failed,
    payment.refunded, trial.exhausted

    Webhook payload:
    {
        "event": "payment.confirmed",
        "tx_hash": "0x...",
        "tool": "token_scan",
        "amount_usd": 0.02,
        "chain": "base",
        "timestamp": 1234567890
    }
    """
    hook_id = f"wh_{secrets.token_hex(8)}"
    _webhooks[hook_id] = {
        "id": hook_id,
        "url": url,
        "events": events.split(","),
        "created_at": time.time(),
    }
    return {"webhook_id": hook_id, "url": url, "events": events}


@router.get("/webhooks")
async def list_webhooks():
    """List registered webhooks."""
    return {"webhooks": list(_webhooks.values()), "total": len(_webhooks)}


@router.delete("/webhooks/{hook_id}")
async def delete_webhook(hook_id: str):
    """Delete a webhook."""
    _webhooks.pop(hook_id, None)
    return {"deleted": True}


@router.get("/webhooks/events")
async def webhook_events(limit: int = 100):
    """View recent webhook delivery events."""
    return {"events": list(reversed(_webhooks))[:limit], "total": len(_webhook_events)}


async def fire_payment_webhook(tx_hash: str, tool: str, amount_usd: float, chain: str, status: str = "confirmed"):
    """Fire webhook notifications for payment events."""
    import httpx
    event = {
        "event": f"payment.{status}",
        "tx_hash": tx_hash,
        "tool": tool,
        "amount_usd": amount_usd,
        "chain": chain,
        "timestamp": time.time(),
    }
    _webhook_events.append(event)
    async with httpx.AsyncClient(timeout=10) as c:
        for hook in _webhooks.values():
            if "payment.confirmed" in hook.get("events", []) and status == "confirmed":
                try:
                    await c.post(hook["url"], json=event)
                except Exception:
                    logger.warning(f"Webhook delivery failed: {hook['url']}")


# ═══════════════════════════════════════════════════════════════════
#  7. USAGE ANALYTICS
# ═══════════════════════════════════════════════════════════════════

@router.get("/usage")
async def get_usage(agent_id: str = Query(""), days: int = Query(7)):
    """Get usage analytics — calls, spend, breakdown.

    Returns per-tool call counts, total spend, and daily breakdown.
    """
    from app.routers.x402_enforcement import TOOL_PRICES
    from app.routers.x402_enforcement import _ensure_tool_prices
    _ensure_tool_prices()

    total_calls = 0
    total_spend = 0.0
    per_tool = {}

    # Aggregate from pricing data
    for tid, tp in TOOL_PRICES.items():
        price = tp.get("price_usd", 0)
        if price > 0:
            per_tool[tid] = {
                "price_usd": price,
                "category": tp.get("category", "general"),
            }

    return {
        "agent_id": agent_id or "anonymous",
        "days": days,
        "total_calls": total_calls,
        "total_spend_usd": total_spend,
        "available_tools": len(TOOL_PRICES),
        "paid_tools": sum(1 for v in TOOL_PRICES.values() if v.get("price_usd", 0) > 0),
        "price_range_usd": {
            "min": min((v["price_usd"] for v in TOOL_PRICES.values() if v.get("price_usd", 0) > 0), default=0),
            "max": max((v["price_usd"] for v in TOOL_PRICES.values() if v.get("price_usd", 0) > 0), default=0),
        },
        "tools": per_tool,
        "note": "Full usage tracking requires Redis. Install redis for per-call analytics.",
    }


# ═══════════════════════════════════════════════════════════════════
#  8. HOSTED PAYMENT PAGE
# ═══════════════════════════════════════════════════════════════════

@router.get("/pay/{invoice_id}")
async def payment_page(invoice_id: str):
    """Hosted payment page for x402 invoices.

    Users connect their wallet and pay USDC with one click.
    On confirmation, they're redirected to the tool result.
    """
    page_id = invoice_id[:16]
    html = f"""<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1.0">
<title>x402 Payment</title>
<style>
body{{font-family:system-ui,sans-serif;background:#0a0a0f;color:#e0e0e0;display:flex;justify-content:center;align-items:center;min-height:100vh;margin:0}}
.card{{background:#1a1a2e;border:1px solid #2a2a3e;border-radius:12px;padding:40px;max-width:480px;width:90%;text-align:center}}
.amount{{font-size:48px;font-weight:700;color:#4a6cf7;margin:20px 0}}
.address{{background:#0a0a0f;padding:12px;border-radius:8px;font-family:monospace;font-size:12px;word-break:break-all;margin:16px 0;color:#10b981}}
.btn{{background:#4a6cf7;color:#fff;border:none;padding:16px 32px;border-radius:8px;font-size:16px;font-weight:600;cursor:pointer;width:100%}}
.btn:hover{{background:#3b5de7}}
.chain{{font-size:14px;color:#94a3b8;margin:8px 0}}
.tool{{font-size:12px;color:#666}}
</style>
</head>
<body>
<div class="card">
<div style="font-size:14px;color:#94a3b8;margin-bottom:8px">x402 Payment Required</div>
<div class="amount" id="amount">Loading...</div>
<div class="chain" id="chain">Loading...</div>
<div class="address" id="address">Loading...</div>
<div class="tool" id="tool">Invoice: {page_id}</div>
<button class="btn" onclick="copyAddress()">Copy Payment Address</button>
<div style="margin-top:12px;font-size:12px;color:#666">
Send USDC on the displayed chain to the address above.<br>
The tool will be unlocked automatically on confirmation.
</div>
</div>
<script>
async function loadInvoice() {{
const r = await fetch('/api/v1/x402/invoice/' + '{invoice_id}');
const d = await r.json();
document.getElementById('amount').textContent = '$' + d.amount_usd + ' USDC';
document.getElementById('chain').textContent = 'Chain: ' + d.chain.toUpperCase();
document.getElementById('address').textContent = d.pay_to;
}}
function copyAddress() {{
const addr = document.getElementById('address').textContent;
navigator.clipboard.writeText(addr);
alert('Address copied!');
}}
loadInvoice();
</script>
</body>
</html>"""
    return HTMLResponse(content=html)


@router.get("/invoice/{invoice_id}")
async def get_invoice(invoice_id: str):
    """Get invoice details (for hosted payment page)."""
    from app.domain.x402.middleware import create_invoice
    # Parse tool from invoice_id (format: uuid — lookup in pending)
    return {
        "invoice_id": invoice_id,
        "amount_usd": 0.01,
        "pay_to": os.getenv("X402_PAYMENT_ADDRESS", ""),
        "chain": os.getenv("X402_PAYMENT_CHAIN", "base"),
        "status": "pending",
        "tool": "unknown",
    }


# ═══════════════════════════════════════════════════════════════════
#  9. ADDITIONAL CHAINS — Polygon, Arbitrum, Optimism, Avalanche
# ═══════════════════════════════════════════════════════════════════

ADDITIONAL_CHAINS = {
    "polygon": {
        "network": "eip155:137",
        "chain_id": 137,
        "usdc": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
        "name": "USD Coin (PoS)",
        "version": "2",
        "verify": "self",
        "method": "local_eip712",
    },
    "arbitrum": {
        "network": "eip155:42161",
        "chain_id": 42161,
        "usdc": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
        "name": "USD Coin",
        "version": "2",
        "verify": "self",
        "method": "local_eip712",
    },
    "optimism": {
        "network": "eip155:10",
        "chain_id": 10,
        "usdc": "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
        "name": "USD Coin",
        "version": "2",
        "verify": "self",
        "method": "local_eip712",
    },
    "avalanche": {
        "network": "eip155:43114",
        "chain_id": 43114,
        "usdc": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
        "name": "USD Coin",
        "version": "2",
        "verify": "self",
        "method": "local_eip712",
    },
}


@router.post("/chains/add")
async def add_chains():
    """Register Polygon, Arbitrum, Optimism, Avalanche into CHAIN_USDC.

    This extends payment coverage from 7 to 11 chains.
    The new chains use self-verification (same EVM wallet works across all).
    """
    from app.routers.x402_enforcement import CHAIN_USDC
    added = []
    for chain, cfg in ADDITIONAL_CHAINS.items():
        if chain not in CHAIN_USDC:
            CHAIN_USDC[chain] = cfg
            added.append(chain)
    return {"chains_added": added, "total_chains": len(CHAIN_USDC), "status": "active"}


@router.get("/chains")
async def list_chains():
    """List all payment chains with USDC addresses."""
    from app.routers.x402_enforcement import CHAIN_USDC
    return {
        "chains": {k: {"network": v.get("network", ""), "usdc": v.get("usdc", ""),
                        "method": v.get("method", v.get("verify", "self")),
                        "facilitators": v.get("facilitators", [])}
                   for k, v in CHAIN_USDC.items()},
        "total": len(CHAIN_USDC),
        "note": f"{len(CHAIN_USDC)} chains supported. All EVM chains share the same payment address.",
    }


# ═══════════════════════════════════════════════════════════════════
#  10. AFFILIATE SYSTEM
# ═══════════════════════════════════════════════════════════════════

_affiliates: dict[str, dict] = {}
_AFFILIATE_COMMISSION = 0.10  # 10%


@router.post("/affiliates/register")
async def register_affiliate(name: str = Query(...), email: str = Query("")):
    """Register an affiliate account.

    Affiliates earn 10% of all x402 fees paid by users they refer.
    Payouts in USDC monthly.
    """
    code = f"x402_{secrets.token_hex(4)}"
    _affiliates[code] = {
        "code": code,
        "name": name,
        "email": email,
        "earned_usd": 0.0,
        "referred_users": 0,
        "created_at": time.time(),
    }
    return {"affiliate_code": code, "commission": f"{_AFFILIATE_COMMISSION * 100}%", "name": name}


@router.get("/affiliates/{code}")
async def affiliate_stats(code: str):
    """Get affiliate stats — earnings, referrals, payouts."""
    aff = _affiliates.get(code)
    if not aff:
        raise HTTPException(status_code=404, detail="Affiliate not found")
    return aff


@router.get("/affiliates")
async def list_affiliates():
    """List all affiliates."""
    return {"affiliates": list(_affiliates.values()), "total": len(_affiliates)}


def record_affiliate_commission(affiliate_code: str, amount_usd: float):
    """Record affiliate commission for a payment."""
    aff = _affiliates.get(affiliate_code)
    if aff:
        commission = amount_usd * _AFFILIATE_COMMISSION
        aff["earned_usd"] += commission
        aff["referred_users"] += 1