"use client";

import * as React from "react";
import type { ColineConnectionStatus } from "@colineapp/sdk/v2";
import { useColine } from "../provider";

/** An account connection's status, with connect and disconnect actions. */
export function useConnection(key: string) {
  const coline = useColine();
  const [status, setStatus] = React.useState<ColineConnectionStatus | null>(null);
  const [isLoading, setLoading] = React.useState(true);
  const [isConnecting, setConnecting] = React.useState(false);
  const [error, setError] = React.useState<string | null>(null);

  const refresh = React.useCallback(async () => {
    try {
      setStatus(await coline.connections.get(key));
      setError(null);
    } catch (cause) {
      setError(cause instanceof Error ? cause.message : String(cause));
    } finally {
      setLoading(false);
    }
  }, [coline, key]);

  React.useEffect(() => {
    let cancelled = false;
    coline.connections
      .get(key)
      .then((next) => {
        if (cancelled) return;
        setStatus(next);
        setError(null);
      })
      .catch((cause: unknown) => {
        if (!cancelled) setError(cause instanceof Error ? cause.message : String(cause));
      })
      .finally(() => {
        if (!cancelled) setLoading(false);
      });
    return () => {
      cancelled = true;
    };
  }, [coline, key]);

  const connect = React.useCallback(async () => {
    setConnecting(true);
    try {
      const next = await coline.connections.connect(key);
      setStatus(next);
      setError(null);
      return next.connected;
    } catch (cause) {
      setError(cause instanceof Error ? cause.message : String(cause));
      return false;
    } finally {
      setConnecting(false);
    }
  }, [coline, key]);

  const disconnect = React.useCallback(async () => {
    await coline.connections.disconnect(key);
    await refresh();
  }, [coline, key, refresh]);

  return { status, isLoading, isConnecting, error, connect, disconnect, refresh };
}

/** A value that settles `delayMs` after it stops changing. */
export function useDebouncedValue<T>(value: T, delayMs = 250): T {
  const [settled, setSettled] = React.useState(value);
  React.useEffect(() => {
    const timer = setTimeout(() => setSettled(value), delayMs);
    return () => clearTimeout(timer);
  }, [value, delayMs]);
  return settled;
}