import { io } from "socket.io-client";

const socket = io("wss://ws.muchfi.com", {
  transports: ["websocket"],
});

socket.on("connect", () => {
  console.log("Connected:", socket.id);
});

1m, 2m, 3m, 5m, 10m, 15m, 20m, 30m, 1h, 2h, 4h, 1d, 1w, 1mo

socket.emit("subscribe:pairs", {
  pairs: ["0x1234...abcd", "0x5678...efgh"],
  intervals: ["1m", "5m", "1h"]
});

socket.on("pairs:subscribed", (data) => {
  console.log("Subscribed to:", data.pairs);
});

socket.on("pairs:price-snapshot", (data) => {
  // { pair, price, volume, volumeUSD, timestamp, side }
});

socket.on("pairs:price-update", (data) => {
  // { pair, price, volume, volumeUSD, timestamp, side }
});

socket.on("pairs:candle-snapshot", (data) => {
  // { pair, interval, candle: { timestamp, open, high, low, close, volume }, marketType }
});

socket.on("pairs:candle-update", (data) => {
  // { pair, interval, candle: { timestamp, open, high, low, close, volume } }
});

socket.emit("unsubscribe:pairs", {
  pairs: ["0x1234...abcd"]
});

socket.on("pairs:unsubscribed", (data) => {
  console.log("Unsubscribed from:", data.pairs);
});

socket.emit("subscribe:tokens", {
  tokens: ["0xtoken1...", "0xtoken2..."],
  intervals: ["1m", "15m"]
});

socket.on("tokens:subscribed", (data) => {
  console.log("Subscribed to tokens:", data.tokens);
});

socket.on("tokens:candle-snapshot", (data) => {
  // { token, interval, candle: { timestamp, open, high, low, close, volume } }
});

socket.on("tokens:candle-update", (data) => {
  // { token, interval, candle: { timestamp, open, high, low, close, volume, volumeUSD, txCount } }
});

socket.emit("subscribe:datafeed", {
  market: "0xpoolAddress...",
  marketType: "amm", // "amm" | "clmm" | "launchpad"
  period: 5 // Period in minutes: 1, 5, 15, 60, 240, 1440, etc.
});

socket.on("datafeed:subscribed", (data) => {
  // { market, marketType, period }
});

socket.on("datafeed:snapshot", (data) => {
  // { market, marketType, period, candles: [{ time, open, high, low, close, volume }] }
});

socket.on("datafeed:update", (data) => {
  // { market, marketType, period, data: { time, open, high, low, close, volume } }
});

socket.emit("subscribe:token-datafeed", {
  token: "0xtokenAddress...",
  period: 5 // Period in minutes
});

socket.on("token-datafeed:subscribed", (data) => {
  // { token, period }
});

socket.on("token-datafeed:snapshot", (data) => {
  // { token, period, candles: [{ time, open, high, low, close, volume, volumeUSD, txCount }] }
});

socket.on("token-datafeed:update", (data) => {
  // { token, period, data: { time, open, high, low, close, volume, volumeUSD, txCount } }
});

socket.emit("subscribe:trades", {
  pair: "0xpoolAddress..."
});

socket.on("trades:subscribed", (data) => {
  // { pair }
});

socket.on("trades:snapshot", (data) => {
  // { pair, trades: [{ taker, type, price, size, timestamp, transactionHash }] }
});

socket.on("trades:new", (data) => {
  // { taker, type, price, size, timestamp, transactionHash }
});

socket.emit("unsubscribe:trades");

socket.on("trades:unsubscribed", () => {
  console.log("Unsubscribed from trades");
});

socket.emit("subscribe:pool-markets", {
  pool: "0xpoolAddress..."
});

socket.on("pool-markets:subscribed", (data) => {
  // { pool }
});

socket.on("pool-markets:snapshot", (data) => {
  /*
  {
    address: "0x...",
    price: "1.234567",
    liquidity: "1000000.00",
    volume24hr: "50000.00",
    apr: "12.500000",
    quoteToken: {
      marketCap: "1000000",
      address: "0x...",
      price: "1.00",
      variation1h: "0.5",
      variation24h: "-1.2"
    },
    baseToken: {
      marketCap: "500000",
      address: "0x...",
      price: "1.234567",
      variation1h: "2.1",
      variation24h: "5.5"
    }
  }
  */
});

socket.on("pool-markets:update", (data) => {
  // Same structure as snapshot
});

socket.emit("unsubscribe:pool-markets");

socket.emit("subscribe:pool", {
  poolId: "0xpoolAddress...",
  candlePeriod: 5 // Period in minutes
});

socket.emit("update:candlePeriod", {
  poolId: "0xpoolAddress...",
  candlePeriod: 15 // New period
});

socket.emit("unsubscribe:pool");

const aggregatedSocket = io("wss://ws.muchfi.com", {
  path: "/aggregated-socket.io/",
  transports: ["websocket"],
});

aggregatedSocket.on("connected", (data) => {
  console.log("Connected:", data.clientId);
  console.log("Available events:", data.availableEvents);
});

aggregatedSocket.emit("subscribe-tokens", {
  tokens: ["0xtoken1...", "0xtoken2..."]
});

aggregatedSocket.on("subscription-confirmed", (data) => {
  console.log("Subscribed to:", data.tokens);
});

aggregatedSocket.on("initial-aggregated-data", (data) => {
  // { tokenAddress, data: {...}, timestamp }
});

aggregatedSocket.on("aggregated-update", (data) => {
  /*
  {
    type: "token_update",
    data: {
      tokenAddress: "0x...",
      priceUSD: 1.23,
      priceImpactPercent: 0.5,
      instantVolume: 10000,
      triggerPool: { address: "0x..." }
    }
  }
  */
});

aggregatedSocket.emit("unsubscribe-tokens", {
  tokens: ["0xtoken1..."]
});

aggregatedSocket.emit("set-price-alert", {
  tokenAddress: "0xtoken...",
  threshold: 1.50, // USD price threshold
  direction: "up", // "up" | "down" | "both"
  timeframe: "1m" // "1m" | "5m" | "15m" | "1h"
});

aggregatedSocket.on("price-alert-set", (data) => {
  console.log("Alert set for", data.tokenAddress, "at $", data.threshold);
});

aggregatedSocket.on("price-alert-triggered", (data) => {
  /*
  {
    type: "price_alert",
    data: {
      tokenAddress: "0x...",
      priceUSD: 1.52,
      priceChange: 1.5,
      timeframe: "1m",
      threshold: 1.50,
      direction: "up"
    }
  }
  */
});

aggregatedSocket.emit("remove-price-alert", {
  tokenAddress: "0xtoken..."
});

aggregatedSocket.emit("set-volume-alert", {
  tokenAddress: "0xtoken...",
  thresholdUSD: 50000, // USD volume threshold
  percentageIncrease: 100, // % increase to trigger
  timeframe: "5m" // "1m" | "5m" | "15m"
});

aggregatedSocket.on("volume-alert-set", (data) => {
  console.log("Volume alert set for", data.tokenAddress);
});

aggregatedSocket.on("volume-alert-triggered", (data) => {
  /*
  {
    type: "volume_spike",
    data: {
      tokenAddress: "0x...",
      volumeUSD: 75000,
      volumeIncrease: 150,
      timeframe: "5m",
      triggerPool: "0x..."
    }
  }
  */
});

aggregatedSocket.emit("remove-volume-alert", {
  tokenAddress: "0xtoken..."
});

socket.on("error", (data) => {
  console.error("WebSocket error:", data.message);
});

socket.on("disconnect", (reason) => {
  console.log("Disconnected:", reason);
});

socket.on("server-shutdown", (data) => {
  console.log("Server shutting down:", data.message);
});

import { io } from "socket.io-client";

// Main WebSocket for trading data
const tradingSocket = io("wss://ws.muchfi.com", {
  transports: ["websocket"],
});

// Aggregated WebSocket for token analytics
const aggregatedSocket = io("wss://ws.muchfi.com", {
  path: "/aggregated-socket.io/",
  transports: ["websocket"],
});

// Trading socket events
tradingSocket.on("connect", () => {
  console.log("Trading socket connected");

  // Subscribe to pair updates
  tradingSocket.emit("subscribe:pairs", {
    pairs: ["0x1234567890abcdef..."],
    intervals: ["1m", "5m"]
  });

  // Subscribe to trades
  tradingSocket.emit("subscribe:trades", {
    pair: "0x1234567890abcdef..."
  });
});

tradingSocket.on("pairs:price-update", (data) => {
  console.log(`Price update: ${data.pair} = $${data.price}`);
});

tradingSocket.on("trades:new", (trade) => {
  console.log(`New trade: ${trade.type} ${trade.size} @ ${trade.price}`);
});

// Aggregated socket events
aggregatedSocket.on("connected", (data) => {
  console.log("Aggregated socket connected:", data.clientId);

  // Subscribe to token updates
  aggregatedSocket.emit("subscribe-tokens", {
    tokens: ["0xabcdef1234567890..."]
  });

  // Set price alert
  aggregatedSocket.emit("set-price-alert", {
    tokenAddress: "0xabcdef1234567890...",
    threshold: 2.00,
    direction: "up",
    timeframe: "5m"
  });
});

aggregatedSocket.on("aggregated-update", (data) => {
  console.log(`Token update: $${data.data.priceUSD}`);
});

aggregatedSocket.on("price-alert-triggered", (alert) => {
  console.log(`Price alert! ${alert.data.tokenAddress} reached $${alert.data.priceUSD}`);
});