pinkudex/app/actions/coverMeta.ts

"use server";
import { revalidatePath } from "next/cache";
import path from "node:path";
import fs from "node:fs/promises";
import { rawDb, uniqueSlug } from "@/lib/db/client";
import { sanitizeFilename, uniqueFilePath, letterBucket, canonicalThumbName } from "@/lib/filename";
import { safeJoin } from "@/lib/safePath";
import { normalizeCode } from "@/lib/jav/codeParser";

const LIBRARY_ROOT = path.join(process.cwd(), "library");
const THUMB_ROOT = path.join(process.cwd(), "data", "thumbs");

export interface CoverMetaInput {
  imageId: number;
  code: string | null;
  title: string | null;
  releaseDate: string | null;
  runtimeMin: number | null;
  director: string | null;
  studio: string | null;
  label: string | null;
  series: string | null;
  rating: number | null;
  watched: boolean;
  notes: string | null;
  actresses: string[];
  genres: string[];
}

function upsertEntity(table: "studios" | "labels" | "series" | "actresses" | "genres", name: string): number {
  const trimmed = name.trim();
  const existing = rawDb.prepare(`SELECT id FROM ${table} WHERE name = ?`).get(trimmed) as { id: number } | undefined;
  if (existing) return existing.id;
  const slug = uniqueSlug(rawDb, table, trimmed);
  const row = rawDb.prepare(`INSERT INTO ${table} (name, slug) VALUES (?, ?) RETURNING id`).get(trimmed, slug) as { id: number };
  return row.id;
}

export async function saveCoverMeta(input: CoverMetaInput): Promise<{ ok: true }> {
  const studioId = input.studio?.trim() ? upsertEntity("studios", input.studio) : null;
  const labelId = input.label?.trim() ? upsertEntity("labels", input.label) : null;
  const seriesId = input.series?.trim() ? upsertEntity("series", input.series) : null;

  // Snapshot the previous code so we can detect a code rename and move
  // the file (and its attachments) to the correct letter bucket, plus
  // rename their thumbnail files to keep the prefix in sync.
  const prev = rawDb.prepare(`SELECT code FROM images WHERE id = ?`).get(input.imageId) as
    | { code: string | null }
    | undefined;

  const tx = rawDb.transaction(() => {
    rawDb.prepare(`
      UPDATE images SET
        code = ?, title = ?, release_date = ?, runtime_min = ?, director = ?,
        studio_id = ?, label_id = ?, series_id = ?,
        rating = ?, watched = ?, notes = ?
      WHERE id = ?
    `).run(
      normalizeCoverCode(input.code),
      norm(input.title),
      norm(input.releaseDate),
      // Coerce strings → numbers so FormData callers (where everything
      // arrives as a string) don't get nulled out. Number.isFinite("5")
      // is false, but Number("5") is 5.
      (() => {
        const raw: unknown = input.runtimeMin;
        const v = typeof raw === "string" ? Number(raw) : raw;
        return typeof v === "number" && Number.isFinite(v) ? v : null;
      })(),
      norm(input.director),
      studioId,
      labelId,
      seriesId,
      typeof input.rating === "number" && input.rating >= 0 && input.rating <= 5 ? input.rating : null,
      input.watched ? 1 : 0,
      norm(input.notes),
      input.imageId,
    );

    rawDb.prepare(`DELETE FROM image_actresses WHERE image_id = ?`).run(input.imageId);
    for (const name of dedupeNames(input.actresses)) {
      const id = upsertEntity("actresses", name);
      rawDb.prepare(`INSERT OR IGNORE INTO image_actresses (image_id, actress_id) VALUES (?, ?)`).run(input.imageId, id);
    }
    rawDb.prepare(`DELETE FROM image_genres WHERE image_id = ?`).run(input.imageId);
    for (const name of dedupeNames(input.genres)) {
      const id = upsertEntity("genres", name);
      rawDb.prepare(`INSERT OR IGNORE INTO image_genres (image_id, genre_id) VALUES (?, ?)`).run(input.imageId, id);
    }
  });
  tx();

  // After the DB update commits, see if the code rename crossed bucket
  // boundaries. If so, move the cover file and any attached children.
  // Failure here logs but doesn't roll back the DB — the file move is
  // best-effort and a later Reorganize run will fix any drift.
  const oldBucket = letterBucket(prev?.code ?? null).dirRel;
  const newCode = normalizeCoverCode(input.code);
  const newBucket = letterBucket(newCode).dirRel;
  if (oldBucket !== newBucket) {
    await moveImageBucket(input.imageId, newBucket).catch((e) => {
      console.error(`[saveCoverMeta] bucket move failed for image ${input.imageId}:`, e);
    });
  }
  // Code embeds in the thumbnail filename — rename whenever the code
  // changes, regardless of bucket. Cascades to attachments since they
  // bucket (and prefix) with the parent.
  if ((prev?.code ?? null) !== newCode) {
    await renameThumbsForCover(input.imageId, newCode).catch((e) => {
      console.error(`[saveCoverMeta] thumb rename failed for image ${input.imageId}:`, e);
    });
  }

  revalidatePath(`/image/${input.imageId}`);
  revalidatePath("/");
  return { ok: true };
}

/**
 * Rename the thumbnail file(s) for a cover and its attachments after the
 * cover's code changed. Embeds the new code in the filename via
 * canonicalThumbName(); updates `thumb_path` in the DB.
 */
async function renameThumbsForCover(imageId: number, newCode: string | null): Promise<void> {
  const rows = rawDb.prepare(`
    SELECT id, sha256, thumb_path FROM images
    WHERE id = ? OR parent_image_id = ?
  `).all(imageId, imageId) as Array<{ id: number; sha256: string; thumb_path: string }>;

  for (const row of rows) {
    const target = canonicalThumbName(newCode, row.sha256);
    if (target === row.thumb_path) continue;
    const oldAbs = safeJoin(THUMB_ROOT, row.thumb_path);
    const newAbs = path.join(THUMB_ROOT, target);
    if (oldAbs) {
      try {
        await fs.rename(oldAbs, newAbs);
      } catch {
        // Source missing or rename failed; leave thumb_path untouched
        // so the regenerator can pick it up.
        continue;
      }
    }
    rawDb.prepare(`UPDATE images SET thumb_path = ? WHERE id = ?`).run(target, row.id);
  }
}

/**
 * Move an image (and any attachments parented on it) into the given
 * bucket directory. Updates rel_path for each row to match the new
 * on-disk location. The thumb dir stays flat — only library/ files
 * are letter-bucketed.
 */
async function moveImageBucket(imageId: number, newBucketDir: string): Promise<void> {
  const targets = rawDb.prepare(`
    SELECT id, filename, rel_path FROM images
    WHERE id = ? OR parent_image_id = ?
  `).all(imageId, imageId) as Array<{ id: number; filename: string; rel_path: string }>;

  await fs.mkdir(path.join(LIBRARY_ROOT, newBucketDir), { recursive: true });

  for (const row of targets) {
    const oldAbs = safeJoin(LIBRARY_ROOT, row.rel_path);
    if (!oldAbs) continue;
    const currentDir = path.posix.dirname(row.rel_path.replace(/\\/g, "/"));
    if (currentDir === newBucketDir) continue; // already in place
    const { base, ext } = sanitizeFilename(row.filename || path.basename(row.rel_path));
    const newAbs = await uniqueFilePath(path.join(LIBRARY_ROOT, newBucketDir), base, ext);
    // uniqueFilePath reserves the slot by creating a 0-byte file via wx.
    // On Windows fs.rename() fails when the destination exists, so we
    // unlink the placeholder right before the rename. Tiny race window
    // is acceptable — single-process server actions, not concurrent uploads.
    await fs.rm(newAbs, { force: true }).catch(() => {});
    try {
      await fs.rename(oldAbs, newAbs);
    } catch {
      // Source missing or rename failed; skip this row.
      continue;
    }
    const newRel = path.posix.join(newBucketDir, path.basename(newAbs));
    rawDb.prepare(`UPDATE images SET rel_path = ? WHERE id = ?`).run(newRel, row.id);
  }
}

/** Revalidate every entity index that lists covers. Toggling a flag can
 *  change visibility under any of these (filters by VIP/Favorite/Owned/
 *  Watched are common across listings). Mirrors trash.ts's revalidate(). */
function revalidateAllCoverIndexes(imageId: number): void {
  revalidatePath(`/image/${imageId}`);
  revalidatePath("/");
  revalidatePath("/collection");
  revalidatePath("/tag");
  revalidatePath("/actress");
  revalidatePath("/studios");
  revalidatePath("/series");
  revalidatePath("/genres");
  revalidatePath("/labels");
}

export async function setWatched(imageId: number, watched: boolean): Promise<void> {
  rawDb.prepare(`UPDATE images SET watched = ? WHERE id = ?`).run(watched ? 1 : 0, imageId);
  revalidateAllCoverIndexes(imageId);
}

export async function setCoverVip(imageId: number, vip: boolean): Promise<void> {
  // VIP and Favorite are mutually exclusive — turning one on clears the other.
  if (vip) {
    rawDb.prepare(`UPDATE images SET is_vip = 1, is_favorite = 0 WHERE id = ?`).run(imageId);
  } else {
    rawDb.prepare(`UPDATE images SET is_vip = 0 WHERE id = ?`).run(imageId);
  }
  revalidateAllCoverIndexes(imageId);
}

export async function setCoverFavorite(imageId: number, favorite: boolean): Promise<void> {
  if (favorite) {
    rawDb.prepare(`UPDATE images SET is_favorite = 1, is_vip = 0 WHERE id = ?`).run(imageId);
  } else {
    rawDb.prepare(`UPDATE images SET is_favorite = 0 WHERE id = ?`).run(imageId);
  }
  revalidateAllCoverIndexes(imageId);
}

export async function setRating(imageId: number, rating: number | null): Promise<void> {
  let v: number | null = null;
  if (rating != null && Number.isFinite(rating)) {
    v = Math.max(0, Math.min(5, Math.round(rating)));
  }
  rawDb.prepare(`UPDATE images SET rating = ? WHERE id = ?`).run(v, imageId);
  revalidateAllCoverIndexes(imageId);
}

export async function setCoverOwned(imageId: number, owned: boolean): Promise<void> {
  rawDb.prepare(`UPDATE images SET is_owned = ? WHERE id = ?`).run(owned ? 1 : 0, imageId);
  revalidateAllCoverIndexes(imageId);
}

function norm(v: string | null): string | null {
  if (v == null) return null;
  const t = v.trim();
  return t === "" ? null : t;
}

function normalizeCoverCode(v: string | null): string | null {
  const t = norm(v);
  if (!t) return null;
  const normalized = normalizeCode(t);
  if (normalized) return normalized;
  const safe = t.toUpperCase().replace(/[^A-Z0-9-]/g, "");
  return safe || null;
}

function dedupeNames(names: string[]): string[] {
  const seen = new Set<string>();
  const out: string[] = [];
  for (const raw of names) {
    const t = raw.trim();
    if (!t) continue;
    const key = t.toLowerCase();
    if (seen.has(key)) continue;
    seen.add(key);
    out.push(t);
  }
  return out;
}