489 lines
16 KiB
TypeScript
489 lines
16 KiB
TypeScript
"use client";
|
|
|
|
import { useCallback, useEffect, useMemo, useState } from "react";
|
|
import {
|
|
enqueueAiCityFetch,
|
|
extractStreamingAirportRead,
|
|
parseSseBlock,
|
|
} from "@/components/dashboard/scan-terminal/ai-city-stream";
|
|
import type {
|
|
AiCityForecastPayload,
|
|
AiCityForecastState,
|
|
} from "@/components/dashboard/scan-terminal/types";
|
|
import { useDashboardStore } from "@/hooks/useDashboardStore";
|
|
import type { CityDetail, MarketScan } from "@/lib/dashboard-types";
|
|
import { normalizeCityKey } from "./decision-utils";
|
|
|
|
const AI_CITY_FORECAST_CACHE_PREFIX = "polyWeather_aiCityForecast_v1";
|
|
const AI_CITY_FORECAST_CACHE_TTL_MS = 60 * 60 * 1000;
|
|
const CITY_MARKET_SCAN_CACHE_PREFIX = "polyWeather_cityMarketScan_v1";
|
|
const CITY_MARKET_SCAN_CACHE_TTL_MS = 10 * 60 * 1000;
|
|
|
|
function getStorage() {
|
|
if (typeof window === "undefined") return null;
|
|
try {
|
|
return window.localStorage;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function buildStorageKey(prefix: string, parts: Array<string | null | undefined>) {
|
|
return `${prefix}:${parts
|
|
.map((part) => encodeURIComponent(String(part || "").trim()))
|
|
.join(":")}`;
|
|
}
|
|
|
|
function readCachedPayload<T>(key: string, ttlMs: number): T | null {
|
|
const storage = getStorage();
|
|
if (!storage) return null;
|
|
try {
|
|
const raw = storage.getItem(key);
|
|
if (!raw) return null;
|
|
const parsed = JSON.parse(raw) as { cachedAt?: number; payload?: T };
|
|
if (!parsed?.payload) return null;
|
|
if (Date.now() - Number(parsed.cachedAt || 0) > ttlMs) {
|
|
storage.removeItem(key);
|
|
return null;
|
|
}
|
|
return parsed.payload;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function writeCachedPayload<T>(key: string, payload: T) {
|
|
const storage = getStorage();
|
|
if (!storage) return;
|
|
try {
|
|
storage.setItem(key, JSON.stringify({ cachedAt: Date.now(), payload }));
|
|
} catch {
|
|
// Ignore quota/privacy-mode failures; network fallbacks still work.
|
|
}
|
|
}
|
|
|
|
function buildPartialAiStreamPayload({
|
|
fallbackText,
|
|
isEn,
|
|
tempSymbol,
|
|
}: {
|
|
fallbackText?: string | null;
|
|
isEn: boolean;
|
|
tempSymbol?: string | null;
|
|
}): AiCityForecastPayload {
|
|
const preservedText =
|
|
String(fallbackText || "").trim() ||
|
|
(isEn
|
|
? "The AI airport read stream was interrupted after partial output."
|
|
: "AI 机场报文解读已输出部分内容，但最终载荷未返回。");
|
|
const retryHint = isEn
|
|
? "The streaming connection ended before the final structured payload. The partial airport read above is preserved; refresh once if you need the full JSON-backed conclusion."
|
|
: "流式连接在最终结构化载荷返回前结束。上方已保留已输出的机场报文解读；如需完整 JSON 结论可刷新一次。";
|
|
|
|
return {
|
|
city_forecast: {
|
|
confidence: "low",
|
|
final_judgment_en: isEn
|
|
? preservedText
|
|
: "Partial AI airport read was preserved after the stream ended early.",
|
|
final_judgment_zh: isEn
|
|
? "AI 机场报文解读已保留部分输出，但流式连接提前结束。"
|
|
: preservedText,
|
|
metar_read_en: isEn ? preservedText : "",
|
|
metar_read_zh: isEn ? "" : preservedText,
|
|
model_cluster_note_en: "",
|
|
model_cluster_note_zh: "",
|
|
predicted_max: null,
|
|
range_high: null,
|
|
range_low: null,
|
|
reasoning_en: retryHint,
|
|
reasoning_zh: retryHint,
|
|
risks_en: isEn ? [retryHint] : [],
|
|
risks_zh: isEn ? [] : [retryHint],
|
|
unit: tempSymbol || "°C",
|
|
},
|
|
raw_reason: "partial_ai_stream_without_final_payload",
|
|
reason: retryHint,
|
|
reason_en: isEn
|
|
? retryHint
|
|
: "AI stream ended before the final payload; partial text was preserved.",
|
|
reason_zh: isEn ? "AI 流在最终载荷前结束；已保留部分文本。" : retryHint,
|
|
status: "partial_stream",
|
|
};
|
|
}
|
|
|
|
export function useAiCityForecast({
|
|
detail,
|
|
detailCityName,
|
|
isEn,
|
|
locale,
|
|
report,
|
|
enabled = true,
|
|
}: {
|
|
detail: CityDetail | null;
|
|
detailCityName: string;
|
|
enabled?: boolean;
|
|
isEn: boolean;
|
|
locale: string;
|
|
report: string;
|
|
}) {
|
|
const [aiForecast, setAiForecast] = useState<AiCityForecastState>({
|
|
status: "idle",
|
|
});
|
|
const [aiRefreshToken, setAiRefreshToken] = useState(0);
|
|
const aiForecastKey = useMemo(
|
|
() =>
|
|
detail
|
|
? `${normalizeCityKey(detailCityName)}:${detail.local_date || ""}:${locale}:${report || ""}`
|
|
: "",
|
|
[detail, detailCityName, locale, report],
|
|
);
|
|
const aiTempSymbol = detail?.temp_symbol || "°C";
|
|
|
|
useEffect(() => {
|
|
if (!enabled || !aiForecastKey) {
|
|
setAiForecast({ status: "idle" });
|
|
return;
|
|
}
|
|
let cancelled = false;
|
|
const controller = new AbortController();
|
|
const cacheKey = buildStorageKey(AI_CITY_FORECAST_CACHE_PREFIX, [aiForecastKey]);
|
|
const cachedPayload =
|
|
aiRefreshToken <= 0
|
|
? readCachedPayload<AiCityForecastPayload>(
|
|
cacheKey,
|
|
AI_CITY_FORECAST_CACHE_TTL_MS,
|
|
)
|
|
: null;
|
|
if (cachedPayload) {
|
|
setAiForecast({ payload: cachedPayload, status: "ready" });
|
|
return () => {
|
|
cancelled = true;
|
|
controller.abort();
|
|
};
|
|
}
|
|
setAiForecast({ status: "loading", streamText: null, streamRaw: "" });
|
|
enqueueAiCityFetch(
|
|
() =>
|
|
fetch("/api/scan/terminal/ai-city/stream", {
|
|
method: "POST",
|
|
headers: {
|
|
Accept: "text/event-stream",
|
|
"Content-Type": "application/json",
|
|
},
|
|
cache: "no-store",
|
|
signal: controller.signal,
|
|
body: JSON.stringify({
|
|
city: detailCityName,
|
|
force_refresh: aiRefreshToken > 0,
|
|
locale,
|
|
}),
|
|
}).then(async (response) => {
|
|
if (!response.ok) {
|
|
let detailMessage = "";
|
|
try {
|
|
const errorPayload = await response.json();
|
|
const message = String(errorPayload?.error || "").trim();
|
|
const rawDetail = String(errorPayload?.detail || "").trim();
|
|
const elapsed = Number(errorPayload?.elapsed_ms);
|
|
const timeout = Number(errorPayload?.timeout_ms);
|
|
detailMessage = [
|
|
message,
|
|
rawDetail,
|
|
Number.isFinite(elapsed) && Number.isFinite(timeout)
|
|
? `elapsed ${Math.round(elapsed / 1000)}s / timeout ${Math.round(timeout / 1000)}s`
|
|
: "",
|
|
]
|
|
.filter(Boolean)
|
|
.join(" · ");
|
|
} catch {
|
|
detailMessage = "";
|
|
}
|
|
throw new Error(
|
|
detailMessage
|
|
? `HTTP ${response.status} · ${detailMessage}`
|
|
: `HTTP ${response.status}`,
|
|
);
|
|
}
|
|
const contentType = response.headers.get("content-type") || "";
|
|
if (!response.body || !contentType.includes("text/event-stream")) {
|
|
return response.json() as Promise<AiCityForecastPayload>;
|
|
}
|
|
|
|
const reader = response.body.getReader();
|
|
const decoder = new TextDecoder();
|
|
let buffer = "";
|
|
let rawStream = "";
|
|
let finalPayload: AiCityForecastPayload | null = null;
|
|
let latestReadableText = "";
|
|
const rememberReadableText = (value?: string | null) => {
|
|
const text = String(value || "").trim();
|
|
if (text) {
|
|
latestReadableText = text;
|
|
}
|
|
};
|
|
const handleBlock = (block: string) => {
|
|
const message = parseSseBlock(block);
|
|
if (!message || !message.data || typeof message.data !== "object") {
|
|
return;
|
|
}
|
|
const data = message.data as Record<string, unknown>;
|
|
if (message.event === "progress") {
|
|
const progressText =
|
|
String(
|
|
locale === "en-US" ? data.message_en || "" : data.message_zh || "",
|
|
).trim() || String(data.message || "").trim();
|
|
if (progressText && !cancelled) {
|
|
rememberReadableText(progressText);
|
|
setAiForecast((current) =>
|
|
current.status === "loading"
|
|
? { ...current, streamText: current.streamText || progressText }
|
|
: current,
|
|
);
|
|
}
|
|
} else if (message.event === "preview") {
|
|
const previewText =
|
|
String(
|
|
locale === "en-US"
|
|
? data.metar_read_en || ""
|
|
: data.metar_read_zh || "",
|
|
).trim() ||
|
|
String(data.metar_read_zh || data.metar_read_en || "").trim() ||
|
|
String(
|
|
locale === "en-US"
|
|
? data.final_judgment_en || ""
|
|
: data.final_judgment_zh || "",
|
|
).trim() ||
|
|
String(data.final_judgment_zh || data.final_judgment_en || "").trim();
|
|
if (previewText && !cancelled) {
|
|
rememberReadableText(previewText);
|
|
setAiForecast((current) =>
|
|
current.status === "loading"
|
|
? {
|
|
...current,
|
|
streamText: previewText,
|
|
}
|
|
: current,
|
|
);
|
|
}
|
|
} else if (message.event === "delta") {
|
|
const content = String(data.content || "");
|
|
if (!content) return;
|
|
rawStream += content;
|
|
const airportRead = extractStreamingAirportRead(rawStream, locale);
|
|
const streamingText =
|
|
airportRead ||
|
|
(rawStream.trim()
|
|
? isEn
|
|
? "AI has started streaming; parsing the METAR read field…"
|
|
: "AI 已开始流式输出，正在解析机场报文字段…"
|
|
: "");
|
|
rememberReadableText(airportRead || streamingText);
|
|
if (!cancelled) {
|
|
setAiForecast((current) =>
|
|
current.status === "loading"
|
|
? {
|
|
...current,
|
|
streamRaw: rawStream,
|
|
streamText: streamingText || current.streamText || null,
|
|
}
|
|
: current,
|
|
);
|
|
}
|
|
} else if (message.event === "final") {
|
|
finalPayload = data as AiCityForecastPayload;
|
|
}
|
|
};
|
|
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
buffer += decoder.decode(value, { stream: true });
|
|
const blocks = buffer.split(/\n\n|\r\n\r\n/);
|
|
buffer = blocks.pop() || "";
|
|
for (const block of blocks) {
|
|
handleBlock(block);
|
|
}
|
|
}
|
|
buffer += decoder.decode();
|
|
if (buffer.trim()) {
|
|
handleBlock(buffer);
|
|
}
|
|
if (!finalPayload) {
|
|
const fallbackText =
|
|
extractStreamingAirportRead(rawStream, locale) ||
|
|
latestReadableText;
|
|
const partialPayload = buildPartialAiStreamPayload({
|
|
fallbackText,
|
|
isEn,
|
|
tempSymbol: aiTempSymbol,
|
|
});
|
|
writeCachedPayload(cacheKey, partialPayload);
|
|
return partialPayload;
|
|
}
|
|
return finalPayload;
|
|
}),
|
|
controller.signal,
|
|
{
|
|
onQueued: () => {
|
|
if (cancelled) return;
|
|
setAiForecast((current) =>
|
|
current.status === "loading"
|
|
? {
|
|
...current,
|
|
streamText: isEn
|
|
? "Waiting for the AI airport read queue..."
|
|
: "正在等待 AI 机场报文解读队列...",
|
|
}
|
|
: current,
|
|
);
|
|
},
|
|
onStart: () => {
|
|
if (cancelled) return;
|
|
setAiForecast((current) =>
|
|
current.status === "loading"
|
|
? {
|
|
...current,
|
|
streamText: current.streamRaw
|
|
? current.streamText
|
|
: isEn
|
|
? "Connecting to DeepSeek V4-Pro for airport bulletin streaming..."
|
|
: "正在连接 DeepSeek V4-Pro，准备流式解读机场报文...",
|
|
}
|
|
: current,
|
|
);
|
|
},
|
|
},
|
|
)
|
|
.then((payload) => {
|
|
if (!cancelled) {
|
|
writeCachedPayload(cacheKey, payload);
|
|
setAiForecast({ payload, status: "ready" });
|
|
}
|
|
})
|
|
.catch((error) => {
|
|
if (controller.signal.aborted) return;
|
|
if (!cancelled) {
|
|
const message = String(error);
|
|
if (message.includes("AI stream ended before final payload")) {
|
|
setAiForecast((current) => {
|
|
const partialPayload = buildPartialAiStreamPayload({
|
|
fallbackText: current.streamText,
|
|
isEn,
|
|
tempSymbol: aiTempSymbol,
|
|
});
|
|
writeCachedPayload(cacheKey, partialPayload);
|
|
return {
|
|
payload: partialPayload,
|
|
status: "ready",
|
|
};
|
|
});
|
|
return;
|
|
}
|
|
setAiForecast({ error: String(error), status: "failed" });
|
|
}
|
|
});
|
|
return () => {
|
|
cancelled = true;
|
|
controller.abort();
|
|
};
|
|
}, [aiForecastKey, aiRefreshToken, aiTempSymbol, detailCityName, enabled, isEn, locale]);
|
|
|
|
const refreshAiForecast = useCallback(() => {
|
|
setAiRefreshToken((current) => current + 1);
|
|
}, []);
|
|
|
|
return { aiForecast, refreshAiForecast };
|
|
}
|
|
|
|
export function useCityMarketScan({
|
|
detail,
|
|
detailCityName,
|
|
enabled = true,
|
|
}: {
|
|
detail: CityDetail | null;
|
|
detailCityName: string;
|
|
enabled?: boolean;
|
|
}) {
|
|
const ensureCityMarketScan = useDashboardStore().ensureCityMarketScan;
|
|
const [marketScan, setMarketScan] = useState<MarketScan | null>(
|
|
detail?.market_scan || null,
|
|
);
|
|
const [marketStatus, setMarketStatus] = useState<
|
|
"idle" | "loading" | "ready" | "failed"
|
|
>(detail?.market_scan ? "ready" : "idle");
|
|
|
|
useEffect(() => {
|
|
if (!detail) {
|
|
setMarketScan(null);
|
|
setMarketStatus("idle");
|
|
return;
|
|
}
|
|
const cacheKey = buildStorageKey(CITY_MARKET_SCAN_CACHE_PREFIX, [
|
|
normalizeCityKey(detailCityName),
|
|
detail.local_date || "",
|
|
"lite",
|
|
]);
|
|
let cancelled = false;
|
|
if (detail.market_scan) {
|
|
setMarketScan(detail.market_scan);
|
|
setMarketStatus("ready");
|
|
writeCachedPayload(cacheKey, detail.market_scan);
|
|
return () => {
|
|
cancelled = true;
|
|
};
|
|
}
|
|
if (!enabled) {
|
|
const cached = readCachedPayload<MarketScan>(
|
|
cacheKey,
|
|
CITY_MARKET_SCAN_CACHE_TTL_MS,
|
|
);
|
|
if (cached) {
|
|
setMarketScan(cached);
|
|
setMarketStatus("ready");
|
|
} else {
|
|
setMarketScan(null);
|
|
setMarketStatus("idle");
|
|
}
|
|
return () => {
|
|
cancelled = true;
|
|
};
|
|
}
|
|
const cached = readCachedPayload<MarketScan>(
|
|
cacheKey,
|
|
CITY_MARKET_SCAN_CACHE_TTL_MS,
|
|
);
|
|
if (cached) {
|
|
setMarketScan(cached);
|
|
setMarketStatus("ready");
|
|
return () => {
|
|
cancelled = true;
|
|
};
|
|
} else {
|
|
setMarketStatus("loading");
|
|
}
|
|
void ensureCityMarketScan(detailCityName, false, {
|
|
lite: true,
|
|
targetDate: detail.local_date || null,
|
|
})
|
|
.then((payload) => {
|
|
if (cancelled) return;
|
|
if (payload) {
|
|
writeCachedPayload(cacheKey, payload);
|
|
}
|
|
setMarketScan(payload || detail.market_scan || null);
|
|
setMarketStatus("ready");
|
|
})
|
|
.catch(() => {
|
|
if (cancelled) return;
|
|
setMarketScan(detail.market_scan || null);
|
|
setMarketStatus(detail.market_scan ? "ready" : "failed");
|
|
});
|
|
return () => {
|
|
cancelled = true;
|
|
};
|
|
}, [detail, detailCityName, enabled, ensureCityMarketScan]);
|
|
|
|
return { marketScan, marketStatus };
|
|
}
|