/**
 * 동적 폼 상태 관리 훅
 *
 * - 필드 값 관리
 * - 밸리데이션
 * - 에러 관리
 * - 폼 제출
 */

'use client';

import { useState, useCallback } from 'react';
import type {
  DynamicFormData,
  DynamicFormErrors,
  DynamicFieldValue,
  UseDynamicFormStateResult,
} from '../types';
import type { ItemFieldResponse } from '@/types/item-master-api';

export function useDynamicFormState(
  _initialData?: DynamicFormData  // 사용하지 않음 - 호환성을 위해 파라미터 유지
): UseDynamicFormStateResult {
  // 2025-12-05: 항상 빈 객체로 시작
  // Edit 모드 데이터는 DynamicItemForm에서 resetForm()으로 설정
  // 이렇게 해야 StrictMode 리마운트에서도 안전함
  const [formData, setFormData] = useState<DynamicFormData>({});
  const [errors, setErrors] = useState<DynamicFormErrors>({});
  const [isSubmitting, setIsSubmitting] = useState(false);

  // 2025-12-05: initialData 동기화 useEffect 제거
  // 모든 초기 데이터는 resetForm()을 통해서만 설정
  // StrictMode에서 useState 초기값이 원본 데이터로 리셋되는 문제 해결

  // 필드 값 설정
  const setFieldValue = useCallback((fieldKey: string, value: DynamicFieldValue) => {
    setFormData((prev) => ({
      ...prev,
      [fieldKey]: value,
    }));
    // 값이 변경되면 해당 필드의 에러 제거
    setErrors((prev) => {
      const newErrors = { ...prev };
      delete newErrors[fieldKey];
      return newErrors;
    });
  }, []);

  // 에러 설정
  const setError = useCallback((fieldKey: string, error: string) => {
    setErrors((prev) => ({
      ...prev,
      [fieldKey]: error,
    }));
  }, []);

  // 에러 제거
  const clearError = useCallback((fieldKey: string) => {
    setErrors((prev) => {
      const newErrors = { ...prev };
      delete newErrors[fieldKey];
      return newErrors;
    });
  }, []);

  // 모든 에러 제거
  const clearAllErrors = useCallback(() => {
    setErrors({});
  }, []);

  // 단일 필드 밸리데이션
  const validateField = useCallback(
    (field: ItemFieldResponse, value: DynamicFieldValue): string | null => {
      const _fieldKey = field.field_key || `field_${field.id}`;

      // 필수 필드 체크
      if (field.is_required) {
        if (value === null || value === undefined || value === '') {
          return `${field.field_name}은(는) 필수 입력 항목입니다.`;
        }
      }

      // 값이 없으면 추가 검증 스킵
      if (value === null || value === undefined || value === '') {
        return null;
      }

      // validation_rules 적용
      const rules = field.validation_rules;
      if (rules) {
        // min 검증 (숫자)
        if (rules.min !== undefined && field.field_type === 'number') {
          const numValue = Number(value);
          if (numValue < rules.min) {
            return `${field.field_name}은(는) ${rules.min} 이상이어야 합니다.`;
          }
        }

        // max 검증 (숫자)
        if (rules.max !== undefined && field.field_type === 'number') {
          const numValue = Number(value);
          if (numValue > rules.max) {
            return `${field.field_name}은(는) ${rules.max} 이하여야 합니다.`;
          }
        }

        // minLength 검증 (문자열)
        if (rules.minLength !== undefined && typeof value === 'string') {
          if (value.length < rules.minLength) {
            return `${field.field_name}은(는) ${rules.minLength}자 이상이어야 합니다.`;
          }
        }

        // maxLength 검증 (문자열)
        if (rules.maxLength !== undefined && typeof value === 'string') {
          if (value.length > rules.maxLength) {
            return `${field.field_name}은(는) ${rules.maxLength}자 이하여야 합니다.`;
          }
        }

        // pattern 검증 (정규식)
        if (rules.pattern && typeof value === 'string') {
          const regex = new RegExp(rules.pattern);
          if (!regex.test(value)) {
            return rules.patternMessage || `${field.field_name}의 형식이 올바르지 않습니다.`;
          }
        }
      }

      return null;
    },
    []
  );

  // 전체 필드 밸리데이션
  const validateAll = useCallback(
    (fields: ItemFieldResponse[]): boolean => {
      const newErrors: DynamicFormErrors = {};
      let isValid = true;

      for (const field of fields) {
        const fieldKey = field.field_key || `field_${field.id}`;
        const value = formData[fieldKey];
        const error = validateField(field, value);

        if (error) {
          newErrors[fieldKey] = error;
          isValid = false;
        }
      }

      setErrors(newErrors);
      return isValid;
    },
    [formData, validateField]
  );

  // 폼 제출
  // 2025-12-04: 실패 시에만 버튼 다시 활성화 (로그인 방식)
  // 성공 시에는 페이지 이동하므로 버튼 비활성화 상태 유지
  const handleSubmit = useCallback(
    async (onSubmit: (data: DynamicFormData) => Promise<void>) => {
      setIsSubmitting(true);

      try {
        await onSubmit(formData);
        // 성공 시: setIsSubmitting(false)를 호출하지 않음
        // 페이지 이동하므로 버튼 비활성화 상태 유지 → 중복 클릭 방지
      } catch (err) {
        console.error('폼 제출 실패:', err);
        // 실패 시에만 버튼 다시 활성화 → 재시도 가능
        setIsSubmitting(false);
        throw err;
      }
    },
    [formData]
  );

  // 폼 초기화
  const resetForm = useCallback((newInitialData?: DynamicFormData) => {
    setFormData(newInitialData || {});
    setErrors({});
    setIsSubmitting(false);
  }, []);

  return {
    formData,
    errors,
    isSubmitting,
    setFieldValue,
    setError,
    clearError,
    clearAllErrors,
    validateField,
    validateAll,
    handleSubmit,
    resetForm,
  };
}
