"use client";
import Image from "next/image";
import { useCallback, useEffect, useRef, useState, type ChangeEvent, type DragEvent } from "react";
import { ArrowRight, Image as ImageIcon, RotateCcw, Upload, X } from "lucide-react";
import { BatchEnhancer } from "@/components/BatchEnhancer";
import { ComparisonViewer } from "@/components/ComparisonViewer";
import { EnhancementControls } from "@/components/EnhancementControls";
import { useHfOAuth } from "@/components/HfOAuthProvider";
import { UploadPanel } from "@/components/UploadPanel";
import { enhanceImage, EnhancementApiError } from "@/lib/api";
import { formatFileSize, validateImageFile } from "@/lib/fileValidation";
import type {
EnhancementResponse,
EnhancementSettings,
} from "@/types/enhancement";
type SelectedImage = {
file: File;
width: number;
height: number;
previewUrl: string;
};
const DEFAULT_SETTINGS: EnhancementSettings = { scale: 4, outputFormat: "png" };
type SingleImageStudioProps = {
active: boolean;
accessToken: string | null;
requiresAuth: boolean;
onBusyChange: (busy: boolean) => void;
};
export function EnhancerStudio() {
const hfAuth = useHfOAuth();
const [mode, setMode] = useState<"single" | "batch">("single");
const [busyModes, setBusyModes] = useState({ single: false, batch: false });
const isBusy = busyModes.single || busyModes.batch;
const reportSingleBusy = useCallback((busy: boolean) => {
setBusyModes((current) => ({ ...current, single: busy }));
}, []);
const reportBatchBusy = useCallback((busy: boolean) => {
setBusyModes((current) => ({ ...current, batch: busy }));
}, []);
return (
);
}
function SingleImageStudio({ active, accessToken, requiresAuth, onBusyChange }: SingleImageStudioProps) {
const [source, setSource] = useState(null);
const [result, setResult] = useState(null);
const [resultPreviewUrl, setResultPreviewUrl] = useState(null);
const [settings, setSettings] = useState(DEFAULT_SETTINGS);
const [errorMessage, setErrorMessage] = useState(null);
const [requestStatus, setRequestStatus] = useState(null);
const [isProcessing, setIsProcessing] = useState(false);
const [isPreviewing, setIsPreviewing] = useState(false);
const [isDragging, setIsDragging] = useState(false);
const [zoom, setZoom] = useState(1);
const fileInput = useRef(null);
const sourceUrl = useRef(null);
const resultUrl = useRef(null);
const selectionSequence = useRef(0);
const previewingRef = useRef(false);
useEffect(() => {
onBusyChange(isProcessing || isPreviewing);
}, [isProcessing, isPreviewing, onBusyChange]);
const releaseResultUrl = useCallback(() => {
if (resultUrl.current) URL.revokeObjectURL(resultUrl.current);
resultUrl.current = null;
setResultPreviewUrl(null);
}, []);
const selectFile = useCallback(async (file: File) => {
const validationMessage = validateImageFile(file);
if (validationMessage) {
setErrorMessage(validationMessage);
return;
}
const selection = ++selectionSequence.current;
previewingRef.current = true;
setIsPreviewing(true);
setErrorMessage(null);
let previewUrl = "";
try {
previewUrl = URL.createObjectURL(file);
const image = new window.Image();
image.src = previewUrl;
await image.decode();
if (selection !== selectionSequence.current) {
URL.revokeObjectURL(previewUrl);
return;
}
if (image.naturalWidth < 1 || image.naturalHeight < 1) {
throw new Error("Image dimensions are invalid.");
}
if (sourceUrl.current) URL.revokeObjectURL(sourceUrl.current);
releaseResultUrl();
sourceUrl.current = previewUrl;
setSource({
file,
width: image.naturalWidth,
height: image.naturalHeight,
previewUrl,
});
setResult(null);
previewingRef.current = false;
setIsPreviewing(false);
setIsProcessing(false);
setZoom(1);
setErrorMessage(null);
} catch {
if (previewUrl) URL.revokeObjectURL(previewUrl);
if (selection === selectionSequence.current) {
previewingRef.current = false;
setIsPreviewing(false);
setIsProcessing(false);
setErrorMessage("This image could not be previewed. Try another JPG, PNG, or WEBP file.");
}
}
}, [releaseResultUrl]);
const clearImage = useCallback(() => {
selectionSequence.current += 1;
previewingRef.current = false;
setIsPreviewing(false);
if (sourceUrl.current) URL.revokeObjectURL(sourceUrl.current);
sourceUrl.current = null;
releaseResultUrl();
setSource(null);
setResult(null);
setErrorMessage(null);
setIsProcessing(false);
setZoom(1);
if (fileInput.current) fileInput.current.value = "";
}, [releaseResultUrl]);
useEffect(() => () => {
if (sourceUrl.current) URL.revokeObjectURL(sourceUrl.current);
if (resultUrl.current) URL.revokeObjectURL(resultUrl.current);
}, []);
useEffect(() => {
if (!active) return;
function handlePaste(event: ClipboardEvent) {
const target = event.target;
if (target instanceof HTMLElement && (target.isContentEditable || ["INPUT", "TEXTAREA"].includes(target.tagName))) {
return;
}
const item = Array.from(event.clipboardData?.items ?? []).find((entry) => entry.type.startsWith("image/"));
const pastedFile = item?.getAsFile();
if (!pastedFile || isProcessing || previewingRef.current) return;
event.preventDefault();
const extension = pastedFile.type === "image/webp" ? "webp" : pastedFile.type === "image/jpeg" ? "jpg" : "png";
const file = pastedFile.name
? pastedFile
: new File([pastedFile], `pasted-image.${extension}`, { type: pastedFile.type });
void selectFile(file);
}
window.addEventListener("paste", handlePaste);
return () => window.removeEventListener("paste", handlePaste);
}, [active, isProcessing, selectFile]);
async function handleEnhance() {
if (!source || isProcessing || previewingRef.current) return;
const requestSelection = selectionSequence.current;
setIsProcessing(true);
setErrorMessage(null);
setRequestStatus("Connecting to the AI queue…");
try {
const enhanced = await enhanceImage(source.file, settings, {
width: source.width,
height: source.height,
}, accessToken, (progress) => {
if (progress.stage === "queued") {
setRequestStatus(progress.position
? `Waiting in the shared GPU queue · position ${progress.position}`
: "Waiting for the shared GPU queue…");
} else if (progress.stage === "working") {
setRequestStatus("Enhancing with Real-ESRGAN…");
}
});
if (requestSelection !== selectionSequence.current) return;
releaseResultUrl();
const previewUrl = URL.createObjectURL(enhanced.blob);
resultUrl.current = previewUrl;
setResultPreviewUrl(previewUrl);
setResult(enhanced);
setZoom(1);
} catch (error) {
if (requestSelection !== selectionSequence.current) return;
setErrorMessage(
error instanceof EnhancementApiError
? error.message
: "Something went wrong. Please try enhancing the image again.",
);
} finally {
if (requestSelection === selectionSequence.current) {
setIsProcessing(false);
setRequestStatus(null);
}
}
}
function handleDownload() {
if (!result) return;
const downloadUrl = URL.createObjectURL(result.blob);
const anchor = document.createElement("a");
anchor.href = downloadUrl;
anchor.download = result.metadata.filename;
document.body.append(anchor);
anchor.click();
anchor.remove();
window.setTimeout(() => URL.revokeObjectURL(downloadUrl), 1_000);
}
function handleInputChange(event: ChangeEvent) {
const file = event.currentTarget.files?.item(0);
event.currentTarget.value = "";
if (file && !isProcessing && !previewingRef.current) void selectFile(file);
}
function handleDrop(event: DragEvent) {
event.preventDefault();
setIsDragging(false);
const file = event.dataTransfer.files.item(0);
if (file && !isProcessing && !previewingRef.current) void selectFile(file);
}
const changeZoom = (value: number) => setZoom(value);
return (
{
if (event.dataTransfer.types.includes("Files")) setIsDragging(true);
}}
onDragOver={(event) => {
if (event.dataTransfer.types.includes("Files")) event.preventDefault();
}}
onDragLeave={(event) => {
if (!event.currentTarget.contains(event.relatedTarget as Node | null)) setIsDragging(false);
}}
onDrop={handleDrop}
>
{result ? "RESULT READY" : source ? "IMAGE READY" : "YOUR CANVAS"}
{requiresAuth ? "HF ZERO-GPU" : "LOCAL SESSION"}
{source && (
)}
{source && (
)}
{source && result && resultPreviewUrl ? (
) : source ? (
ORIGINAL
{source.file.name || "Pasted image"}{source.width.toLocaleString()} × {source.height.toLocaleString()} px · {formatFileSize(source.file.size)}
READY
) : (
fileInput.current?.click()}
/>
)}
{source && result && (
{result.metadata.filename}{formatFileSize(result.blob.size)} · Full-resolution output
)}
{errorMessage && (
!{errorMessage}
)}
{!source && QUICK TIP You can also paste an image from your clipboard with Ctrl + V.
}
void handleEnhance()}
settings={settings}
/>
);
}