파일 업로드 리팩토링기 #4. 에러가 나도 파일이 남는 훅

export function useFileStaging(
  options: FileManagerOptions = {}
): FileManagerReturn {
  const {
    permission = 'manager',
    maxFiles,
    maxFileSize,
    accept,
    concurrency = 3,
    confirmDir,
    initialFiles,
    contentValidation,
    onAllUploaded,
    onValidationError,
    onConfirmSuccess,
  } = options;

  const contentValidator = buildContentValidator(contentValidation);
  const [state, dispatch] = useReducer(fileManagerReducer, INITIAL_STATE);
  const [confirmError, setConfirmError] = useState<ConfirmErrorCode | null>(
    null
  );
  const stateRef = useRef(state);
  stateRef.current = state;
  const activeUploadsRef = useRef(0);
  const abortControllersRef = useRef<Map<string, AbortController>>(new Map());

  // ── Upload mutation ──────────────────────────────────
  const fileUpload = useFileUpload(permission, {
    onUploadError: (fileId, error) => {
      activeUploadsRef.current--;
      abortControllersRef.current.delete(fileId);
      dispatch({
        payload: {
          error: {
            isRetryable: isRetryableError(error),
            message: error.message,
          },
          id: fileId,
        },
        type: 'UPLOAD_ERROR',
      });
      processQueue();
    },
    onUploadProgress: (fileId, progress) => {
      dispatch({ payload: { id: fileId, progress }, type: 'UPDATE_PROGRESS' });
    },
    onUploadSuccess: (fileId, response) => {
      activeUploadsRef.current--;
      abortControllersRef.current.delete(fileId);
      dispatch({ payload: { id: fileId, response }, type: 'UPLOAD_COMPLETED' });
      processQueue();
    },
  });

  // ── Confirm mutation ─────────────────────────────────
  const { confirmFiles: confirmMutation, isConfirming } = useFileConfirm({
    onSuccess: data => {
      const completedIds = Array.from(state.files.values())
        .filter(f => f.status === FileStatus.COMPLETED)
        .map(f => f.id);
      dispatch({ payload: completedIds, type: 'SET_CONFIRMED' });
      onConfirmSuccess?.(data);
    },
  });

  // ── Queue processor ──────────────────────────────────
  const processQueue = useCallback(() => {
    const { queue, files } = stateRef.current;
    const toProcess: string[] = [];
    let idx = 0;

    while (
      activeUploadsRef.current + toProcess.length < concurrency &&
      idx < queue.length
    ) {
      const fileId = queue[idx];
      const file = fileId ? files.get(fileId) : undefined;
      if (file?.rawFile && file.status === FileStatus.QUEUED) {
        toProcess.push(fileId);
      }
      idx++;
    }
    if (toProcess.length === 0) return;

    dispatch({ payload: toProcess, type: 'DEQUEUE' });

    for (const fileId of toProcess) {
      const file = files.get(fileId);
      if (!file?.rawFile) continue;
      const controller = new AbortController();
      abortControllersRef.current.set(fileId, controller);
      activeUploadsRef.current++;
      fileUpload.uploadFile({
        file: file.rawFile,
        fileId,
        signal: controller.signal,
      });
    }
  }, [concurrency, fileUpload.uploadFile]);

  // ── Public API ───────────────────────────────────────
  const addFiles = useCallback(
    (fileList: FileList) => {
      if (!fileList.length) return;
      setConfirmError(null);

      const incoming = Array.from(fileList);
      if (maxFiles && state.files.size + incoming.length > maxFiles) {
        toast.info(`최대 ${maxFiles}개만 선택 가능합니다.`);
        return;
      }

      const existingFiles = Array.from(state.files.values());
      const newFiles: ManagedFile[] = [];

      for (const file of incoming) {
        // 중복 체크
        if (
          existingFiles.some(
            ef => ef.fileName === file.name && ef.fileSize === file.size
          )
        ) {
          toast.info(`이미 추가된 파일입니다: ${file.name}`);
          continue;
        }
        // 동기 검증 (크기, 확장자)
        const error = validateFile(file);
        if (error) {
          toast.error(`${file.name}: ${error}`);
          continue;
        }

        newFiles.push({
          contentType: file.type || undefined,
          directory: '',
          fileName: file.name,
          fileSize: file.size,
          fullPath: '',
          id: uuidv4(),
          progress: 0,
          rawFile: file,
          status: FileStatus.QUEUED,
        });
      }
      if (newFiles.length === 0) return;

      // 비동기 콘텐츠 검증 (5편)
      if (contentValidator) {
        Promise.all(
          newFiles.map(async mf => {
            if (!mf.rawFile) return mf;
            const result = await contentValidator(mf.rawFile);
            if (!result.valid) {
              toast.error(
                `${mf.fileName}: ${result.reason ?? '유효하지 않은 파일입니다.'}`
              );
              return null;
            }
            return mf;
          })
        ).then(results => {
          const valid = results.filter((r): r is ManagedFile => r !== null);
          if (valid.length > 0) {
            dispatch({ payload: valid, type: 'ADD_FILES' });
            queueMicrotask(processQueue);
          }
        });
      } else {
        dispatch({ payload: newFiles, type: 'ADD_FILES' });
        queueMicrotask(processQueue);
      }
    },
    [
      state.files,
      maxFiles,
      maxFileSize,
      accept,
      contentValidation,
      processQueue,
    ]
  );

  const removeFile = useCallback((fileId: string) => {
    const controller = abortControllersRef.current.get(fileId);
    if (controller) {
      controller.abort();
      abortControllersRef.current.delete(fileId);
      activeUploadsRef.current = Math.max(0, activeUploadsRef.current - 1);
    }
    dispatch({ payload: fileId, type: 'REMOVE_FILE' });
  }, []);

  const retryFile = useCallback(
    (fileId: string) => {
      dispatch({ payload: fileId, type: 'RETRY_FILE' });
      queueMicrotask(processQueue);
    },
    [processQueue]
  );

  const cancelUpload = useCallback(
    (fileId: string) => removeFile(fileId),
    [removeFile]
  );

  const confirmFilesHandler = useCallback(async () => {
    const allFiles = Array.from(state.files.values());
    if (allFiles.length === 0) {
      setConfirmError('NO_FILES');
      return Promise.reject(new Error('NO_FILES'));
    }
    if (
      allFiles.some(
        f => f.status === FileStatus.UPLOADING || f.status === FileStatus.QUEUED
      )
    ) {
      setConfirmError('HAS_UPLOADING');
      return Promise.reject(new Error('HAS_UPLOADING'));
    }
    const completedFiles = allFiles.filter(
      f => f.status === FileStatus.COMPLETED
    );
    if (completedFiles.length === 0) {
      setConfirmError('NO_FILES');
      return Promise.reject(new Error('NO_FILES'));
    }

    setConfirmError(null);
    try {
      return await confirmMutation({
        files: completedFiles.map(toFileDetail),
        to_dir: confirmDir!,
      });
    } catch (error) {
      setConfirmError('CONFIRM_FAILED');
      throw error;
    }
  }, [state.files, confirmDir, confirmMutation]);

  // ── Return ───────────────────────────────────────────
  const filesArray = useMemo(
    () => Array.from(state.files.values()),
    [state.files]
  );
  return {
    addFiles,
    cancelUpload,
    clearFiles,
    confirmError,
    confirmFiles: confirmFilesHandler,
    files: filesArray,
    hasErrorFiles: filesArray.some(f => f.status === FileStatus.ERROR),
    hasUploadingFiles: filesArray.some(
      f => f.status === FileStatus.UPLOADING || f.status === FileStatus.QUEUED
    ),
    isAllUploaded:
      filesArray.length > 0 &&
      filesArray.every(f => f.status === FileStatus.COMPLETED),
    isConfirming,
    removeFile,
    retryFile,
    totalProgress:
      filesArray.length > 0
        ? Math.round(
            filesArray.reduce((sum, f) => sum + f.progress, 0) /
              filesArray.length
          )
        : 0,
  };
}

interface FileManagerState {
  files: Map<string, ManagedFile>;
  queue: string[];
}

type FileManagerAction =
  | { type: 'ADD_FILES'; payload: ManagedFile[] }
  | { type: 'REMOVE_FILE'; payload: string }
  | { type: 'CLEAR_FILES' }
  | { type: 'UPDATE_PROGRESS'; payload: { id: string; progress: number } }
  | { type: 'UPLOAD_STARTED'; payload: string }
  | {
      type: 'UPLOAD_COMPLETED';
      payload: { id: string; response: FileUploadRs };
    }
  | {
      type: 'UPLOAD_ERROR';
      payload: { id: string; error: { message: string; isRetryable: boolean } };
    }
  | { type: 'RETRY_FILE'; payload: string }
  | { type: 'SET_CONFIRMED'; payload: string[] }
  | { type: 'DEQUEUE'; payload: string[] };

function updateFile(
  files: Map<string, ManagedFile>,
  id: string,
  update: Partial<ManagedFile>
): Map<string, ManagedFile> {
  const existing = files.get(id);
  if (!existing) return files;
  const next = new Map(files);
  next.set(id, { ...existing, ...update });
  return next;
}

export function fileManagerReducer(
  state: FileManagerState,
  action: FileManagerAction
): FileManagerState {
  switch (action.type) {
    case 'ADD_FILES': {
      const next = new Map(state.files);
      const newQueue = [...state.queue];
      for (const file of action.payload) {
        next.set(file.id, file);
        if (file.status === FileStatus.QUEUED) {
          newQueue.push(file.id);
        }
      }
      return { files: next, queue: newQueue };
    }
    case 'REMOVE_FILE': {
      const next = new Map(state.files);
      next.delete(action.payload);
      return {
        files: next,
        queue: state.queue.filter(id => id !== action.payload),
      };
    }
    case 'UPDATE_PROGRESS':
      return {
        ...state,
        files: updateFile(state.files, action.payload.id, {
          progress: action.payload.progress,
        }),
      };
    case 'UPLOAD_STARTED':
      return {
        ...state,
        files: updateFile(state.files, action.payload, {
          status: FileStatus.UPLOADING,
        }),
      };
    case 'UPLOAD_COMPLETED': {
      const partial = fromUploadResponse(action.payload.response);
      return {
        ...state,
        files: updateFile(state.files, action.payload.id, {
          ...partial,
          progress: 100,
          rawFile: undefined,
          status: FileStatus.COMPLETED,
        }),
      };
    }
    case 'UPLOAD_ERROR':
      return {
        ...state,
        files: updateFile(state.files, action.payload.id, {
          error: action.payload.error,
          status: FileStatus.ERROR,
        }),
      };
    case 'RETRY_FILE': {
      const file = state.files.get(action.payload);
      if (!file || file.status !== FileStatus.ERROR || !file.rawFile)
        return state;
      return {
        files: updateFile(state.files, action.payload, {
          error: undefined,
          progress: 0,
          status: FileStatus.QUEUED,
        }),
        queue: [...state.queue, action.payload],
      };
    }
    case 'SET_CONFIRMED': {
      let next = state.files;
      for (const id of action.payload) {
        next = updateFile(next, id, { status: FileStatus.CONFIRMED });
      }
      return { ...state, files: next };
    }
    case 'DEQUEUE':
      return {
        ...state,
        queue: state.queue.filter(id => !action.payload.includes(id)),
      };
    default:
      return state;
  }
}