1import fs from "node:fs/promises";
2import path from "node:path";
3import { fileURLToPath } from "node:url";
4import { Jimp, JimpMime } from "jimp";
5import decodeWebp, { init as initWebpDecode } from "@jsquash/webp/decode.js";
6 
7export interface WechatUploadAsset {
8  buffer: Buffer;
9  filename: string;
10  contentType: string;
11  fileExt: string;
12  fileSize: number;
13}
14 
15export interface PreparedWechatUploadAsset {
16  buffer: Buffer;
17  filename: string;
18  contentType: string;
19  wasProcessed: boolean;
20  processingNotes: string[];
21}
22 
23export const WECHAT_BODY_IMAGE_MAX_SIZE = 1024 * 1024; // 1MB
24export const WECHAT_BODY_IMAGE_UNSUPPORTED_FORMATS = new Set([
25  ".gif",
26  ".webp",
27  ".bmp",
28  ".tiff",
29  ".tif",
30  ".svg",
31  ".ico",
32]);
33 
34const BODY_UPLOAD_ALLOWED_MIME_TYPES = new Set([
35  JimpMime.jpeg,
36  JimpMime.png,
37]);
38 
39const MIME_TO_EXT: Record<string, string> = {
40  "image/jpeg": ".jpg",
41  "image/png": ".png",
42  "image/gif": ".gif",
43  "image/webp": ".webp",
44  "image/bmp": ".bmp",
45  "image/x-ms-bmp": ".bmp",
46  "image/tiff": ".tiff",
47  "image/svg+xml": ".svg",
48  "image/x-icon": ".ico",
49  "image/vnd.microsoft.icon": ".ico",
50};
51 
52const JPEG_QUALITY_STEPS = [82, 74, 66, 58, 50, 42, 34];
53const MAX_WIDTH_STEPS = [2560, 2048, 1600, 1280, 1024, 800, 640, 480];
54 
55/**
56 * Detect actual image format from buffer magic bytes.
57 * Returns corrected { contentType, fileExt } or null if unknown.
58 */
59export function detectImageFormatFromBuffer(buffer: Buffer): { contentType: string; fileExt: string } | null {
60  if (buffer.length < 12) return null;
61 
62  // WebP: RIFF....WEBP
63  if (
64    buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46 &&
65    buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50
66  ) {
67    return { contentType: "image/webp", fileExt: ".webp" };
68  }
69  // PNG: 89 50 4E 47
70  if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
71    return { contentType: "image/png", fileExt: ".png" };
72  }
73  // JPEG: FF D8 FF
74  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
75    return { contentType: "image/jpeg", fileExt: ".jpg" };
76  }
77  // GIF: GIF8
78  if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x38) {
79    return { contentType: "image/gif", fileExt: ".gif" };
80  }
81  // BMP: BM
82  if (buffer[0] === 0x42 && buffer[1] === 0x4d) {
83    return { contentType: "image/bmp", fileExt: ".bmp" };
84  }
85  return null;
86}
87 
88let webpDecoderReady: Promise<void> | undefined;
89 
90type JimpImage = Awaited<ReturnType<typeof Jimp.read>>;
91 
92function normalizeMimeType(contentType: string): string {
93  return contentType.split(";")[0]!.trim().toLowerCase();
94}
95 
96function extFromMimeType(contentType: string): string {
97  return MIME_TO_EXT[normalizeMimeType(contentType)] || "";
98}
99 
100function ensureFileExt(asset: WechatUploadAsset): string {
101  return asset.fileExt || extFromMimeType(asset.contentType);
102}
103 
104function basenameWithoutExt(filename: string): string {
105  const base = path.basename(filename, path.extname(filename));
106  return base || "image";
107}
108 
109function renameWithExt(filename: string, ext: string): string {
110  return `${basenameWithoutExt(filename)}${ext}`;
111}
112 
113export function needsWechatBodyImageProcessing(asset: WechatUploadAsset): boolean {
114  if (asset.fileSize > WECHAT_BODY_IMAGE_MAX_SIZE) {
115    return true;
116  }
117 
118  const normalizedMimeType = normalizeMimeType(asset.contentType);
119  if (BODY_UPLOAD_ALLOWED_MIME_TYPES.has(normalizedMimeType)) {
120    return false;
121  }
122 
123  const fileExt = ensureFileExt(asset);
124  return WECHAT_BODY_IMAGE_UNSUPPORTED_FORMATS.has(fileExt) || !fileExt;
125}
126 
127async function ensureWebpDecoder(): Promise<void> {
128  if (!webpDecoderReady) {
129    webpDecoderReady = (async () => {
130      const __filename = fileURLToPath(import.meta.url);
131      const __dirname = path.dirname(__filename);
132      const wasmPath = path.resolve(__dirname, "node_modules/@jsquash/webp/codec/dec/webp_dec.wasm");
133      const wasmModule = await WebAssembly.compile(await fs.readFile(wasmPath));
134      await initWebpDecode(wasmModule, {});
135    })();
136  }
137 
138  await webpDecoderReady;
139}
140 
141async function loadImageForProcessing(asset: WechatUploadAsset): Promise<JimpImage> {
142  const fileExt = ensureFileExt(asset);
143  const normalizedMimeType = normalizeMimeType(asset.contentType);
144 
145  if (fileExt === ".webp" || normalizedMimeType === "image/webp") {
146    await ensureWebpDecoder();
147    const decoded = await decodeWebp(asset.buffer);
148    return new Jimp({
149      data: Buffer.from(decoded.data.buffer, decoded.data.byteOffset, decoded.data.byteLength),
150      width: decoded.width,
151      height: decoded.height,
152    });
153  }
154 
155  if (fileExt === ".svg" || fileExt === ".ico") {
156    throw new Error(`Cannot convert ${fileExt} image for WeChat body upload; provide a PNG or JPG instead.`);
157  }
158 
159  return Jimp.read(asset.buffer);
160}
161 
162function imageHasTransparency(image: JimpImage): boolean {
163  const { data } = image.bitmap;
164  for (let i = 3; i < data.length; i += 4) {
165    if (data[i] !== 255) {
166      return true;
167    }
168  }
169  return false;
170}
171 
172function buildCandidateWidths(width: number): number[] {
173  const candidates = new Set<number>([width]);
174 
175  for (const maxWidth of MAX_WIDTH_STEPS) {
176    if (width > maxWidth) {
177      candidates.add(maxWidth);
178    }
179  }
180 
181  return [...candidates].sort((a, b) => b - a);
182}
183 
184function resizeToWidth(image: JimpImage, width: number): JimpImage {
185  const cloned = image.clone();
186  if (width < image.bitmap.width) {
187    cloned.resize({ w: width });
188  }
189  return cloned;
190}
191 
192function flattenOnWhite(image: JimpImage): JimpImage {
193  const flattened = new Jimp({
194    width: image.bitmap.width,
195    height: image.bitmap.height,
196    color: 0xffffffff,
197  });
198  flattened.composite(image, 0, 0);
199  return flattened;
200}
201 
202async function encodePng(image: JimpImage): Promise<Buffer> {
203  return image.getBuffer(JimpMime.png);
204}
205 
206async function encodeJpeg(image: JimpImage, quality: number): Promise<Buffer> {
207  const jpegSource = imageHasTransparency(image) ? flattenOnWhite(image) : image;
208  return jpegSource.getBuffer(JimpMime.jpeg, { quality });
209}
210 
211function buildProcessingNotes(asset: WechatUploadAsset): string[] {
212  const notes: string[] = [];
213  const fileExt = ensureFileExt(asset);
214 
215  if (fileExt && WECHAT_BODY_IMAGE_UNSUPPORTED_FORMATS.has(fileExt)) {
216    notes.push(`converted unsupported ${fileExt} source`);
217  }
218 
219  if (asset.fileSize > WECHAT_BODY_IMAGE_MAX_SIZE) {
220    notes.push(`compressed ${(asset.fileSize / 1024 / 1024).toFixed(2)}MB source below 1MB`);
221  }
222 
223  if (notes.length === 0) {
224    notes.push("re-encoded for WeChat body upload");
225  }
226 
227  return notes;
228}
229 
230export async function prepareWechatBodyImageUpload(
231  asset: WechatUploadAsset,
232): Promise<PreparedWechatUploadAsset> {
233  if (!needsWechatBodyImageProcessing(asset)) {
234    return {
235      buffer: asset.buffer,
236      filename: asset.filename,
237      contentType: asset.contentType,
238      wasProcessed: false,
239      processingNotes: [],
240    };
241  }
242 
243  const image = await loadImageForProcessing(asset);
244  const widths = buildCandidateWidths(image.bitmap.width);
245  const ext = ensureFileExt(asset);
246  const preferPng = imageHasTransparency(image) || ext === ".png" || ext === ".webp";
247  const processingNotes = buildProcessingNotes(asset);
248 
249  for (const width of widths) {
250    const resized = resizeToWidth(image, width);
251 
252    if (preferPng) {
253      const pngBuffer = await encodePng(resized);
254      if (pngBuffer.length <= WECHAT_BODY_IMAGE_MAX_SIZE) {
255        return {
256          buffer: pngBuffer,
257          filename: renameWithExt(asset.filename, ".png"),
258          contentType: JimpMime.png,
259          wasProcessed: true,
260          processingNotes: width < image.bitmap.width
261            ? [...processingNotes, `resized to ${width}px wide`]
262            : processingNotes,
263        };
264      }
265    }
266 
267    for (const quality of JPEG_QUALITY_STEPS) {
268      const jpegBuffer = await encodeJpeg(resized, quality);
269      if (jpegBuffer.length <= WECHAT_BODY_IMAGE_MAX_SIZE) {
270        const notes = [...processingNotes, `encoded as JPEG (${quality} quality)`];
271        if (width < image.bitmap.width) {
272          notes.push(`resized to ${width}px wide`);
273        }
274        return {
275          buffer: jpegBuffer,
276          filename: renameWithExt(asset.filename, ".jpg"),
277          contentType: JimpMime.jpeg,
278          wasProcessed: true,
279          processingNotes: notes,
280        };
281      }
282    }
283  }
284 
285  throw new Error(`Unable to reduce ${asset.filename} below 1MB for WeChat body upload.`);
286}
287