/**
 * Rebuild ~/Desktop/ftp-images-new from original ftp-images sources.
 * Fixes blur + loading issues: single encode, baseline JPEG, no blur masks, higher resolution.
 */

import { removeBackground } from '@imgly/background-removal-node';
import fs from 'node:fs';
import path from 'node:path';
import sharp from 'sharp';

const OUT_ROOT = path.join(process.env.HOME ?? '', 'Desktop', 'ftp-images-new');
const SRC_ROOT = path.join(__dirname, '..', 'ftp-images');
const SWEETS_MARKER = `${path.sep}sweets${path.sep}`;

const OUT_W = 2400;
const OUT_H = 1800;
const PLATE_CX = OUT_W / 2;
const PLATE_CY = OUT_H / 2 + 24;
const PLATE_R = 660;

const JPEG = {
  quality: 96,
  mozjpeg: false,
  progressive: false,
  chromaSubsampling: '4:4:4' as const,
};

const HARD_CROP_SWEETS = new Set([
  'bilder-bp/sweets/patisa/bild/IMG_1400.jpg',
  'bilder-bp/sweets/namak-paray/bild/IMG_0209.jpg',
]);

function platePng(seed: number): Buffer {
  const specks: string[] = [];
  let s = seed + 17;
  const rand = () => {
    s = (s * 16807) % 2147483647;
    return s / 2147483647;
  };
  const colors = ['#4A7EBB', '#E8843C', '#C4A882', '#6B9E78', '#D4A574'];
  for (let i = 0; i < 64; i++) {
    const a = rand() * Math.PI * 2;
    const d = rand() * (PLATE_R - 80);
    const x = PLATE_CX + Math.cos(a) * d;
    const y = PLATE_CY + Math.sin(a) * d;
    specks.push(
      `<circle cx="${x.toFixed(1)}" cy="${y.toFixed(1)}" r="${(3 + rand() * 8).toFixed(1)}" fill="${colors[i % colors.length]}" opacity="0.5"/>`
    );
  }

  const svg = `<svg width="${OUT_W}" height="${OUT_H}" xmlns="http://www.w3.org/2000/svg">
    <rect width="100%" height="100%" fill="#FFFFFF"/>
    <ellipse cx="${PLATE_CX}" cy="${PLATE_CY + 42}" rx="${PLATE_R + 30}" ry="${PLATE_R * 0.14}" fill="#D8D0C4" opacity="0.35"/>
    <circle cx="${PLATE_CX}" cy="${PLATE_CY}" r="${PLATE_R + 14}" fill="#FFFFFF"/>
    <circle cx="${PLATE_CX}" cy="${PLATE_CY}" r="${PLATE_R + 10}" fill="none" stroke="#C9A227" stroke-width="11"/>
    <circle cx="${PLATE_CX}" cy="${PLATE_CY}" r="${PLATE_R}" fill="#FFFDF8"/>
    <clipPath id="c"><circle cx="${PLATE_CX}" cy="${PLATE_CY}" r="${PLATE_R}"/></clipPath>
    <g clip-path="url(#c)">${specks.join('')}</g>
    <circle cx="${PLATE_CX}" cy="${PLATE_CY}" r="${PLATE_R - 28}" fill="none" stroke="#EDE4D4" stroke-width="2"/>
    <circle cx="${PLATE_CX}" cy="${PLATE_CY}" r="${PLATE_R}" fill="none" stroke="#B8922A" stroke-width="5"/>
  </svg>`;
  return Buffer.from(svg);
}

function collectImages(dir: string): string[] {
  if (!fs.existsSync(dir)) return [];
  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
    const full = path.join(dir, e.name);
    if (e.isDirectory()) return collectImages(full);
    if (/\.(jpe?g|png|webp)$/i.test(e.name) && !e.name.includes('.polish.')) return [full];
    return [];
  });
}

function findSource(rel: string): string | null {
  const dir = path.dirname(path.join(SRC_ROOT, rel));
  const base = path.basename(rel, path.extname(rel));
  if (!fs.existsSync(dir)) return null;
  for (const name of fs.readdirSync(dir)) {
    if (name.startsWith(base) && /\.(jpe?g|png|webp)$/i.test(name)) {
      return path.join(dir, name);
    }
  }
  return null;
}

async function preparePhoto(src: string): Promise<Buffer> {
  const rotated = sharp(src, { failOn: 'none', unlimited: true }).rotate();
  const { data, info } = await rotated.toColorspace('srgb').removeAlpha().toBuffer({ resolveWithObject: true });

  const w = info.width;
  const h = info.height;
  const aspect = OUT_W / OUT_H;
  const sa = w / h;

  let cropW = w;
  let cropH = h;
  let left = 0;
  let top = 0;
  if (sa > aspect) {
    cropW = Math.round(h * aspect);
    left = Math.round((w - cropW) / 2);
  } else if (sa < aspect) {
    cropH = Math.round(w / aspect);
    top = Math.round((h - cropH) / 2);
  }
  cropW = Math.min(cropW, w - left);
  cropH = Math.min(cropH, h - top);

  const minDim = Math.min(cropW, cropH);
  let pipe = sharp(data)
    .extract({ left, top, width: cropW, height: cropH })
    .modulate({ brightness: 1.02, saturation: 1.1 });

  if (minDim < 1200) {
    pipe = pipe.sharpen({ sigma: 1, m1: 0.6, m2: 0.3 });
  } else {
    pipe = pipe.sharpen({ sigma: 0.6, m1: 0.4, m2: 0.2 });
  }

  return pipe
    .resize(OUT_W, OUT_H, { fit: 'fill', kernel: sharp.kernel.lanczos3 })
    .png()
    .toBuffer();
}

async function writeJpeg(buf: Buffer, dest: string): Promise<void> {
  fs.mkdirSync(path.dirname(dest), { recursive: true });
  await sharp(buf).jpeg(JPEG).toFile(dest);
}

async function rebuildDish(src: string, dest: string): Promise<void> {
  const photo = await preparePhoto(src);
  await writeJpeg(photo, dest);
}

async function cutoutFromPng(pngPath: string): Promise<Buffer> {
  const blob = await removeBackground(pngPath, { model: 'small' });
  return Buffer.from(await blob.arrayBuffer());
}

async function cutoutOk(buf: Buffer): Promise<boolean> {
  const { data, info } = await sharp(buf).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
  const w = info.width ?? 1;
  const h = info.height ?? 1;
  let o = 0;
  let t = 0;
  for (let y = Math.floor(h * 0.15); y < Math.floor(h * 0.85); y++) {
    for (let x = Math.floor(w * 0.15); x < Math.floor(w * 0.85); x++) {
      if (data[(y * w + x) * 4 + 3] > 50) o++;
      t++;
    }
  }
  return o / t > 0.06;
}

async function placeOnPlate(foodPng: Buffer, index: number): Promise<Buffer> {
  const meta = await sharp(foodPng).metadata();
  const cw = meta.width ?? 1;
  const ch = meta.height ?? 1;
  const maxW = PLATE_R * 1.05;
  const maxH = PLATE_R * 0.88;
  const scale = Math.min(maxW / cw, maxH / ch, 1);

  const food = await sharp(foodPng)
    .resize(Math.round(cw * scale), Math.round(ch * scale), { kernel: sharp.kernel.lanczos3 })
    .png()
    .toBuffer();

  const fm = await sharp(food).metadata();
  const fw = fm.width ?? 1;
  const fh = fm.height ?? 1;
  const left = Math.round(PLATE_CX - fw / 2);
  const top = Math.round(PLATE_CY - fh / 2 + 4);

  const shadow = Buffer.from(`<svg width="${OUT_W}" height="${OUT_H}">
    <ellipse cx="${PLATE_CX}" cy="${PLATE_CY + fh * 0.17}" rx="${fw * 0.38}" ry="${fh * 0.085}" fill="#A09890" opacity="0.14"/>
  </svg>`);

  return sharp(platePng(index))
    .composite([
      { input: await sharp(shadow).png().toBuffer(), top: 0, left: 0 },
      { input: food, top, left },
    ])
    .png()
    .toBuffer();
}

async function hardCropFood(photo: Buffer): Promise<Buffer> {
  const meta = await sharp(photo).metadata();
  const w = meta.width ?? OUT_W;
  const h = meta.height ?? OUT_H;
  const cw = Math.round(w * 0.62);
  const ch = Math.round(h * 0.62);
  return sharp(photo)
    .extract({ left: Math.round((w - cw) / 2), top: Math.round((h - ch) / 2), width: cw, height: ch })
    .png()
    .toBuffer();
}

async function rebuildSweet(src: string, dest: string, rel: string, index: number): Promise<void> {
  const photo = await preparePhoto(src);
  const tmp = path.join(OUT_ROOT, `.tmp-${index}.png`);
  fs.writeFileSync(tmp, photo);

  try {
    let food: Buffer;
    if (HARD_CROP_SWEETS.has(rel)) {
      food = await hardCropFood(photo);
    } else {
      const cut = await cutoutFromPng(tmp);
      food = (await cutoutOk(cut)) ? cut : await hardCropFood(photo);
    }
    const composed = await placeOnPlate(food, index);
    await writeJpeg(composed, dest);
  } finally {
    if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
  }
}

async function verifyJpeg(file: string): Promise<boolean> {
  try {
    const meta = await sharp(file).metadata();
    return (meta.width ?? 0) > 0 && (meta.height ?? 0) > 0;
  } catch {
    return false;
  }
}

async function main() {
  const images = collectImages(OUT_ROOT).sort();
  let ok = 0;
  let fail = 0;

  console.log(`Rebuilding ${images.length} images → ${OUT_W}×${OUT_H} baseline JPEG\n`);

  for (let i = 0; i < images.length; i++) {
    const dest = images[i];
    const rel = path.relative(OUT_ROOT, dest);
    const src = findSource(rel);
    if (!src) {
      console.error(`  ✗ ${rel}: no source`);
      fail++;
      continue;
    }
    try {
      if (rel.includes(SWEETS_MARKER)) {
        await rebuildSweet(src, dest, rel, i);
      } else {
        await rebuildDish(src, dest);
      }
      if (!(await verifyJpeg(dest))) throw new Error('invalid output JPEG');
      const stat = fs.statSync(dest);
      if (stat.size < 8000) throw new Error('file too small');
      ok++;
      console.log(`  ✓ ${rel} (${Math.round(stat.size / 1024)}KB)`);
    } catch (err) {
      fail++;
      console.error(`  ✗ ${rel}: ${err instanceof Error ? err.message : err}`);
    }
  }

  console.log(`\nDone: ${ok} rebuilt, ${fail} failed`);
  if (fail) process.exit(1);
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});