gc-alexandria/src/lib/utils/network_detection.ts

import { deduplicateRelayUrls } from "./relay_management.ts";

/**
 * Network conditions for relay selection
 */
export enum NetworkCondition {
  ONLINE = "online",
  SLOW = "slow",
  OFFLINE = "offline",
}

/**
 * Network connectivity test endpoints
 */
const NETWORK_ENDPOINTS = [
  "https://www.google.com/favicon.ico",
  "https://httpbin.org/status/200",
  "https://api.github.com/zen",
];

/**
 * Detects if the network is online using more reliable endpoints
 * @returns Promise that resolves to true if online, false otherwise
 */
export async function isNetworkOnline(): Promise<boolean> {
  for (const endpoint of NETWORK_ENDPOINTS) {
    try {
      // Use a simple fetch without HEAD method to avoid CORS issues
      await fetch(endpoint, {
        method: "GET",
        cache: "no-cache",
        signal: AbortSignal.timeout(3000),
        mode: "no-cors", // Use no-cors mode to avoid CORS issues
      });
      // With no-cors mode, we can't check response.ok, so we assume success if no error
      return true;
    } catch (error) {
      console.debug(
        `[network_detection.ts] Failed to reach ${endpoint}:`,
        error,
      );
      continue;
    }
  }

  console.debug("[network_detection.ts] All network endpoints failed");
  return false;
}

/**
 * Tests network speed by measuring response time
 * @returns Promise that resolves to network speed in milliseconds
 */
export async function testNetworkSpeed(): Promise<number> {
  const startTime = performance.now();

  for (const endpoint of NETWORK_ENDPOINTS) {
    try {
      await fetch(endpoint, {
        method: "GET",
        cache: "no-cache",
        signal: AbortSignal.timeout(5000),
        mode: "no-cors", // Use no-cors mode to avoid CORS issues
      });

      const endTime = performance.now();
      return endTime - startTime;
    } catch (error) {
      console.debug(
        `[network_detection.ts] Speed test failed for ${endpoint}:`,
        error,
      );
      continue;
    }
  }

  console.debug(
    "[network_detection.ts] Network speed test failed for all endpoints",
  );
  return Infinity; // Very slow if it fails
}

/**
 * Determines network condition based on connectivity and speed
 * @returns Promise that resolves to NetworkCondition
 */
export async function detectNetworkCondition(): Promise<NetworkCondition> {
  const isOnline = await isNetworkOnline();

  if (!isOnline) {
    console.debug("[network_detection.ts] Network condition: OFFLINE");
    return NetworkCondition.OFFLINE;
  }

  const speed = await testNetworkSpeed();

  // Consider network slow if response time > 2000ms
  if (speed > 2000) {
    console.debug(
      `[network_detection.ts] Network condition: SLOW (${speed.toFixed(0)}ms)`,
    );
    return NetworkCondition.SLOW;
  }

  console.debug(
    `[network_detection.ts] Network condition: ONLINE (${speed.toFixed(0)}ms)`,
  );
  return NetworkCondition.ONLINE;
}

/**
 * Gets the appropriate relay sets based on network condition
 * @param networkCondition The detected network condition
 * @param discoveredLocalRelays Array of discovered local relay URLs
 * @param lowbandwidthRelays Array of low bandwidth relay URLs
 * @param fullRelaySet The complete relay set for normal conditions
 * @returns Object with inbox and outbox relay arrays
 */
export function getRelaySetForNetworkCondition(
  networkCondition: NetworkCondition,
  discoveredLocalRelays: string[],
  lowbandwidthRelays: string[],
  fullRelaySet: { inboxRelays: string[]; outboxRelays: string[] },
): { inboxRelays: string[]; outboxRelays: string[] } {
  switch (networkCondition) {
    case NetworkCondition.OFFLINE:
      // When offline, use local relays if available, otherwise rely on cache
      // This will be improved when IndexedDB local relay is implemented
      if (discoveredLocalRelays.length > 0) {
        console.debug("[network_detection.ts] Using local relays (offline)");
        return {
          inboxRelays: discoveredLocalRelays,
          outboxRelays: discoveredLocalRelays,
        };
      } else {
        console.debug(
          "[network_detection.ts] No local relays available, will rely on cache (offline)",
        );
        return {
          inboxRelays: [],
          outboxRelays: [],
        };
      }
    case NetworkCondition.SLOW: {
      // Local relays + low bandwidth relays when slow (deduplicated)
      console.debug(
        "[network_detection.ts] Using local + low bandwidth relays (slow network)",
      );
      const slowInboxRelays = deduplicateRelayUrls([
        ...discoveredLocalRelays,
        ...lowbandwidthRelays,
      ]);
      const slowOutboxRelays = deduplicateRelayUrls([
        ...discoveredLocalRelays,
        ...lowbandwidthRelays,
      ]);
      return {
        inboxRelays: slowInboxRelays,
        outboxRelays: slowOutboxRelays,
      };
    }
    case NetworkCondition.ONLINE:
    default:
      // Full relay set when online
      console.debug("[network_detection.ts] Using full relay set (online)");
      return fullRelaySet;
  }
}

/**
 * Starts periodic network monitoring with reduced frequency to avoid spam
 * @param onNetworkChange Callback function called when network condition changes
 * @param checkInterval Interval in milliseconds between network checks (default: 60 seconds)
 * @returns Function to stop the monitoring
 */
export function startNetworkMonitoring(
  onNetworkChange: (condition: NetworkCondition) => void,
  checkInterval: number = 60000, // Increased to 60 seconds to reduce spam
): () => void {
  let lastCondition: NetworkCondition | null = null;
  let intervalId: ReturnType<typeof setInterval> | null = null;

  const checkNetwork = async () => {
    try {
      const currentCondition = await detectNetworkCondition();

      if (currentCondition !== lastCondition) {
        console.debug(
          `[network_detection.ts] Network condition changed: ${lastCondition} -> ${currentCondition}`,
        );
        lastCondition = currentCondition;
        onNetworkChange(currentCondition);
      }
    } catch (error) {
      console.warn("[network_detection.ts] Network monitoring error:", error);
    }
  };

  // Initial check
  checkNetwork();

  // Set up periodic monitoring
  intervalId = globalThis.setInterval(checkNetwork, checkInterval);

  // Return function to stop monitoring
  return () => {
    if (intervalId !== null) {
      clearInterval(intervalId);
      intervalId = null;
    }
  };
}