homeio

1"use client";
2
3import {
4  POWER_ACTION_STATE_CHANGED_EVENT,
5  readPersistedPowerActionState,
6} from "@/lib/desktop/reboot-state";
7import { queryKeys } from "@/lib/shared/query-keys";
8import { useQueryClient } from "@tanstack/react-query";
9import { useEffect, useState } from "react";
10
11type ConnectionStatus = "connecting" | "connected" | "disconnected";
12type ParsedNetworkEvent = {
13  connected: boolean | null;
14  iface: string | null;
15  ssid: string | null;
16  state: string | null;
17  reason: string | null;
18};
19
20const INVALIDATION_DEBOUNCE_MS = 600;
21const INVALIDATION_COOLDOWN_MS = 4_000;
22const ERROR_LOG_COOLDOWN_MS = 30_000;
23
24function parseNetworkEventPayload(data: string): ParsedNetworkEvent | null {
25  try {
26    const parsed = JSON.parse(data) as Partial<{
27      connected: unknown;
28      iface: unknown;
29      ssid: unknown;
30      state: unknown;
31      reason: unknown;
32    }>;
33
34    return {
35      connected:
36        typeof parsed.connected === "boolean" ? parsed.connected : null,
37      iface: typeof parsed.iface === "string" ? parsed.iface : null,
38      ssid: typeof parsed.ssid === "string" ? parsed.ssid : null,
39      state: typeof parsed.state === "string" ? parsed.state : null,
40      reason: typeof parsed.reason === "string" ? parsed.reason : null,
41    };
42  } catch {
43    return null;
44  }
45}
46
47function networkEventSignature(
48  type: string,
49  payload: ParsedNetworkEvent | null,
50) {
51  if (!payload) {
52    return `${type}:unknown`;
53  }
54
55  return [
56    type,
57    payload.connected === null ? "?" : String(payload.connected),
58    payload.iface ?? "",
59    payload.ssid ?? "",
60    payload.state ?? "",
61    payload.reason ?? "",
62  ].join("|");
63}
64
65export function useNetworkEventsSse(enabled = true) {
66  const queryClient = useQueryClient();
67  const initialPowerActionActive =
68    typeof window !== "undefined" &&
69    readPersistedPowerActionState(window.localStorage) !== null;
70  const [isPowerActionActive, setIsPowerActionActive] = useState(
71    initialPowerActionActive,
72  );
73  const [status, setStatus] = useState<ConnectionStatus>(
74    enabled && !initialPowerActionActive ? "connecting" : "disconnected",
75  );
76
77  useEffect(() => {
78    if (typeof window === "undefined") return;
79
80    const syncPowerActionState = () => {
81      setIsPowerActionActive(
82        readPersistedPowerActionState(window.localStorage) !== null,
83      );
84    };
85
86    syncPowerActionState();
87
88    window.addEventListener("storage", syncPowerActionState);
89    window.addEventListener(
90      POWER_ACTION_STATE_CHANGED_EVENT,
91      syncPowerActionState,
92    );
93
94    return () => {
95      window.removeEventListener("storage", syncPowerActionState);
96      window.removeEventListener(
97        POWER_ACTION_STATE_CHANGED_EVENT,
98        syncPowerActionState,
99      );
100    };
101  }, []);
102
103  useEffect(() => {
104    if (!enabled || isPowerActionActive) {
105      setStatus("disconnected");
106      return;
107    }
108
109    const source = new EventSource("/api/v1/network/events/stream");
110    let refreshTimeout: ReturnType<typeof setTimeout> | null = null;
111    let refreshQueued = false;
112    let queuedNeedsNetworks = false;
113    let lastInvalidateAt = 0;
114    let lastConnectionSignature = "";
115    let lastDeviceSignature = "";
116    let lastErrorLogAt = 0;
117
118    source.onopen = () => {
119      setStatus("connected");
120    };
121
122    const refreshCachedQueries = (needsNetworks: boolean) => {
123      const invalidations = [
124        queryClient.invalidateQueries({
125          queryKey: queryKeys.networkStatus,
126        }),
127      ];
128      if (needsNetworks) {
129        invalidations.push(
130          queryClient.invalidateQueries({
131            queryKey: queryKeys.networkNetworks,
132          }),
133        );
134      }
135      void Promise.all(invalidations);
136    };
137
138    const flushRefresh = () => {
139      const now = Date.now();
140      const elapsedMs = now - lastInvalidateAt;
141      if (elapsedMs < INVALIDATION_COOLDOWN_MS) {
142        const waitMs = INVALIDATION_COOLDOWN_MS - elapsedMs;
143        refreshTimeout = setTimeout(flushRefresh, waitMs);
144        return;
145      }
146
147      const needsNetworks = queuedNeedsNetworks;
148      queuedNeedsNetworks = false;
149      refreshQueued = false;
150      refreshTimeout = null;
151      lastInvalidateAt = now;
152      refreshCachedQueries(needsNetworks);
153    };
154
155    const scheduleRefresh = (needsNetworks: boolean) => {
156      queuedNeedsNetworks = queuedNeedsNetworks || needsNetworks;
157      if (refreshQueued) return;
158      refreshQueued = true;
159      refreshTimeout = setTimeout(flushRefresh, INVALIDATION_DEBOUNCE_MS);
160    };
161
162    const onConnectionChanged = (event: MessageEvent) => {
163      const payload = parseNetworkEventPayload(event.data);
164      const signature = networkEventSignature(
165        "network.connection.changed",
166        payload,
167      );
168      if (signature === lastConnectionSignature) return;
169      lastConnectionSignature = signature;
170      scheduleRefresh(true);
171    };
172
173    const onDeviceStateChanged = (event: MessageEvent) => {
174      const payload = parseNetworkEventPayload(event.data);
175      const signature = networkEventSignature(
176        "network.device.state.changed",
177        payload,
178      );
179      if (signature === lastDeviceSignature) return;
180      lastDeviceSignature = signature;
181      scheduleRefresh(true);
182    };
183
184    const onError = () => {
185      setStatus("disconnected");
186      const now = Date.now();
187      if (now - lastErrorLogAt < ERROR_LOG_COOLDOWN_MS) {
188        return;
189      }
190      lastErrorLogAt = now;
191    };
192
193    source.addEventListener("network.connection.changed", onConnectionChanged);
194    source.addEventListener(
195      "network.device.state.changed",
196      onDeviceStateChanged,
197    );
198    source.addEventListener("error", onError);
199
200    return () => {
201      if (refreshTimeout !== null) {
202        clearTimeout(refreshTimeout);
203      }
204      source.removeEventListener(
205        "network.connection.changed",
206        onConnectionChanged,
207      );
208      source.removeEventListener(
209        "network.device.state.changed",
210        onDeviceStateChanged,
211      );
212      source.removeEventListener("error", onError);
213      source.close();
214
215      setStatus("disconnected");
216    };
217  }, [enabled, isPowerActionActive, queryClient]);
218
219  return {
220    status,
221  };
222}
223