import {
  configureStore,
  combineReducers,
  type Reducer,
} from "@reduxjs/toolkit";
import storage from "redux-persist/lib/storage"; // defaults to localStorage for web
import { createTransform, persistReducer, persistStore } from "redux-persist";
import { createEpicMiddleware, combineEpics } from "redux-observable";
import advancedSearchReducer from "./advanedSearch/advancedSearchSlice";
import authReducer from "./auth/authSlice";
import uiReducer from "./ui/uiSlice";
import userEpics from "./user/epic";
import authEpics from "./auth/epic";

type PersistedAuth = { user: unknown | null };

const persistConfig = {
  key: "root",
  storage,
  whitelist: ["auth"], // only persist auth slice
  transforms: [
    // Persist only the `user` subkey from the auth slice
    createTransform(
      (inboundState: unknown): PersistedAuth => {
        const s = inboundState as { user?: unknown } | null | undefined;
        return { user: s?.user ?? null };
      },
      (outboundState: unknown): PersistedAuth => {
        const s = outboundState as { user?: unknown } | null | undefined;
        return { user: s?.user ?? null };
      },
      { whitelist: ["auth"] }
    ),
  ],
};

const rootReducer = combineReducers({
  advancedSearch: advancedSearchReducer,
  auth: authReducer,
  ui: uiReducer,
});

const rootEpic = combineEpics(...userEpics, ...authEpics);

const persistedReducer = persistReducer(persistConfig, rootReducer as Reducer);

// Create epic middleware
const epicMiddleware = createEpicMiddleware();

export const makeStore = () => {
  const store = configureStore({
    reducer: persistedReducer,
    devTools: process.env.NODE_ENV !== "production",
    middleware: getDefaultMiddleware =>
      getDefaultMiddleware({
        serializableCheck: false, // redux-persist uses non-serializable values
      }).concat(epicMiddleware),
  });

  // Run the epic
  epicMiddleware.run(rootEpic);

  return store;
};

// Create store + persistor
export const store = makeStore();
export const persistor = persistStore(store);

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