bitforum-frontend/lib/utils/client.ts

'use client';

import { clsx, type ClassValue } from 'clsx';
import { twMerge } from 'tailwind-merge';
import { TokenData, ResultDto } from '@/dtos/response/common';
import { CLAIM_NAME_IDENTIFIER, CLAIM_EMAIL, CLAIM_NAME } from '@/constants/common';
import useAuth from '@/hooks/useAuth';

export function cn(...inputs: ClassValue[]) {
	return twMerge(clsx(inputs))
}

// JWT 토큰에서 사용자 정보 추출
export function decodeAccessToken(token: string): TokenData|null {
	try {

		const base64URL = token.split('.')[1]; // JWT의 Payload 부분
        const base64 = base64URL.replace(/-/g, '+').replace(/_/g, '/'); // Base64 형식 변환
        const jsonPayload = decodeURIComponent(
			atob(base64).split('').map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)).join('')
        );

        const payload = JSON.parse(jsonPayload);

		return {
			id: payload[CLAIM_NAME_IDENTIFIER] || null,
			email: payload[CLAIM_EMAIL] || null,
			name: payload[CLAIM_NAME] || null
		};

	} catch {
 		return null;
	}
}

export function formatDate(dateString: string|null): string {
    if (!dateString) {
        return '-';
    }

    const date = new Date(dateString);
    const now  = new Date();

    // 두 자리 숫자 포맷 함수
    const pad = (n: number) => n.toString().padStart(2, '0');

    // 오늘인지 검사
    const isToday =
        date.getFullYear() === now.getFullYear() &&
        date.getMonth()    === now.getMonth() &&
        date.getDate()     === now.getDate();

    if (isToday) {
        // 오늘이면 'HH:mm'
        const hh = pad(date.getHours());
        const mm = pad(date.getMinutes());
        return `${hh}:${mm}`;
    } else {
        // 오늘이 아니면 'YYYY.MM.DD'
        const yyyy = date.getFullYear();
        const mo   = pad(date.getMonth() + 1);
        const dd   = pad(date.getDate());
        return `${yyyy}.${mo}.${dd}`;
    }
}

// 2025.01.01. 12:00:00 으로 조회
export function getDateTime(dateString: string|null) {
    if (!dateString) {
		return '-';
	}

    const date = new Date(dateString);

    return date.toLocaleString('ko-KR', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        second: '2-digit',
        hour12: false
    }).replace(/\. /g, '.');
}

// 파일 이름 생성
export function getDateFilename(prefix: string): string {
	if (!prefix) {
		return '';
	}

    const now = new Date();
    const yyyy = now.getFullYear();
    const MM = String(now.getMonth() + 1).padStart(2, '0');
    const dd = String(now.getDate()).padStart(2, '0');
    const hh = String(now.getHours()).padStart(2, '0');
    const mm = String(now.getMinutes()).padStart(2, '0');
    const ss = String(now.getSeconds()).padStart(2, '0');

    return `${prefix}-${yyyy}${MM}${dd}${hh}${mm}${ss}.png`;
}

// HTML 태그 제거
export function stripHtmlTags(str?: string|null): string {
	if (!str) {
		return '';
	}

	const div = document.createElement('div');
	div.innerHTML = str;
	return div.textContent || div.innerText || '';
}

// 비밀번호 정책 안내 문구 생성성
export function getPasswordPolicyMessage(policy: {
	passwordUppercaseLength: number;
	passwordNumbersLength: number;
	passwordSpecialcharsLength: number;
}) {
	const parts: string[] = [];

	if (policy.passwordUppercaseLength > 0) {
		parts.push(`영문 대문자 ${policy.passwordUppercaseLength}자 이상`);
	}

	if (policy.passwordNumbersLength > 0) {
		parts.push(`숫자 ${policy.passwordNumbersLength}자 이상`);
	}

	if (policy.passwordSpecialcharsLength > 0) {
		parts.push(`특수문자 ${policy.passwordSpecialcharsLength}자 이상`);
	}

	if (parts.length > 0) {
		return `비밀번호는 ${parts.join(', ')}를 포함해야 합니다.`;
	}

	return '';
}

// 특수문자 제거
export function filterSpecialCharacters(str: string) {
	return str.replace(/[^\p{L}\p{N}\s]/gu, '');
}

// ResultDto에서 첫 번째 오류 조회
export function getError(errors: Record<string, string[]>|null|undefined, index = 0): string|undefined {
    if (!errors) {
		return undefined;
	}

    const keys = Object.keys(errors);
    if (keys.length > 0) {
        const key = keys[index];
        return errors[key]?.[0];
    }

    return undefined;
}

// 서버 응답 메시지 분석
export function throwError<T>(res: ResultDto<T>): void {
	if (res.ok) {
		return;
	}

	let message:string|null|undefined = getError(res.errors);

	if (!message && !res.message) {
		switch (res.status) {
			case 400:
				message = '잘못된 요청입니다.';
				break;
			case 401:
				message = '로그인 후 이용해 주세요.';
				location.replace('/login');
				break;
			case 403:
				message = '권한이 없습니다.';
				break;
			case 404:
				message = '요청하신 페이지를 찾을 수 없습니다.';
				break;
			case 500:
				message = '서버 오류가 발생했습니다. 다시 시도해 주세요.';
				break;
		}

		if ([400, 403, 404, 500].includes(res.status)) {
			location.replace('/');
		}

	} else if(!message || message == '') {
		message = res.message;
	}

	if (message) {
		throw new Error(message);
	}
}

// 1000회 이상 조회된 게시글인지 확인
export function isHotPost(showHotIcon: boolean, post: { views: number; createdAt: string }): boolean {
    return (showHotIcon && post.views >= 1000 && Date.now() - new Date(post.createdAt).getTime() < 7 * 24 * 60 * 60 * 1000);
}

// 24시간 이내에 작성된 게시글인지 확인
export function isNewPost(showNewIcon: boolean, post: { createdAt: string }): boolean {
    return (showNewIcon && Date.now() - new Date(post.createdAt).getTime() < 24 * 60 * 60 * 1000);
}

// a 태그에 target="_blank" 추가
export function forceTargetBlank(html: string) {
    return html.replace(/<a\s+(?![^>]*target=)([^>]*href=["'][^"']+["'])/gi, '<a target="_blank" rel="noopener noreferrer" $1');
};

// 날짜가 현재 날짜보다 지났는지 확인
export function isDateOverdue(dateString: string|null, days = 0): boolean {
	if (!dateString) {
		return false;
	}

    const limitDate = new Date(new Date(dateString));
    limitDate.setDate(limitDate.getDate() + days);

    const now = new Date();

	return now > limitDate;
}

// 로그인 페이지로 이동 시키기
export function loginCheck() {
	const { isAuthenticated } = useAuth();

	return () => {
		if (!isAuthenticated) {
			if (confirm("로그인 후 이용 가능합니다.")) {
				window.location.href = `/login?returnUrl=${encodeURIComponent(window.location.pathname + window.location.search)}`;
			}
			return false;
		}
		return true;
	};
}