import Taro from '@tarojs/taro';
|
import { useState, useEffect, useRef, useCallback } from 'react';
|
import { getRemainingSeconds, parseFlexibleEndTimeMs } from '../../../../../utils/Robotaxi-public-method';
|
import { getWaitTime, queryOrderFinishTime, cancelOrder, queryFareBreakdown } from '../../../../api/begin-route';
|
|
type Props = {
|
tripStatus: number;
|
orderId?: string;
|
estimatedWaitMinutes?: number;
|
finishCountdownEnabled: boolean;
|
handleCancelTimeout?: () => void;
|
handleFinishTimeout?: () => void;
|
priceUpdateVersion?: number;
|
};
|
|
const PICKUP_END_TIME_KEY = 'pickupEndTime';
|
const FINISH_END_TIME_KEY = 'finishEndTime';
|
|
const getTargetOrderId = (orderId?: string) => orderId || Taro.getStorageSync('orderId');
|
|
export default function useTripCountdown({
|
tripStatus,
|
orderId,
|
estimatedWaitMinutes,
|
finishCountdownEnabled,
|
handleCancelTimeout,
|
handleFinishTimeout,
|
priceUpdateVersion
|
}: Props) {
|
const [waitMinutes, setWaitMinutes] = useState<number | null>(null);
|
const [limitMinutes, setLimitMinutes] = useState<number | null>(null);
|
const [pickupCountdownSeconds, setPickupCountdownSeconds] = useState<number | null>(null);
|
const [finishCountdownSeconds, setFinishCountdownSeconds] = useState<number | null>(null);
|
const [fareBreakdown, setFareBreakdown] = useState<any>(null);
|
|
const pickupTimerRef = useRef<any>(null);
|
const finishTimerRef = useRef<any>(null);
|
const countdownFinishedRef = useRef(false);
|
const pickupTripStatusRef = useRef(tripStatus);
|
const pickupEndTimeRef = useRef<number | null>(null);
|
const finishEndTimeRef = useRef<number | null>(null);
|
const lastFareOrderIdRef = useRef<string | null>(null);
|
|
const requestFareBreakdown = useCallback((force = false) => {
|
const targetOrderId = getTargetOrderId(orderId);
|
if (!targetOrderId) return;
|
if (!force && lastFareOrderIdRef.current === targetOrderId) return;
|
lastFareOrderIdRef.current = targetOrderId;
|
queryFareBreakdown(targetOrderId).then((res: any) => {
|
setFareBreakdown(res?.data ?? res?.result ?? res);
|
}).catch(() => { });
|
}, [orderId]);
|
|
const clearPickupTimer = useCallback(() => {
|
if (pickupTimerRef.current) {
|
clearTimeout(pickupTimerRef.current);
|
pickupTimerRef.current = null;
|
}
|
}, []);
|
|
const clearFinishTimer = useCallback(() => {
|
if (finishTimerRef.current) {
|
clearTimeout(finishTimerRef.current);
|
finishTimerRef.current = null;
|
}
|
}, []);
|
|
const scheduleAlignedTick = (endMs: number, runner: () => void) => {
|
const now = Date.now();
|
const diffMs = endMs - now;
|
const delay = diffMs > 0 ? (diffMs % 1000 || 1000) : 1000;
|
return setTimeout(runner, delay);
|
};
|
|
useEffect(() => {
|
if (typeof priceUpdateVersion === 'number' && priceUpdateVersion > 0 && [8, 9].includes(tripStatus)) {
|
requestFareBreakdown(true);
|
}
|
}, [priceUpdateVersion, tripStatus, requestFareBreakdown]);
|
|
useEffect(() => {
|
let active = true;
|
if (tripStatus !== 3) return () => { active = false; };
|
if (typeof estimatedWaitMinutes === 'number' && !Number.isNaN(estimatedWaitMinutes)) {
|
setWaitMinutes(estimatedWaitMinutes);
|
return () => { active = false; };
|
}
|
const startSite = Taro.getStorageSync('startSite');
|
getWaitTime({ latitude: startSite?.latitude, longitude: startSite?.longitude })
|
.then((res) => {
|
const minutes = Number(res);
|
if (active && !Number.isNaN(minutes)) {
|
setWaitMinutes(minutes);
|
}
|
})
|
.catch(() => { });
|
return () => {
|
active = false;
|
};
|
}, [tripStatus, estimatedWaitMinutes]);
|
|
useEffect(() => {
|
if (tripStatus !== 4) return;
|
const startSite = Taro.getStorageSync('startSite');
|
const time = Number(startSite?.time);
|
if (!Number.isNaN(time)) {
|
setLimitMinutes(time);
|
}
|
}, [tripStatus]);
|
|
useEffect(() => {
|
pickupTripStatusRef.current = tripStatus;
|
}, [tripStatus]);
|
|
useEffect(() => {
|
if (tripStatus !== 5) {
|
clearPickupTimer();
|
return;
|
}
|
|
const runPickupTick = () => {
|
// 防止状态已切换后，旧定时回调仍触发取消逻辑
|
if (pickupTripStatusRef.current !== 5) {
|
clearPickupTimer();
|
return;
|
}
|
const remaining = getRemainingSeconds(pickupEndTimeRef.current);
|
if (remaining !== null && remaining <= 0) {
|
if (!countdownFinishedRef.current) {
|
countdownFinishedRef.current = true;
|
const targetOrderId = getTargetOrderId(orderId);
|
if (targetOrderId) {
|
cancelOrder(targetOrderId).finally(() => {
|
Taro.removeStorageSync(PICKUP_END_TIME_KEY);
|
handleCancelTimeout?.();
|
});
|
} else {
|
Taro.removeStorageSync(PICKUP_END_TIME_KEY);
|
handleCancelTimeout?.();
|
}
|
}
|
clearPickupTimer();
|
setPickupCountdownSeconds(0);
|
return;
|
}
|
setPickupCountdownSeconds(remaining);
|
if (!pickupEndTimeRef.current) return;
|
pickupTimerRef.current = scheduleAlignedTick(pickupEndTimeRef.current, runPickupTick);
|
};
|
|
const startSite = Taro.getStorageSync('startSite');
|
const limitMin = Number(startSite?.time);
|
const cachedEndTime = Taro.getStorageSync(PICKUP_END_TIME_KEY);
|
const hasValidCached = typeof cachedEndTime === 'number' && cachedEndTime > Date.now();
|
|
if (hasValidCached) {
|
pickupEndTimeRef.current = cachedEndTime;
|
} else if (!Number.isNaN(limitMin) && limitMin > 0) {
|
pickupEndTimeRef.current = Date.now() + limitMin * 60 * 1000;
|
Taro.setStorageSync(PICKUP_END_TIME_KEY, pickupEndTimeRef.current);
|
} else {
|
pickupEndTimeRef.current = null;
|
}
|
|
if (!pickupEndTimeRef.current) {
|
setPickupCountdownSeconds(null);
|
return;
|
}
|
|
countdownFinishedRef.current = false;
|
setPickupCountdownSeconds(getRemainingSeconds(pickupEndTimeRef.current));
|
clearPickupTimer();
|
runPickupTick();
|
|
return () => {
|
clearPickupTimer();
|
};
|
}, [tripStatus, orderId, handleCancelTimeout, clearPickupTimer]);
|
|
useEffect(() => {
|
if (tripStatus !== 7) {
|
clearFinishTimer();
|
return;
|
}
|
|
const runFinishTick = () => {
|
const remaining = getRemainingSeconds(finishEndTimeRef.current);
|
if (remaining !== null && remaining <= 0) {
|
clearFinishTimer();
|
setFinishCountdownSeconds(0);
|
Taro.removeStorageSync(FINISH_END_TIME_KEY);
|
handleFinishTimeout?.();
|
return;
|
}
|
setFinishCountdownSeconds(remaining);
|
if (!finishEndTimeRef.current) return;
|
finishTimerRef.current = scheduleAlignedTick(finishEndTimeRef.current, runFinishTick);
|
};
|
|
const initCountdown = (endTimeMs: number | null) => {
|
finishEndTimeRef.current = endTimeMs;
|
if (typeof endTimeMs === 'number' && endTimeMs > Date.now()) {
|
Taro.setStorageSync(FINISH_END_TIME_KEY, endTimeMs);
|
} else {
|
Taro.removeStorageSync(FINISH_END_TIME_KEY);
|
}
|
const remaining = getRemainingSeconds(endTimeMs);
|
if (remaining === null) {
|
setFinishCountdownSeconds(null);
|
return;
|
}
|
setFinishCountdownSeconds(remaining);
|
clearFinishTimer();
|
runFinishTick();
|
};
|
|
const cachedEndTime = Taro.getStorageSync(FINISH_END_TIME_KEY);
|
const hasValidCached = typeof cachedEndTime === 'number' && cachedEndTime > Date.now();
|
if (hasValidCached) {
|
initCountdown(cachedEndTime);
|
} else {
|
queryOrderFinishTime().then((res: any) => {
|
initCountdown(parseFlexibleEndTimeMs(res));
|
}).catch(() => {
|
setFinishCountdownSeconds(null);
|
finishEndTimeRef.current = null;
|
Taro.removeStorageSync(FINISH_END_TIME_KEY);
|
});
|
}
|
|
return () => {
|
if (typeof finishEndTimeRef.current === 'number' && finishEndTimeRef.current > Date.now()) {
|
Taro.setStorageSync(FINISH_END_TIME_KEY, finishEndTimeRef.current);
|
}
|
clearFinishTimer();
|
};
|
}, [tripStatus, handleFinishTimeout, finishCountdownEnabled, clearFinishTimer]);
|
|
useEffect(() => {
|
if ([8, 9].includes(tripStatus)) {
|
Taro.removeStorageSync(FINISH_END_TIME_KEY);
|
requestFareBreakdown();
|
}
|
}, [tripStatus, requestFareBreakdown]);
|
|
return {
|
waitMinutes,
|
limitMinutes,
|
pickupCountdownSeconds,
|
finishCountdownSeconds,
|
fareBreakdown
|
};
|
}
|
