import { join } from 'path';
import { unlink } from 'fs/promises';
import { tmpdir } from 'os';
import { Queue } from 'bullmq';
import { query } from '../db/client.js';
import { downloadFromS3, uploadToS3 } from '../s3/client.js';
import { extractFrameAtTime, getMediaDuration } from '../ffmpeg/executor.js';

const parseRedisUrl = (url) => {
  try { const p = new URL(url); return { host: p.hostname, port: parseInt(p.port, 10) || 6379 }; }
  catch { return { host: 'localhost', port: 6379 }; }
};
const filmstripQueue = new Queue('filmstrip', {
  connection: parseRedisUrl(process.env.REDIS_URL || 'redis://queue:6379'),
});

const S3_BUCKET = process.env.S3_BUCKET || 'wild-dragon';

/**
 * Pick a seek time that won't exceed the clip duration.
 * Tries 5s first, then 1s, then 0s as a last resort.
 */
async function pickSeekTime(inputPath) {
  try {
    const duration = await getMediaDuration(inputPath);
    if (duration >= 5) return '00:00:05';
    if (duration >= 1) return '00:00:01';
    return '00:00:00';
  } catch {
    // If ffprobe fails, fall back to 5s and let ffmpeg handle it
    return '00:00:05';
  }
}

export const thumbnailWorker = async (job) => {
  const { assetId, proxyKey, outputKey } = job.data;

  const tmpDir = tmpdir();
  const inputPath  = join(tmpDir, `thumb-input-${job.id}.mp4`);
  const outputPath = join(tmpDir, `thumb-output-${job.id}.jpg`);

  try {
    // Check asset status before doing any work
    const assetRow = await query(
      'SELECT status FROM assets WHERE id = $1',
      [assetId]
    );
    const asset = assetRow.rows[0];

    if (asset?.status === 'pending_migration') {
      console.log(`[thumbnail] asset ${assetId} is pending_migration, skipping`);
      return;
    }

    // Download proxy from S3
    await job.updateProgress(10);
    console.log(`[thumbnail] Downloading ${proxyKey} for asset ${assetId}`);
    await downloadFromS3(S3_BUCKET, proxyKey, inputPath);

    // Pick a safe seek time based on actual clip duration
    const seekTime = await pickSeekTime(inputPath);

    // Extract frame
    await job.updateProgress(40);
    console.log(`[thumbnail] Extracting frame at ${seekTime} for asset ${assetId}`);
    await extractFrameAtTime(inputPath, outputPath, seekTime);

    // Upload thumbnail to S3
    await job.updateProgress(70);
    console.log(`[thumbnail] Uploading to ${outputKey}`);
    await uploadToS3(S3_BUCKET, outputKey, outputPath);

    // Update asset: thumbnail key + mark ready
    await job.updateProgress(90);
    await query(
      `UPDATE assets
       SET thumbnail_s3_key = $1, status = 'ready', updated_at = NOW()
       WHERE id = $2`,
      [outputKey, assetId]
    );

    await job.updateProgress(100);
    console.log(`[thumbnail] Asset ${assetId} thumbnail complete → status=ready`);

    // Queue filmstrip generation now that the proxy is confirmed good
    await filmstripQueue.add('generate', { assetId, proxyKey }).catch(err => {
      console.warn(`[thumbnail] Failed to queue filmstrip for ${assetId}:`, err.message);
    });

    return { assetId, outputKey };
  } catch (error) {
    console.error(`[thumbnail] Error processing asset ${assetId}:`, error);
    // Thumbnail failed but the asset is still usable via proxy — mark it ready
    // so it doesn't stay in 'processing' state forever.
    await query(
      `UPDATE assets SET status = 'ready', updated_at = NOW() WHERE id = $1`,
      [assetId]
    ).catch(e => console.error('[thumbnail] Failed to update asset status:', e));
    throw error;
  } finally {
    await Promise.all([
      unlink(inputPath).catch(() => {}),
      unlink(outputPath).catch(() => {}),
    ]);
  }
};