useDownloadSpeed.ts

import { useEffect, useState } from 'react';
import { useSupabase } from '../db/PowerSyncProvider';

export type DownloadSpeedReason = 'load' | 'abort' | 'error' | 'no-credentials';

export interface UseDownloadSpeedOptions {
  durationMs?: number;
}

export interface DownloadSpeedResult {
  mbps: number | null;
  kbps: number | null;
  bytes: number | null;
  durationMs: number | null;
  reason: DownloadSpeedReason;
  error: string | null;
  ranAt: number;
  compressed: boolean;
  contentEncoding: string | null;
}

export interface DownloadSpeedStatus {
  result: DownloadSpeedResult | null;
  measuring: boolean;
  runNow: (opts?: { compressed?: boolean }) => void;
}

const generateClientId = () =>
  `speedtest-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;

export function useDownloadSpeed(options: UseDownloadSpeedOptions = {}): DownloadSpeedStatus {
  const durationMs = options.durationMs ?? 4000;
  const supabase = useSupabase();

  const [result, setResult] = useState<DownloadSpeedResult | null>(null);
  const [activeXhr, setActiveXhr] = useState<XMLHttpRequest | null>(null);

  useEffect(() => () => activeXhr?.abort(), [activeXhr]);

  const runNow = async (opts?: { compressed?: boolean }) => {
    if (activeXhr) return;
    const compressed = opts?.compressed ?? true;

    let credentials: { endpoint: string; token: string } | null = null;
    try {
      credentials = (await supabase.fetchCredentials()) as any;
    } catch (e: any) {
      setResult({
        mbps: null, kbps: null, bytes: null, durationMs: null,
        reason: 'no-credentials',
        error: String(e?.message ?? e),
        ranAt: Date.now(),
        compressed,
        contentEncoding: null
      });
      return;
    }
    if (!credentials) {
      setResult({
        mbps: null, kbps: null, bytes: null, durationMs: null,
        reason: 'no-credentials',
        error: 'no credentials returned',
        ranAt: Date.now(),
        compressed,
        contentEncoding: null
      });
      return;
    }

    const xhr = new XMLHttpRequest();
    xhr.open('POST', `${credentials.endpoint}/sync/stream`, true);
    xhr.responseType = 'text';
    xhr.setRequestHeader('Content-Type', 'application/json');
    xhr.setRequestHeader('Authorization', `Token ${credentials.token}`);
    xhr.setRequestHeader('Accept-Encoding', compressed ? 'gzip, br' : 'identity');

    const start = Date.now();
    let lastTime = start;
    let peakBytes = 0;

    xhr.onprogress = () => {
      const len = xhr.responseText?.length ?? 0;
      if (len > peakBytes) peakBytes = len;
      lastTime = Date.now();
    };

    const finish = (reason: DownloadSpeedReason) => {
      setActiveXhr(null);
      const elapsed = lastTime - start;
      const encoding = (() => {
        try { return xhr.getResponseHeader('Content-Encoding'); } catch { return null; }
      })();

      const hasData = peakBytes > 0 && elapsed > 0;
      const seconds = elapsed / 1000;

      setResult({
        mbps: hasData ? Math.round(((peakBytes * 8) / 1_000_000 / seconds) * 100) / 100 : null,
        kbps: hasData ? Math.round(peakBytes / 1024 / seconds) : null,
        bytes: peakBytes > 0 ? peakBytes : null,
        durationMs: elapsed > 0 ? elapsed : null,
        reason,
        error: reason === 'error' ? `xhr error (http ${xhr.status})` : hasData ? null : 'no bytes received',
        ranAt: Date.now(),
        compressed,
        contentEncoding: encoding
      });
    };

    xhr.onerror = () => finish('error');
    xhr.onabort = () => finish('abort');
    xhr.onload = () => finish('load');

    setActiveXhr(xhr);
    xhr.send(JSON.stringify({ raw_data: true, client_id: generateClientId(), buckets: [] }));

    setTimeout(() => {
      if (xhr.readyState !== 4) xhr.abort();
    }, durationMs);
  };

  return {
    result,
    measuring: activeXhr !== null,
    runNow
  };
}