import * as optionsConfig from '../assets/data/options';
import { logFieldLabels } from '../assets/data/data';

export const convertKTC = (dt, nation = true) => {
	if (!dt) return "";
	if (typeof dt !== "string") return "";

	const date = new Date(dt.endsWith("Z") ? dt : `${dt}Z`);
	const options = {
		year: 'numeric',
		month: '2-digit',
		day: '2-digit',
		hour: '2-digit',
		minute: '2-digit',
		hour12: true, // 오전/오후 형식을 위해 true 설정
		timeZone: 'Asia/Seoul',
	};

	return nation ? date.toLocaleString('ko-KR', options) + " KST" : date.toLocaleString('ko-KR', options);
}

export const convertKTCDate = (dt) => {
	const date = new Date(dt);
	date.setHours(date.getHours() + 9);
	return date;
}

export const convertUTC = (dt) => {
	if (!dt) return null;
	const date = new Date(dt);
	return new Date(date.setHours(date.getHours() - 9));
}

export const combineDateTime = (date, hour, min) => {
	if (!date) return null;
	return new Date(date.getFullYear(), date.getMonth(), date.getDate(), hour, min);
};

export const timeDiffMinute = (mainDt, subDt) => {
	const main_data = new Date(mainDt);
	const sub_data = new Date(subDt);
	return (main_data.getTime() - sub_data.getTime()) / 1000 / 60
}

export const formatStringDate = (date) => {
	const year = date.getFullYear();
	const month = String(date.getMonth() + 1).padStart(2, '0');
	const day = String(date.getDate()).padStart(2, '0');

	return `${year}-${month}-${day}`;
}

export const truncateText = (text) => {
	const maxLength = 30;
	if (text.length > maxLength) {
		return text.substring(0, maxLength) + '...';
	}
	return text;
};

export const getOptionsArray = (optionsKey) => {
	if (typeof optionsKey === 'string') {
		return optionsConfig[optionsKey] || [];
	}
	return optionsKey || [];
};

export const loadConfig = async (configPath) => {
	try {
		// 동적 import
		const module = await import(`../assets/data/pages/${configPath}.json`);
		return module.default;
	} catch (error) {
		console.error(`Failed to load search configuration: ${configPath}`, error);
		throw error;
	}
};

export const getFieldLabel = (key, value) => {
	if (logFieldLabels[key]) {
		return logFieldLabels[key];
	}

	if (typeof value === 'string' && logFieldLabels[value]) {
		return logFieldLabels[value];
	}

	return key;
};

export const numberFormatter = {
	formatCurrency: (number, decimals = 2) => {
		if (number === null || number === undefined) return '0';

		try {
			const num = typeof number === 'string' ? parseFloat(number) : number;
			if (isNaN(num)) return '0';

			// 정수인지 확인
			const isInteger = Number.isInteger(num);

			// 작은 수이거나 소수점이 있는 경우
			if ((Math.abs(num) < 1 && num !== 0) || !isInteger) {
				return num.toFixed(decimals);
			}

			// 정수인 경우
			return new Intl.NumberFormat('ko-KR', {
				minimumFractionDigits: 0,
				maximumFractionDigits: 0
			}).format(num);

		} catch (e) {
			console.error('Currency formatting error:', e);
			return '0';
		}
	},
	formatPercent: (number, decimals = 2) => {
		if (number === null || number === undefined) return '0%';

		try {
			const num = typeof number === 'string' ? parseFloat(number) : number;
			if (isNaN(num)) return '0%';

			const valueToFormat = num / 100;

			return new Intl.NumberFormat('ko-KR', {
				style: 'percent',
				minimumFractionDigits: 0,
				maximumFractionDigits: decimals
			}).format(valueToFormat);

		} catch (e) {
			console.error('Currency formatting error:', e);
			return '0%';
		}
	},
	formatSecondToMinuts: (seconds) => {
		if (seconds === null || seconds === undefined) return '0:00';

		try {
			const num = typeof seconds === 'string' ? parseFloat(seconds) : seconds;
			if (isNaN(num)) return '0:00';

			// 총 초를 분과 초로 변환
			const minutes = Math.floor(num / 60);
			const remainingSeconds = Math.floor(num % 60);

			// 초가 10보다 작으면 앞에 0을 붙여 두 자리로 표시
			const formattedSeconds = remainingSeconds < 10 ? `0${remainingSeconds}` : remainingSeconds;

			return `${minutes}:${formattedSeconds}`;
		} catch (e) {
			console.error('Seconds to minutes formatting error:', e);
			return '0:00';
		}
	}


};

/**
 * API 응답으로부터 파일 다운로드를 처리하는 함수
 * @param {Object} response - API 응답 객체
 * @param {Object} response.data - 응답 데이터
 * @param {Object} response.headers - 응답 헤더
 * @param {Object} options - 추가 옵션
 * @param {string} options.defaultFileName - 기본 파일명 (기본값: 'download')
 * @returns {void}
 * @throws {Error} 데이터가 없거나 파일 형식이 잘못된 경우
 */
export const responseFileDownload = (response, options = {}) => {
	const { defaultFileName = 'download' } = options;

	if (!response.data) {
		console.log(response);
		throw new Error('No data received');
	}

	const contentType = response.headers['content-type'] || response.headers['Content-Type'];
	const contentDisposition = response.headers['content-disposition'] || response.headers['Content-Disposition'];

	// Excel, CSV, ZIP 파일 형식 검증 (CSV 추가)
	const isValidType = contentType && (
		contentType.includes('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') ||
		contentType.includes('text/csv') ||
		contentType.includes('application/zip')
	);

	if (!isValidType) {
		console.log('Invalid content type:', contentType);
		console.log('Full response:', response);
		throw new Error(`잘못된 파일 형식입니다. Content-Type: ${contentType}`);
	}

	let fileName = defaultFileName;
	let fileExtension = '.csv';
	let mimeType = 'text/csv; charset=UTF-8';

	// 파일 타입별 처리
	if (contentType.includes('text/csv')) {
		// CSV 파일 처리
		fileExtension = '.csv';
		mimeType = 'text/csv; charset=UTF-8';
		fileName = `${defaultFileName}`;
	} else if (contentType.includes('application/zip')) {
		// ZIP 파일 처리
		fileExtension = '.zip';
		mimeType = 'application/zip';
		fileName = `${defaultFileName}_multiple_files`;
	}

	// Content-Disposition에서 파일명 추출
	if (contentDisposition) {
		const fileNameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
		if (fileNameMatch && fileNameMatch[1]) {
			let extractedFileName = fileNameMatch[1].replace(/['"]/g, '');
			try {
				fileName = decodeURIComponent(extractedFileName);
			} catch (e) {
				// decodeURIComponent 실패 시 원본 사용
				fileName = extractedFileName;
			}
		}
	} else {
		fileName = fileName + fileExtension;
	}

	const blob = new Blob([response.data], { type: mimeType });

	// 파일 유효성 검사 (CSV는 더 작을 수 있으므로 조건 완화)
	if (blob.size === 0) {
		throw new Error('다운로드된 파일이 비어있습니다.');
	}

	// CSV 파일은 크기 검사 완화
	const minSize = contentType.includes('text/csv') ? 100 : 1024;
	if (blob.size < minSize) {
		throw new Error(`파일 크기가 너무 작습니다. 올바른 파일이 아닐 수 있습니다. (${blob.size} bytes)`);
	}

	// 파일 다운로드 실행
	const href = URL.createObjectURL(blob);
	const link = document.createElement('a');
	link.href = href;
	link.download = fileName;
	link.style.display = 'none';
	link.rel = 'noopener noreferrer';
	document.body.appendChild(link);
	link.click();

	// 정리
	link.remove();
	window.URL.revokeObjectURL(href);
};

export const calculateTotals = (data) => {
	return data?.reduce((acc, row) => {
		Object.entries(row).forEach(([key, value]) => {
			if (!isNaN(value) && value !== '') {
				acc[key] = (acc[key] || 0) + Number(value);
			}
		});
		return acc;
	}, {}) || {};
};