useNetworkStatus.ts

import { useEffect, useRef, useState } from 'react';
import { useStatus } from '@powersync/react';

export type NetworkQuality = 'offline' | 'poor' | 'moderate' | 'good' | 'unknown';

/**
 * Ops/sec thresholds that define quality tiers.
 * Quality is classified by comparing the measured average ops/sec against
 * these boundaries — updated live during a download and preserved after.
 */
export const OPS_PER_SECOND_THRESHOLDS = {
  good: 10000,    // >= 10000 ops/sec → good
  moderate: 5000, // >= 5000 ops/sec → moderate
  // anything below moderate → poor
};

function classifyQuality(opsPerSec: number | null, connected: boolean): NetworkQuality {
  if (!connected) return 'offline';
  if (opsPerSec == null) return 'unknown';
  if (opsPerSec >= OPS_PER_SECOND_THRESHOLDS.good) return 'good';
  if (opsPerSec >= OPS_PER_SECOND_THRESHOLDS.moderate) return 'moderate';
  return 'poor';
}

export interface NetworkStatus {
  quality: NetworkQuality;
  opsPerSecond: number | null;
  connected: boolean;
  downloading: boolean;
}

export function useNetworkStatus(): NetworkStatus {
  const status = useStatus();
  const connected = status.connected;
  const downloading = status.dataFlowStatus.downloading ?? false;
  const progress = status.downloadProgress;
  const downloadedOps = progress?.downloadedOperations ?? 0;

  const downloadStartRef = useRef<number | null>(null);
  const wasDownloadingRef = useRef(false);
  const [opsPerSecond, setOpsPerSecond] = useState<number | null>(null);

  useEffect(() => {
    // Download just started
    if (downloading && !wasDownloadingRef.current) {
      downloadStartRef.current = Date.now();
    }

    // Update live ops/sec while downloading
    if (downloading && downloadStartRef.current != null && downloadedOps > 0) {
      const durationSec = (Date.now() - downloadStartRef.current) / 1000;
      if (durationSec > 0) {
        setOpsPerSecond(Math.round(downloadedOps / durationSec));
      }
    }

    // Download just finished — compute final average
    if (!downloading && wasDownloadingRef.current) {
      const start = downloadStartRef.current;
      if (start != null && downloadedOps > 0) {
        const durationSec = (Date.now() - start) / 1000;
        if (durationSec > 0) {
          setOpsPerSecond(Math.round(downloadedOps / durationSec));
        }
      }
    }

    wasDownloadingRef.current = downloading;
  }, [downloading, downloadedOps]);

  return {
    quality: classifyQuality(opsPerSecond, connected),
    opsPerSecond,
    connected,
    downloading
  };
}