// npm i ethers
import { ethers } from "ethers";

export async function verifyEvmTx({ rpc, txhash, receiver, minWei, tokenAddress }) {
  const provider = new ethers.JsonRpcProvider(rpc);
  const receipt = await provider.getTransactionReceipt(txhash);
  if (!receipt) return { ok:false, reason:"tx_not_found" };
  if (receipt.status !== 1) return { ok:false, reason:"tx_failed" };

  // Native ETH
  if (!tokenAddress) {
    const tx = await provider.getTransaction(txhash);
    const to = (tx.to || "").toLowerCase();
    if (to !== receiver.toLowerCase()) return { ok:false, reason:"receiver_mismatch" };
    if (tx.value < BigInt(minWei)) return { ok:false, reason:"insufficient_amount" };
    return { ok:true, payer: tx.from, value: tx.value.toString() };
  }

  // ERC20 (USDC)
  const iface = new ethers.Interface(["event Transfer(address indexed from,address indexed to,uint256 value)"]);
  const logs = receipt.logs.filter(l => (l.address||"").toLowerCase() === tokenAddress.toLowerCase());
  for (const log of logs) {
    try {
      const ev = iface.parseLog(log);
      if (ev?.name === "Transfer" && ev.args.to.toLowerCase() === receiver.toLowerCase()) {
        return { ok:true, payer: ev.args.from, value: ev.args.value.toString(), token: tokenAddress };
      }
    } catch {}
  }
  return { ok:false, reason:"transfer_not_found" };
}

// npm i jsonwebtoken
import jwt from "jsonwebtoken";

// issue
export function signX402({ secret, tokenId, product, ttlSeconds = 300, extra={} }) {
  const payload = { tokenId, product, ...extra };
  return jwt.sign(payload, secret, { expiresIn: ttlSeconds });
}

// verify (middleware)
export function verifyX402({ secret }) {
  return (req, res, next) => {
    const auth = (req.headers.authorization || "").split(" ");
    if (auth[0] !== "Bearer" || !auth[1]) return res.status(401).json({ ok:false, reason:"no_token" });
    try {
      const data = jwt.verify(auth[1], secret);
      req.x402 = data; // { tokenId, product, iat, exp, ... }
      return next();
    } catch (e) {
      return res.status(401).json({ ok:false, reason:"invalid_or_expired" });
    }
  };
}

export function makeX402Client({ apiBase, chain="solana", product="ai.small", payWithWallet }) {
  let token = null;

  async function ensurePaid() {
    if (token) return token;
    // 1) get price
    const price = await fetch(\`\${apiBase}/prices?product=\${product}\`).then(r=>r.json());
    // 2) trigger wallet (app supplies)
    const txid = await payWithWallet(price); // implement Phantom/Metamask
    if (!txid) throw new Error("payment_cancelled");
    // 3) verify -> token
    const vr = await fetch(\`\${apiBase}/verify\`, {
      method:"POST", headers:{ "content-type":"application/json" },
      body: JSON.stringify({ chain, txid, product })
    }).then(r=>r.json());
    if (!vr.paid) throw new Error("verify_failed");
    token = vr.token;
    return token;
  }

  async function call(path, body) {
    const res = await fetch(\`\${apiBase}\${path}\`, {
      method:"POST", headers:{ "content-type":"application/json", ...(token ? {authorization:\`Bearer \${token}\`}:{}) },
      body: JSON.stringify(body||{})
    });
    if (res.status !== 402) return res.json();
    await ensurePaid(); // do the flow
    return fetch(\`\${apiBase}\${path}\`, {
      method:"POST", headers:{ "content-type":"application/json", authorization:\`Bearer \${token}\` },
      body: JSON.stringify(body||{})
    }).then(r=>r.json());
  }

  return { ensurePaid, call };
}