import api from "./client";
import type { HostPathResult } from "@/types";

export interface FileContent {
  path: string;
  content: string | null;
  size: number;
  binary: boolean;
  too_large: boolean;
}

function triggerDownload(blob: Blob, filename: string) {
  const url = URL.createObjectURL(blob);
  const a = document.createElement("a");
  a.href = url;
  a.download = filename;
  document.body.appendChild(a);
  a.click();
  a.remove();
  URL.revokeObjectURL(url);
}

const base = "/api/files";

export const filesApi = {
  list: (path: string, showHidden = false) =>
    api
      .get<HostPathResult>(`${base}/list`, { params: { path, show_hidden: showHidden } })
      .then((r) => r.data),

  read: (path: string) =>
    api.get<FileContent>(`${base}/read`, { params: { path } }).then((r) => r.data),

  write: (path: string, content: string) =>
    api.put<{ path: string; size: number }>(`${base}/write`, { path, content }).then((r) => r.data),

  mkdir: (path: string, name: string) =>
    api.post<{ path: string }>(`${base}/mkdir`, { path, name }).then((r) => r.data),

  touch: (path: string, name: string) =>
    api.post<{ path: string }>(`${base}/touch`, { path, name }).then((r) => r.data),

  rename: (path: string, newName: string) =>
    api.post<{ path: string }>(`${base}/rename`, { path, new_name: newName }).then((r) => r.data),

  remove: (path: string, recursive = false) =>
    api.delete(base, { params: { path, recursive } }).then((r) => r.data),

  copy: (src: string, destDir: string, overwrite = false) =>
    api
      .post<{ path: string }>(`${base}/copy`, { src, dest_dir: destDir, overwrite })
      .then((r) => r.data),

  move: (src: string, destDir: string, overwrite = false) =>
    api
      .post<{ path: string }>(`${base}/move`, { src, dest_dir: destDir, overwrite })
      .then((r) => r.data),

  download: async (
    path: string,
    filename: string,
    onProgress?: (loaded: number, total: number | undefined) => void,
  ) => {
    const res = await api.get(`${base}/download`, {
      params: { path },
      responseType: "blob",
      onDownloadProgress: onProgress
        ? (e) => onProgress(e.loaded, e.total || undefined)
        : undefined,
    });
    triggerDownload(res.data as Blob, filename);
  },

  upload: async (
    path: string,
    file: File,
    overwrite = false,
    relPath = "",
    onProgress?: (pct: number) => void,
  ) => {
    const form = new FormData();
    form.append("path", path);
    form.append("overwrite", String(overwrite));
    if (relPath) form.append("rel_path", relPath);
    form.append("file", file);
    const res = await api.post<{ ok: boolean; name: string }>(`${base}/upload`, form, {
      onUploadProgress: onProgress
        ? (e) => {
            const pct = e.total ? (e.loaded / e.total) * 100 : (e.progress ?? 0) * 100;
            onProgress(Math.min(pct, 100));
          }
        : undefined,
    });
    return res.data;
  },
};