const obj1 = { a: 1, b: { c: 2, d: [3, 4, { e: 5 }] } };  
const obj2 = { a: 1, b: { c: 2, d: [3, 4, { e: 5 }] } };  

export const shallowEquals = (a: unknown, b: unknown) => {  
	if (Object.is(a, b)) return true;  
	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;

	const isArrayA = Array.isArray(a);  
	const isArrayB = Array.isArray(b);  
	if (isArrayA !== isArrayB) return false;

	// 둘 다 배열이면 배열 비교  
	if (isArrayA && isArrayB) {  
		if (a.length !== b.length) return false;  
		for (let i = 0; i < a.length; i++) {  
			if (!Object.is(a[i], b[i])) return false;  
		}  
		return true;  
	}

	// 둘 다 객체면 객체 비교  
	const aObj = a as Record<string, unknown>;  
	const bObj = b as Record<string, unknown>;  
	const aKeys = Object.keys(aObj);  
	const bKeys = Object.keys(bObj);

	if (aKeys.length !== bKeys.length) return false;  
	for (const key of aKeys) {  
		if (!(key in bObj)) return false;  
		if (!Object.is(aObj[key], bObj[key])) return false;  
	}  
	return true;  
};  

const isArray = (value: unknown) => Array.isArray(value);  
const isObject = (value: unknown) => typeof value === 'object' && value !== null;  
const compareArrays = (a: unknown[], b: unknown[]) =>  
  a.length === b.length && a.every((item, index) => Object.is(item, b[index]));  
const compareObjects = (a: object, b: object) => {  
  const keysA = Object.keys(a);  
  const keysB = Object.keys(b);  
  return (  
    keysA.length === keysB.length && keysA.every((key) => key in b && Object.is(a[key], b[key]))  
  );  
};

export const shallowEquals = (a: unknown, b: unknown) => {  
  if (Object.is(a, b)) return true;  
  if (!isObject(a) || !isObject(b)) return false;  
  if (isArray(a) !== isArray(b)) return false;  
  if (isArray(a) && isArray(b)) return compareArrays(a, b);  
  return compareObjects(a, b);  
};  

// ... 헬퍼함수들

type Condition<T> = (param: T) => boolean;  
type Handler<T, R> = (param: T) => R;  
type ConditionHandlerPair<T, R> = [condition: Condition<T>, handler: Handler<T, R>];

// dispatchWithCondition 함수 추가구현  
export function dispatchWithCondition<T, R>(...args: [...ConditionHandlerPair<T, R>[], Handler<T, R>]) {  
	const pairs = args.slice(0, -1) as ConditionHandlerPair<T, R>[];  
	const defaultHandler = args[args.length - 1] as Handler<T, R>;

	return (param: T) => {  
		for (const [condition, handler] of pairs) {  
			if (condition(param)) {  
				return handler(param);  
			}  
		}

		return defaultHandler(param);  
	};  
}

export const shallowEquals = (a: unknown, b: unknown) => {  
	return dispatchWithCondition<[typeof a, typeof b], boolean>(  
		// 두 값이 정확히 같은지 확인 (참조가 같은 경우)  
		[([a, b]) => Object.is(a, b), () => true],  
		// 둘 다 객체가 아니면 false  
		[([a, b]) => !isObject(a) || !isObject(b), () => false],  
		// 서로 다른 타입을 받을 경우 false  
		[([a, b]) => isArray(a) !== isArray(b), () => false],  
		// 둘 다 배열이면 배열 비교  
		[([a, b]) => isArray(a) && isArray(b), ([a, b]) => compareArrays(a as unknown[], b as unknown[])],  
		// 둘 다 객체면 객체 비교  
		([a, b]) => compareObjects(a as object, b as object)  
	)([a, b]);  
};  

export function useRef<T>(initialValue: T) {  
	const [refObject] = useState<RefObject<T>>(() => ({ current: initialValue }));  
	return refObject;  
}  

export function useMemo<T>(factory: () => T, _deps: DependencyList, _equals = shallowEquals) {  
	// useRef로 메모이제이션 상태 저장  
	const memoRef = useRef<MemoRef<T> | null>(null);

	// 의존성 배열이 없거나, 이전과 다르면 새로 계산  
	if (!memoRef.current || !_equals(memoRef.current.deps, _deps)) {  
		const value = factory();  
		memoRef.current = { deps: _deps, value };  
	}

	return memoRef.current.value;  
}

export function useCallback<T extends AnyFunction>(factory: T, _deps: DependencyList) {  
	return useMemo(() => factory, _deps);  
}  

export const useShallowState = <T>(initialValue: T): [T, Dispatch<SetStateAction<T>>] => {  
	const [value, setValue] = useState<T>(initialValue);

	const setShallow = useCallback((newValue: SetStateAction<T>) => {  
		setValue((prev) => {  
			const nextValue = typeof newValue === "function" ? (newValue as (prevValue: T) => T)(prev) : newValue;  
			return shallowEquals(prev, nextValue) ? prev : nextValue;  
		});  
	}, []);

	return [value, setShallow];  
};  

export const useAutoCallback = <T extends AnyFunction>(fn: T) => {  
	const fnRef = useRef(fn);  
	fnRef.current = fn; // 매 렌더링마다 최신 함수로 업데이트

	const autoCallback = useCallback((...args: Parameters<T>) => {  
		return fnRef.current(...args);  
	}, []);

	return autoCallback;  
};  

export const createStore = <S, A>(reducer: (state: S, action: A) => S, initialState: S) => {  
	const { subscribe, notify } = createObserver();  
	let state = initialState;

	const getState = () => state;  
	const dispatch = (action: A) => {  
		const newState = reducer(state, action);  
		if (!Object.is(newState, state)) {  
			state = newState;  
			notify();  
		}  
	};

	return { getState, dispatch, subscribe };  
};

export const useStore = <T, S = T>(store: Store<T>, selector = defaultSelector<T, S>) => {  
	const shallowSelector = useShallowSelector(selector);  
	const getSnapshot = () => shallowSelector(store.getState());  
	return useSyncExternalStore(store.subscribe, getSnapshot);  
};