digital-pilates/store/index.ts

import { configureStore, createListenerMiddleware } from '@reduxjs/toolkit';
import challengesReducer from './challengesSlice';
import checkinReducer, { addExercise, autoSyncCheckin, removeExercise, replaceExercises, setNote, toggleExerciseCompleted } from './checkinSlice';
import circumferenceReducer from './circumferenceSlice';
import exerciseLibraryReducer from './exerciseLibrarySlice';
import foodLibraryReducer from './foodLibrarySlice';
import foodRecognitionReducer from './foodRecognitionSlice';
import goalsReducer from './goalsSlice';
import healthReducer from './healthSlice';
import fastingReducer, {
  clearActiveSchedule,
  completeActiveSchedule,
  rescheduleActivePlan,
  scheduleFastingPlan,
  setRecommendedSchedule,
} from './fastingSlice';
import moodReducer from './moodSlice';
import nutritionReducer from './nutritionSlice';
import scheduleExerciseReducer from './scheduleExerciseSlice';
import tasksReducer from './tasksSlice';
import trainingPlanReducer from './trainingPlanSlice';
import userReducer from './userSlice';
import waterReducer from './waterSlice';
import workoutReducer from './workoutSlice';
import { persistActiveFastingSchedule } from '@/utils/fasting';

// 创建监听器中间件来处理自动同步
const listenerMiddleware = createListenerMiddleware();

// 监听所有数据变动的 actions，触发自动同步
const syncActions = [addExercise, removeExercise, replaceExercises, toggleExerciseCompleted, setNote];
syncActions.forEach(action => {
  listenerMiddleware.startListening({
    actionCreator: action,
    effect: async (action, listenerApi) => {
      const state = listenerApi.getState() as any;
      const date = action.payload?.date;

      if (!date) return;

      // 延迟一下，避免在同一事件循环中重复触发
      await new Promise(resolve => setTimeout(resolve, 100));

      // 检查是否还有待同步的日期
      const currentState = listenerApi.getState() as any;
      const pendingSyncDates = currentState?.checkin?.pendingSyncDates || [];

      if (pendingSyncDates.includes(date)) {
        listenerApi.dispatch(autoSyncCheckin({ date }));
      }
    },
  });
});

const persistFastingState = async (listenerApi: any) => {
  const state = listenerApi.getState() as { fasting?: { activeSchedule?: any } };
  await persistActiveFastingSchedule(state?.fasting?.activeSchedule ?? null);
};

listenerMiddleware.startListening({
  actionCreator: scheduleFastingPlan,
  effect: async (_, listenerApi) => {
    await persistFastingState(listenerApi);
  },
});

listenerMiddleware.startListening({
  actionCreator: rescheduleActivePlan,
  effect: async (_, listenerApi) => {
    await persistFastingState(listenerApi);
  },
});

listenerMiddleware.startListening({
  actionCreator: completeActiveSchedule,
  effect: async (_, listenerApi) => {
    await persistFastingState(listenerApi);
  },
});

listenerMiddleware.startListening({
  actionCreator: setRecommendedSchedule,
  effect: async (_, listenerApi) => {
    await persistFastingState(listenerApi);
  },
});

listenerMiddleware.startListening({
  actionCreator: clearActiveSchedule,
  effect: async () => {
    await persistActiveFastingSchedule(null);
  },
});

export const store = configureStore({
  reducer: {
    user: userReducer,
    challenges: challengesReducer,
    checkin: checkinReducer,
    circumference: circumferenceReducer,
    goals: goalsReducer,
    health: healthReducer,
    mood: moodReducer,
    nutrition: nutritionReducer,
    tasks: tasksReducer,
    trainingPlan: trainingPlanReducer,
    scheduleExercise: scheduleExerciseReducer,
    exerciseLibrary: exerciseLibraryReducer,
    foodLibrary: foodLibraryReducer,
    foodRecognition: foodRecognitionReducer,
    workout: workoutReducer,
    water: waterReducer,
    fasting: fastingReducer,
  },
  middleware: (getDefaultMiddleware) =>
    getDefaultMiddleware().prepend(listenerMiddleware.middleware),
});

export type RootState = ReturnType<typeof store.getState>;
export type AppDispatch = typeof store.dispatch;