import type { ImageContent } from "./content.ts";
import { debugLog } from "./debug.ts";

export interface ImagePipelineDeps {
	resizeModelImage?: (image: ImageContent) => Promise<ImageContent>;
	resizePreviewImage?: (image: ImageContent) => Promise<ImageContent>;
	storeImage?: (image: ImageContent) => Promise<string | undefined>;
}

/** One source, independently cached model/preview bytes, and one model blob. */
export class PreparedImage {
	private modelPromise?: Promise<ImageContent>;
	private previewPromise?: Promise<ImageContent>;
	private referencePromise?: Promise<string | undefined>;
	preview?: ImageContent;
	reference?: string;

	constructor(readonly source: ImageContent, private readonly deps: ImagePipelineDeps) {}

	model(): Promise<ImageContent> {
		return this.modelPromise ??= this.resize(this.deps.resizeModelImage);
	}

	thumbnail(): Promise<ImageContent> {
		return this.previewPromise ??= this.resize(this.deps.resizePreviewImage).then((image) => {
			this.preview = image;
			return image;
		});
	}

	persist(): Promise<string | undefined> {
		return this.referencePromise ??= this.model().then(async (image) => {
			try {
				this.reference = await this.deps.storeImage?.(image);
			} catch (error) {
				debugLog("Failed to persist model image", error);
			}
			return this.reference;
		});
	}

	private async resize(resize?: (image: ImageContent) => Promise<ImageContent>): Promise<ImageContent> {
		try {
			return resize ? await resize(this.source) : this.source;
		} catch (error) {
			debugLog("Image preparation failed; keeping source attachment", error);
			return this.source;
		}
	}
}