import { createUploader } from "@visulima/storage-client";

const uploader = createUploader({
    endpoint: "/api/upload/multipart",
    metadata: { category: "photos" },
});

import { createMultipartAdapter } from "@visulima/storage-client";

const adapter = createMultipartAdapter({
    endpoint: "/api/upload/multipart",
});

const result = await adapter.upload(file);

import { createTusAdapter } from "@visulima/storage-client";

const adapter = createTusAdapter({
    endpoint: "/api/upload/tus",
    chunkSize: 1024 * 1024, // 1MB
});

const result = await adapter.upload(file);

import { createChunkedRestAdapter } from "@visulima/storage-client";

const adapter = createChunkedRestAdapter({
    endpoint: "/api/upload/chunked-rest",
    chunkSize: 5 * 1024 * 1024, // 5MB
});

const result = await adapter.upload(file);

import { buildUrl, fetchFile, fetchJson, fetchHead, deleteRequest, putFile, patchChunk, parseApiError, extractFileMetaFromHeaders } from "@visulima/storage-client";

import { storageQueryKeys } from "@visulima/storage-client";

// Base key
storageQueryKeys.all; // ["storage"]

// File keys
storageQueryKeys.files.all(endpoint);
storageQueryKeys.files.detail(endpoint, id, transformParams?);
storageQueryKeys.files.list(endpoint, { limit?, page? });
storageQueryKeys.files.meta(endpoint, id);
storageQueryKeys.files.head(endpoint, id);

// Transform keys
storageQueryKeys.transform.all(endpoint);
storageQueryKeys.transform.file(endpoint, id, transformParams);
storageQueryKeys.transform.metadata(endpoint);

interface FileMeta {
    id: string;
    name?: string;
    originalName?: string;
    contentType?: string;
    size?: number;
    bytesWritten?: number;
    createdAt?: string;
    metadata?: Record<string, unknown>;
    status?: "completed" | "part" | "deleted" | "created";
}

interface UploadResult extends FileMeta {
    filename?: string;
    offset?: number;
    url?: string;
}

type UploadMethod = "auto" | "multipart" | "tus" | "chunked-rest";

interface UploadItem {
    id: string;
    file: File;
    status: "pending" | "uploading" | "completed" | "error" | "aborted";
    completed: number;   // Progress percentage (0-100)
    loaded: number;      // Bytes uploaded so far
    size: number;        // Total file size in bytes
    error?: string;
    batchId?: string;
    retryCount?: number;
    url?: string;
    uploadResponse?: { data?: unknown; response?: string };
}

interface BatchState {
    id: string;
    itemIds: string[];
    status: "pending" | "uploading" | "completed" | "error" | "cancelled";
    progress: number;       // Aggregate progress (0-100)
    totalCount: number;
    completedCount: number;
    errorCount: number;
}

type UploaderEventType =
    | "ITEM_START" | "ITEM_PROGRESS" | "ITEM_FINISH" | "ITEM_ERROR" | "ITEM_ABORT"
    | "BATCH_START" | "BATCH_PROGRESS" | "BATCH_FINISH" | "BATCH_ERROR"
    | "BATCH_CANCELLED" | "BATCH_FINALIZE" | "BATCH_COMPLETE";

interface ApiError {
    error: {
        code: string;
        message: string;
        name?: string;
    };
}

interface FileHeadMetadata {
    contentLength?: number;
    contentType?: string;
    etag?: string;
    lastModified?: string;
    uploadOffset?: number;
    uploadComplete?: boolean;
    uploadExpires?: string;
    chunkedUpload?: boolean;
    receivedChunks?: number[];
}

interface FileListResponse {
    data: FileMeta[];
    meta?: {
        page?: number;
        perPage?: number;
        total?: number;
        firstPage?: number;
        lastPage?: number;
        firstPageUrl?: string;
        lastPageUrl?: string;
        nextPageUrl?: string | undefined;
        previousPageUrl?: string | undefined;
    };
}

interface TransformOptions {
    width?: number;
    height?: number;
    quality?: number;         // 0-100
    format?: string;          // "jpeg", "png", "webp", etc.
    fit?: "cover" | "contain" | "fill" | "inside" | "outside";
    [key: string]: string | number | boolean | undefined;
}

interface TransformMetadata {
    formats?: string[];
    parameters?: string[];
}

interface BatchDeleteResult {
    successful?: number;
    failed?: number;
}

const {
    upload,       // (file: File) => Promise<UploadResult>
    abort,        // () => void
    reset,        // () => void
    progress,     // number (0-100)
    isUploading,  // boolean
    isPaused,     // boolean | undefined
    error,        // Error | undefined
    result,       // UploadResult | undefined
    currentMethod,// UploadMethod
    offset,       // number | undefined
    pause,        // (() => void) | undefined
    resume,       // (() => Promise<void>) | undefined
} = useUpload(options);

const { upload, progress, isUploading, error, result, reset } = useMultipartUpload({
    endpoint: "/api/upload/multipart",
});

const { upload, pause, resume, abort, progress, isUploading, isPaused, offset, error, result, reset } = useTusUpload({
    endpoint: "/api/upload/tus",
});

const { upload, pause, resume, abort, progress, isUploading, isPaused, offset, error, result, reset } = useChunkedRestUpload({
    endpoint: "/api/upload/chunked-rest",
    chunkSize: 5 * 1024 * 1024,
});

const { uploadBatch, abortBatch, progress, isUploading, items, completedCount, errorCount, error, reset } = useBatchUpload({
    endpoint: "/api/upload/multipart",
});

const { files, inputRef, handleFileChange, handleDrop, handleDragOver, handleDragLeave, openFileDialog, reset } = useFileInput({
    multiple: true,
    accept: "image/*",
});

const { handlePaste, pastedFiles, reset } = usePasteUpload({
    filter: (file) => file.type.startsWith("image/"),
    onFilesPasted: (files) => console.log("Pasted:", files),
});

const { data, isLoading, error, meta, refetch } = useGetFile({
    endpoint: "/api/files",
    id: "file-123",
});

const { data, isLoading, error, refetch } = useGetFileList({
    endpoint: "/api/files",
    page: 1,
    limit: 20,
});

const { data, isLoading, error, refetch } = useGetFileMeta({
    endpoint: "/api/files",
    id: "file-123",
});

const { data, isLoading, error, refetch } = useHeadFile({
    endpoint: "/api/files",
    id: "file-123",
});

const { deleteFile, isLoading, error, reset } = useDeleteFile({
    endpoint: "/api/files",
});

await deleteFile("file-123");

const { batchDeleteFiles, isLoading, error, reset } = useBatchDeleteFiles({
    endpoint: "/api/files",
});

const result = await batchDeleteFiles(["file-1", "file-2"]);
// result: { successful?: number, failed?: number }

const { putFile, progress, isLoading, error, data, reset } = usePutFile({
    endpoint: "/api/files",
});

await putFile("file-123", file);

const { patchChunk, isLoading, error, data, reset } = usePatchChunk({
    endpoint: "/api/upload/chunked-rest",
});

await patchChunk("file-123", chunkBlob, offset, checksum);

const { data, isLoading, error, meta, refetch } = useTransformFile({
    endpoint: "/api/files",
    id: "file-123",
    transform: { width: 800, height: 600, quality: 85 },
});

const { data, isLoading, error, refetch } = useTransformMetadata({
    endpoint: "/api/files",
});
// data: { formats?: string[], parameters?: string[] }

const { abortAll } = useAbortAll({ endpoint: "/api/upload/multipart" });

const { abortBatch } = useAbortBatch({ endpoint: "/api/upload/multipart" });
abortBatch("batch-123");

const { abortItem } = useAbortItem({ endpoint: "/api/upload/multipart" });
abortItem("item-123");

const { retryItem } = useRetry({ endpoint: "/api/upload/multipart" });
retryItem("item-123");

const { retryBatch } = useBatchRetry({ endpoint: "/api/upload/multipart" });
retryBatch("batch-123");