import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { useClient } from 'hooks/useClient';
import type { HeadscaleServer, HeadscaleHealth, HeadscaleSshTest } from './shared';

// The registered-servers cache. Every panel in the /headscale workspace reads this one query, so switching
// the active server anywhere updates the whole screen at once.
//
// Registration is validated server-side before anything is saved (reachable, >=0.29, key accepted), which
// means a POST can fail for perfectly ordinary reasons — a typo'd URL, a revoked key. Those are not
// exceptional here, so the mutations surface their message rather than swallowing it.

const SERVERS_KEY = ['headscale', 'servers'] as const;
const EMPTY: HeadscaleServer[] = [];

const BASE = '/offscale/_officer/servers';

/**
 * Readable message from a useClient rejection. It throws `{status, message}` where `message` is the raw
 * body text — JSON `{error}` from our sidecar, but plain text from the platform's own 401/503 paths.
 */
export function headscaleErrorMessage(err: unknown): string {
  const raw = (err as { message?: unknown } | null)?.message;
  if (typeof raw !== 'string' || !raw) return 'Something went wrong';
  try {
    const parsed = JSON.parse(raw) as { error?: unknown };
    if (typeof parsed.error === 'string' && parsed.error) return parsed.error;
  } catch {
    /* plain text */
  }
  return raw.slice(0, 300);
}

export type RegisterServerInput = { name?: string; url: string; apiKey: string; sshHost?: string };
/** `sshHost: ''` clears the console target; omitting it leaves whatever is stored alone. */
export type UpdateServerInput = { id: number; name?: string; url?: string; apiKey?: string; sshHost?: string };

export function useHeadscaleServers() {
  const { get, post, patch, delete: del } = useClient();
  const qc = useQueryClient();

  const query = useQuery({
    queryKey: SERVERS_KEY,
    queryFn: () => get<{ servers: HeadscaleServer[] }>(BASE),
    staleTime: 30_000,
  });

  const invalidate = () => qc.invalidateQueries({ queryKey: SERVERS_KEY });

  const register = useMutation({
    mutationFn: (input: RegisterServerInput) => post<{ server: HeadscaleServer }>(BASE, input),
    onSuccess: invalidate,
  });

  const update = useMutation({
    mutationFn: ({ id, ...rest }: UpdateServerInput) => patch<{ server: HeadscaleServer }>(`${BASE}/${id}`, rest),
    onSuccess: invalidate,
  });

  const remove = useMutation({
    mutationFn: (id: number) => del(`${BASE}/${id}`),
    onSuccess: invalidate,
  });

  const activate = useMutation({
    mutationFn: (id: number) => post<{ server: HeadscaleServer }>(`${BASE}/${id}/activate`),
    // Deleting or switching reshuffles which server is active, and every domain query is scoped to it.
    onSuccess: () => qc.invalidateQueries({ queryKey: ['headscale'] }),
  });

  const servers = query.data?.servers ?? EMPTY;

  return {
    servers,
    active: servers.find((s) => s.isActive) ?? null,
    isLoading: query.isLoading,
    error: query.error,
    refetch: query.refetch,
    register,
    update,
    remove,
    activate,
  };
}

/**
 * Try to open a shell on a console target with the keys already on this machine. Takes the host rather than a
 * server id so the form can test a value before it is saved — which is when a typo is still cheap to fix.
 */
export function useHeadscaleSshTest() {
  const { post } = useClient();
  return useMutation({
    mutationFn: (host: string) => post<HeadscaleSshTest>('/offscale/_officer/ssh-test', { host }),
  });
}

/** On-demand reachability probe for one server. Never automatic — it costs two upstream round trips. */
export function useHeadscaleHealth() {
  const { get } = useClient();
  return useMutation({
    mutationFn: (id: number) => get<HeadscaleHealth>(`${BASE}/${id}/health`),
  });
}