const HORIZON = 'https://horizon.stellar.org';

async function trackStablecoinSupply(assetCode, issuerId) {
  const res = await fetch(
    `${HORIZON}/assets?asset_code=${assetCode}&asset_issuer=${issuerId}`
  );
  const data = await res.json();
  const asset = data._embedded.records[0];

  return {
    assetCode: asset.asset_code,
    totalSupply: parseFloat(asset.amount),
    authorizedAccounts: asset.accounts.authorized,
    clawbackEnabled: asset.flags.auth_clawback_enabled,
  };
}

// Track supply changes over time
async function trackSupplyHistory(assetCode, issuerId, hours = 24) {
  const res = await fetch(
    `${HORIZON}/accounts/${issuerId}/payments?limit=200&order=desc`
  );
  const data = await res.json();
  const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000);

  let minted = 0;
  let burned = 0;

  for (const payment of data._embedded.records) {
    if (new Date(payment.created_at) < cutoff) break;
    if (payment.asset_code !== assetCode) continue;

    const amount = parseFloat(payment.amount);
    if (payment.from === issuerId) {
      minted += amount;   // Issuer sending = minting
    } else if (payment.to === issuerId) {
      burned += amount;   // Receiving back = burning
    }
  }

  return { minted, burned, netIssuance: minted - burned };
}

// Use LumenQuery's analytics endpoint for aggregated data
async function getStablecoinMetrics() {
  const res = await fetch('https://lumenquery.io/api/analytics/tokens');
  const data = await res.json();

  return {
    usdcVolume24h: data.tokens?.find(t => t.code === 'USDC')?.volume24h,
    paymentCount24h: data.paymentCount,
    uniqueSenders: data.uniqueSenders,
  };
}

// Stream incoming stablecoin payments to a merchant account
function streamMerchantPayments(merchantAccountId) {
  const url = `${HORIZON}/accounts/${merchantAccountId}/payments?cursor=now`;
  const es = new EventSource(url);

  es.onmessage = (event) => {
    const payment = JSON.parse(event.data);

    if (payment.type === 'payment' && payment.asset_code === 'USDC') {
      console.log(`Received ${payment.amount} USDC from ${payment.from}`);

      processPayment({
        amount: payment.amount,
        sender: payment.from,
        transactionId: payment.transaction_hash,
        timestamp: payment.created_at,
      });
    }
  };
}

async function getAccountComplianceStatus(accountId) {
  const res = await fetch(`${HORIZON}/accounts/${accountId}`);
  const account = await res.json();

  const stablecoinTrustlines = account.balances.filter(b =>
    b.asset_type !== 'native' && ['USDC'].includes(b.asset_code)
  );

  return stablecoinTrustlines.map(tl => ({
    asset: `${tl.asset_code}:${tl.asset_issuer.substring(0, 8)}...`,
    balance: tl.balance,
    authorized: tl.is_authorized,
    frozen: !tl.is_authorized && tl.is_authorized_to_maintain_liabilities,
  }));
}