import { useCallback, useEffect, useState } from 'react';
import { loadConfig } from '../utils';
import * as APIs from '../apis';
import { useAlert } from '../context/AlertProvider';
import { alertTypes } from '../assets/data/types';

export const useCommonSearchOld = (configPath) => {
	const [config, setConfig] = useState(null);
	const [searchParams, setSearchParams] = useState({});
	const [loading, setLoading] = useState(false);
	const [data, setData] = useState(null);
	const [configLoaded, setConfigLoaded] = useState(false);
	const { showToast } = useAlert();
	const token = sessionStorage.getItem('token');

	// 설정 파일 로드
	useEffect(() => {
		const fetchConfig = async () => {
			try {
				const configData = await loadConfig(configPath);
				setConfig(configData);

				// 초기 검색 파라미터 설정
				if (configData.initialSearchParams) {
					setSearchParams(configData.initialSearchParams);
				}

				setConfigLoaded(true);
			} catch (error) {
				console.error('Error loading search configuration:', error);
			}
		};

		fetchConfig();
	}, [configPath]);

	// 파라미터 값 변환 (날짜 등)
	const transformParam = (param, value) => {
		if (typeof param === 'object' && param.transform) {
			if (param.transform === 'toISOString' && value) {
				return new Date(value).toISOString();
			}
		}
		return value;
	};

	// API 호출에 필요한 파라미터 준비
	const prepareApiParams = useCallback((params) => {
		if (!config || !config.apiInfo || !config.apiInfo.paramsMapping) {
			return [token, params];
		}

		// 파라미터 배열 매핑
		return config.apiInfo.paramsMapping.map(param => {
			if (param === 'token') return token;

			if (typeof param === 'object') {
				return transformParam(param, params[param.param]);
			}

			return params[param];
		});
	}, [token, config]);

	// 데이터 가져오기
	const fetchData = useCallback(async (params) => {
		if (!token || !config || !config.apiInfo || !config.apiInfo.functionName) return;

		try {
			setLoading(true);
			const apiParams = prepareApiParams(params);

			// API 호출
			const functionName = config.apiInfo.functionName;
			if (!APIs[functionName]) {
				console.error(`API function ${functionName} not found!`);
				return;
			}

			const result = await APIs[functionName](token, ...apiParams);

			// 에러 처리
			if (result.result && result.result.startsWith('ERROR_')) {
				showToast('SEARCH_FAIL',{type: alertTypes.error})
			}

			setData(result.data || result);
			return result.data || result;
		} catch (error) {
			console.error(`Error fetching data:`, error);
			throw error;
		} finally {
			setLoading(false);
		}
	}, [token, config, prepareApiParams]);

	// 초기 데이터 로드
	useEffect(() => {
		if (configLoaded && config && searchParams && config.apiInfo?.loadOnMount) {
			fetchData(searchParams);
		}
	}, [configLoaded, config, searchParams, fetchData]);

	// 검색 파라미터 업데이트
	const updateSearchParams = useCallback((newParams) => {
		setSearchParams(prev => ({
			...prev,
			...newParams
		}));
	}, []);

	// 검색 처리
	const handleSearch = useCallback(async (newParams = {}, executeSearch = true) => {
		if (!config) return null;

		const pageField = config.apiInfo?.pageField || 'currentPage';

		const updatedParams = {
			...searchParams,
			...newParams,
			[pageField]: newParams[pageField] || 1 // 새 검색 시 첫 페이지로 리셋
		};

		updateSearchParams(updatedParams);

		if (executeSearch) {
			return await fetchData(updatedParams);
		}
		return null;
	}, [searchParams, fetchData, config, updateSearchParams]);

	// 검색 초기화
	const handleReset = useCallback(async () => {
		if (!config || !config.initialSearchParams) return null;

		setSearchParams(config.initialSearchParams);
		return await fetchData(config.initialSearchParams);
	}, [config, fetchData]);

	// 페이지 변경
	const handlePageChange = useCallback(async (newPage) => {
		if (!config) return null;

		const pageField = config.apiInfo?.pageField || 'currentPage';
		return await handleSearch({ [pageField]: newPage }, true);
	}, [handleSearch, config]);

	// 페이지 크기 변경
	const handlePageSizeChange = useCallback(async (newSize) => {
		if (!config) return null;

		const pageField = config.apiInfo?.pageField || 'currentPage';
		const pageSizeField = config.apiInfo?.pageSizeField || 'pageSize';
		return await handleSearch({
			[pageSizeField]: newSize,
			[pageField]: 1
		}, true);
	}, [handleSearch, config]);

	// 정렬 방식 변경
	const handleOrderByChange = useCallback(async (newOrder) => {
		if (!config) return null;

		const orderField = config.apiInfo?.orderField || 'orderBy';
		return await handleSearch({ [orderField]: newOrder }, true);
	}, [handleSearch, config]);

	return {
		config,
		searchParams,
		loading,
		data,
		handleSearch,
		handleReset,
		handlePageChange,
		handlePageSizeChange,
		handleOrderByChange,
		updateSearchParams,
		configLoaded
	};
};

export default useCommonSearchOld;