/**
 * Soundtrack A/B candidate generation + selection.
 *
 * `generateSoundtrackCandidates` runs each AVAILABLE music backend (from the
 * audio-platform registry, optionally filtered by `backendIds`) for a project,
 * writes each candidate to `projects/<slug>/artifacts/audio/soundtrack-<backendId>.mp3`,
 * and persists a `soundtrack.json` artifact listing every candidate. A human can
 * then compare them in the preview portal and pick one.
 *
 * `selectSoundtrack` marks one candidate as `selected` in `soundtrack.json` AND
 * writes its path into the project manifest `soundtrack` field, which the
 * preview portal's discovery (preview-portal/discovery.ts) reads to render the
 * headline `<audio>` player.
 *
 * Pure-ish: `env` and `fetcher` are threaded through to the backends so tests
 * run fully offline with no real keys or network. If only a single backend is
 * available, generation still produces one candidate (no hard failure).
 */

import { mkdir, readFile, writeFile } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import { dirname, join, relative, resolve } from 'node:path';
import { resolveProjectWorkspace, updateProjectManifestSoundtrack } from './workspace.js';
import { appendProjectEvent } from './events.js';
import { writeTextFileAtomic } from './atomic-write.js';
import { VclawError } from './errors.js';
import {
  getMusicBackend,
  listAvailableMusicBackends,
} from './audio-platform/registry.js';
import type { MusicBackend } from './audio-platform/types.js';

export const SOUNDTRACK_SCHEMA_VERSION = 1;

export interface SoundtrackCandidate {
  backendId: string;
  /** Project-relative path to the generated candidate audio. */
  path: string;
  durationMs: number;
  prompt: string;
}

export interface SoundtrackArtifact {
  schemaVersion: typeof SOUNDTRACK_SCHEMA_VERSION;
  projectSlug: string;
  generatedAt: string;
  candidates: SoundtrackCandidate[];
  /** backendId of the human-selected candidate, if any. */
  selected?: string;
}

export interface GenerateSoundtrackCandidatesOptions {
  workspaceRoot: string;
  slug: string;
  prompt: string;
  durationSec?: number;
  /** Restrict to these backend ids (defaults to all AVAILABLE backends). */
  backendIds?: string[];
  /**
   * User-supplied lyrics ([Verse]/[Chorus]-tagged). Threaded to backends that
   * support vocal songs (FlowMusic); ignored by instrumental-only backends.
   */
  lyrics?: string;
  /** Force an instrumental render (FlowMusic only; other backends ignore it). */
  instrumental?: boolean;
  dryRun?: boolean;
  env?: NodeJS.ProcessEnv;
  fetcher?: typeof fetch;
}

export function soundtrackArtifactPathFor(root: string, slug: string): string {
  return join(resolveProjectWorkspace(slug, root).projectDir, 'artifacts', 'soundtrack.json');
}

export function soundtrackAudioDirFor(root: string, slug: string): string {
  return join(resolveProjectWorkspace(slug, root).projectDir, 'artifacts', 'audio');
}

export async function readSoundtrackArtifact(
  root: string,
  slug: string,
): Promise<SoundtrackArtifact | null> {
  const path = soundtrackArtifactPathFor(root, slug);
  if (!existsSync(path)) return null;
  return JSON.parse(await readFile(path, 'utf-8')) as SoundtrackArtifact;
}

async function writeSoundtrackArtifact(
  root: string,
  slug: string,
  artifact: SoundtrackArtifact,
): Promise<string> {
  const path = soundtrackArtifactPathFor(root, slug);
  await mkdir(dirname(path), { recursive: true });
  await writeTextFileAtomic(path, `${JSON.stringify(artifact, null, 2)}\n`);
  return path;
}

/**
 * Resolve which backends to run. When `backendIds` is given, each is looked up
 * by id (throws on unknown) and gated on availability; otherwise all currently
 * available backends are used.
 */
function resolveBackends(
  backendIds: string[] | undefined,
  available: MusicBackend[],
): MusicBackend[] {
  if (!backendIds || backendIds.length === 0) return available;
  const availableIds = new Set(available.map((b) => b.id));
  const out: MusicBackend[] = [];
  for (const id of backendIds) {
    const backend = getMusicBackend(id); // throws on unknown id
    if (!availableIds.has(backend.id)) continue; // skip unavailable (no creds)
    out.push(backend);
  }
  return out;
}

/**
 * Generate one soundtrack candidate per available music backend and persist the
 * `soundtrack.json` artifact. Returns the written artifact. Throws
 * `soundtrack_no_backend` when no requested/available backend can run.
 */
export async function generateSoundtrackCandidates(
  options: GenerateSoundtrackCandidatesOptions,
): Promise<SoundtrackArtifact> {
  const { workspaceRoot, slug, prompt } = options;
  const env = options.env ?? process.env;

  if (!prompt.trim()) {
    throw new VclawError('music_gen_failed', 'Cannot generate a soundtrack with an empty prompt.', {
      slug,
    });
  }

  const available = listAvailableMusicBackends(env);
  const backends = resolveBackends(options.backendIds, available);
  if (backends.length === 0) {
    throw new VclawError(
      'soundtrack_no_backend',
      'No music backend is available. Set credentials for at least one (e.g. KIE_API_KEY for Suno) or pass a backend that is configured.',
      {
        slug,
        requested: options.backendIds ?? null,
        available: available.map((b) => b.id),
      },
    );
  }

  const workspace = resolveProjectWorkspace(slug, workspaceRoot);
  const projectRoot = resolve(workspace.projectDir);
  const audioDir = soundtrackAudioDirFor(workspaceRoot, slug);
  await mkdir(audioDir, { recursive: true });

  const candidates: SoundtrackCandidate[] = [];
  for (const backend of backends) {
    const outputPath = join(audioDir, `soundtrack-${backend.id}.mp3`);
    const result = await backend.generate({
      prompt,
      ...(options.durationSec !== undefined ? { durationSec: options.durationSec } : {}),
      outputPath,
      ...(options.lyrics !== undefined ? { lyrics: options.lyrics } : {}),
      ...(options.instrumental !== undefined ? { instrumental: options.instrumental } : {}),
      ...(options.dryRun !== undefined ? { dryRun: options.dryRun } : {}),
      env,
      ...(options.fetcher ? { fetcher: options.fetcher } : {}),
    });
    // In dry-run the backends return a path without writing audio. Write a
    // placeholder so the artifact stays consistent with disk (preview-portal
    // discovery guards every candidate with existsSync, so otherwise a fully
    // populated soundtrack.json would render zero players).
    if (options.dryRun && !existsSync(result.path)) {
      await mkdir(dirname(result.path), { recursive: true });
      await writeFile(result.path, Buffer.alloc(0));
    }
    const rel = relative(projectRoot, resolve(result.path)).replaceAll('\\', '/');
    candidates.push({
      backendId: result.backendId,
      path: rel,
      durationMs: result.durationMs,
      prompt,
    });
  }

  // Preserve a prior selection if its backend is still among the candidates.
  const prior = await readSoundtrackArtifact(workspaceRoot, slug);
  const selected =
    prior?.selected && candidates.some((c) => c.backendId === prior.selected)
      ? prior.selected
      : undefined;

  const artifact: SoundtrackArtifact = {
    schemaVersion: SOUNDTRACK_SCHEMA_VERSION,
    projectSlug: slug,
    generatedAt: new Date().toISOString(),
    candidates,
    ...(selected ? { selected } : {}),
  };
  await writeSoundtrackArtifact(workspaceRoot, slug, artifact);

  if (existsSync(workspace.eventsPath) || existsSync(workspace.eventsDir)) {
    await appendProjectEvent(workspace, {
      type: 'soundtrack.candidates.generated',
      payload: {
        backends: candidates.map((c) => c.backendId),
        dryRun: options.dryRun ?? false,
      },
    });
  }

  return artifact;
}

/**
 * Mark `backendId` as the selected soundtrack candidate: sets
 * `soundtrack.json.selected` AND writes the candidate's path into the project
 * manifest `soundtrack` field (read by the preview portal). Throws when the
 * artifact is missing or the backend is not among the candidates.
 */
export async function selectSoundtrack(
  workspaceRoot: string,
  slug: string,
  backendId: string,
): Promise<{ artifact: SoundtrackArtifact; manifestSoundtrack: string }> {
  const artifact = await readSoundtrackArtifact(workspaceRoot, slug);
  if (!artifact) {
    throw new VclawError(
      'asset_not_found',
      `No soundtrack.json for ${slug}. Run \`vclaw video soundtrack --project ${slug} --prompt "..."\` first.`,
      { slug },
    );
  }
  const candidate = artifact.candidates.find((c) => c.backendId === backendId);
  if (!candidate) {
    throw new VclawError(
      'asset_not_found',
      `No soundtrack candidate for backend '${backendId}'. Available: ${artifact.candidates.map((c) => c.backendId).join(', ') || '(none)'}.`,
      { slug, backendId, available: artifact.candidates.map((c) => c.backendId) },
    );
  }

  const updated: SoundtrackArtifact = { ...artifact, selected: backendId };
  await writeSoundtrackArtifact(workspaceRoot, slug, updated);

  const workspace = resolveProjectWorkspace(slug, workspaceRoot);
  // Manifest soundtrack path is project-relative (matches discovery's resolver).
  await updateProjectManifestSoundtrack(workspace, candidate.path);

  if (existsSync(workspace.eventsPath) || existsSync(workspace.eventsDir)) {
    await appendProjectEvent(workspace, {
      type: 'soundtrack.selected',
      payload: { backendId, path: candidate.path },
    });
  }

  return { artifact: updated, manifestSoundtrack: candidate.path };
}