Aislo/B03_FileInput/B03_FileInput_Api_Fetch.ts

/* B03 다중 파일 업로드 API 클라이언트 */

import { API_BASE_URL, API_TIMEOUT_MS } from "@config/config_frontend";

export interface UploadedFileResult {
  input_file_id: number;
  original_filename: string;
  file_type: string;
  relative_path: string;
  size_bytes: number;
  metadata: Record<string, unknown>;
}

export interface FileUploadResponse {
  status: string;
  project_id: string;
  files: UploadedFileResult[];
}

export interface ChunkSessionCreateResponse {
  status: string;
  project_id: string;
  upload_session_id: string;
  original_filename: string;
  file_size_bytes: number;
  chunk_size_bytes: number;
  total_chunks: number;
  completed_chunks: number;
  /** 같은 내용이 이미 올라와 있어 전송을 건너뛰어도 되는지. */
  already_uploaded?: boolean;
}

export interface ChunkUploadResponse {
  status: string;
  upload_session_id: string;
  chunk_index: number;
  completed_chunks: number;
  total_chunks: number;
  chunk_hash: string;
}

export interface UploadStatusResponse {
  status: string;
  upload_session_id: string;
  upload_status: string;
  original_filename: string;
  file_size_bytes: number;
  chunk_size_bytes: number;
  total_chunks: number;
  completed_chunks: number;
  completed_chunk_indexes: number[];
}

async function readJsonOrThrow<T>(response: Response): Promise<T> {
  const payload = (await response.json()) as T & { message?: string };
  if (!response.ok) {
    throw new Error(payload.message ?? `HTTP ${response.status}`);
  }
  return payload;
}

export async function uploadProjectFiles(
  projectId: string,
  files: readonly File[],
): Promise<FileUploadResponse> {
  const formData = new FormData();
  for (const file of files) formData.append("files", file, file.name);

  const controller = new AbortController();
  const timeoutId = window.setTimeout(() => controller.abort(), API_TIMEOUT_MS);
  try {
    const response = await fetch(
      `${API_BASE_URL}/projects/${projectId}/files`,
      {
        method: "POST",
        credentials: "include",
        body: formData,
        signal: controller.signal,
      },
    );
    return await readJsonOrThrow<FileUploadResponse>(response);
  } finally {
    window.clearTimeout(timeoutId);
  }
}

export async function createUploadSession(
  projectId: string,
  file: File,
  chunkSizeBytes: number,
  fingerprint?: string | null,
  completeUpload = false,
  lasFree = false,
): Promise<ChunkSessionCreateResponse> {
  const response = await fetch(
    `${API_BASE_URL}/projects/${projectId}/upload-sessions`,
    {
      method: "POST",
      credentials: "include",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        original_filename: file.name,
        size_bytes: file.size,
        chunk_size_bytes: chunkSizeBytes,
        fingerprint: fingerprint ?? null,
        complete_upload: completeUpload,
        las_free: lasFree,
      }),
    },
  );
  return await readJsonOrThrow<ChunkSessionCreateResponse>(response);
}

export async function uploadFileChunk(
  projectId: string,
  sessionId: string,
  chunkIndex: number,
  chunk: Blob,
): Promise<ChunkUploadResponse> {
  const formData = new FormData();
  formData.append("session_id", sessionId);
  formData.append("chunk_index", String(chunkIndex));
  formData.append("chunk_data", chunk, `${sessionId}-${chunkIndex}.chunk`);

  const response = await fetch(`${API_BASE_URL}/projects/${projectId}/chunks`, {
    method: "POST",
    credentials: "include",
    body: formData,
  });
  return await readJsonOrThrow<ChunkUploadResponse>(response);
}

export async function finalizeUploadSession(
  projectId: string,
  sessionId: string,
  totalChunks: number,
  completeUpload: boolean,
  fingerprint?: string | null,
  lasFree = false,
): Promise<FileUploadResponse> {
  const response = await fetch(
    `${API_BASE_URL}/projects/${projectId}/finalize`,
    {
      method: "POST",
      credentials: "include",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        session_id: sessionId,
        total_chunks: totalChunks,
        complete_upload: completeUpload,
        fingerprint: fingerprint ?? null,
        las_free: lasFree,
      }),
    },
  );
  return await readJsonOrThrow<FileUploadResponse>(response);
}

export async function fetchUploadStatus(
  projectId: string,
  sessionId: string,
): Promise<UploadStatusResponse> {
  const response = await fetch(
    `${API_BASE_URL}/projects/${projectId}/upload-status/${sessionId}`,
    {
      method: "GET",
      credentials: "include",
    },
  );
  return await readJsonOrThrow<UploadStatusResponse>(response);
}

export interface UploadOverviewFile {
  input_file_id: number;
  file_type: string;
  original_filename: string;
  file_size_mb: number;
  status: string;
  uploaded_at: string | null;
  /** 저장 경로 — PRJ 두 장(노선/지형)을 카드에 되돌릴 때 이것으로 가린다. */
  relative_path: string | null;
}

export interface UploadOverviewSession {
  upload_session_id: string;
  original_filename: string;
  file_size_bytes: number;
  total_chunks: number;
  completed_chunks: number;
  progress_percent: number;
  updated_at: string | null;
}

export interface UploadOverviewResponse {
  status: string;
  files: UploadOverviewFile[];
  pending_sessions: UploadOverviewSession[];
  required_complete: boolean;
  analysis_complete: boolean;
}

/** 재접속 시 업로드 현황(정본) — 완료 파일 목록 + 중단 세션 + 완료 여부. */
export async function fetchUploadOverview(
  projectId: string,
): Promise<UploadOverviewResponse> {
  const response = await fetch(
    `${API_BASE_URL}/projects/${projectId}/upload-overview`,
    {
      method: "GET",
      credentials: "include",
    },
  );
  return await readJsonOrThrow<UploadOverviewResponse>(response);
}

export interface WF1AnalysisStatus {
  project_id: string;
  status: "pending" | "in_progress" | "completed" | "failed";
  model_count: number;
  progress_percent: number;
  current_stage: string;
  message: string;
  error?: string;
}

export async function checkWF1AnalysisStatus(
  projectId: string,
): Promise<WF1AnalysisStatus> {
  const response = await fetch(
    `${API_BASE_URL}/projects/${projectId}/surface/status`,
    {
      method: "GET",
      credentials: "include",
    },
  );
  return await readJsonOrThrow<WF1AnalysisStatus>(response);
}