import express from 'express';
import { Queue } from 'bullmq';
import { v4 as uuidv4 } from 'uuid';
import { promises as fs } from 'node:fs';
import path from 'node:path';
import pool from '../db/pool.js';
import { getSignedUrlForObject, deleteObject, s3Client, getS3Bucket } from '../s3/client.js';
import { GetObjectCommand } from '@aws-sdk/client-s3';
import { requireAuth } from '../middleware/auth.js';

const router = express.Router();

router.use(requireAuth);

// BullMQ queue connection (mirrors worker/src/index.js)
const parseRedisUrl = (url) => {
  const parsed = new URL(url);
  return { host: parsed.hostname, port: parseInt(parsed.port, 10) };
};

const proxyQueue = new Queue('proxy', {
  connection: parseRedisUrl(process.env.REDIS_URL || 'redis://queue:6379'),
});

const thumbnailQueue = new Queue('thumbnail', {
  connection: parseRedisUrl(process.env.REDIS_URL || 'redis://queue:6379'),
});

// GET / - List assets with filtering
router.get('/', async (req, res, next) => {
  try {
    const {
      project_id,
      bin_id,
      status,
      search,
      media_type,
      limit = 50,
      offset = 0,
      include_archived,
    } = req.query;

    let query = `
      SELECT a.*,
             COUNT(*) OVER() AS full_count
      FROM assets a
      WHERE 1=1
    `;
    const params = [];
    let paramCount = 1;

    if (!status && include_archived !== 'true') {
      query += ` AND a.status <> 'archived'`;
    }

    if (project_id) {
      query += ` AND a.project_id = $${paramCount++}`;
      params.push(project_id);
    }

    if (bin_id) {
      query += ` AND a.bin_id = $${paramCount++}`;
      params.push(bin_id);
    }

    if (status) {
      query += ` AND a.status = $${paramCount++}`;
      params.push(status);
    }

    if (media_type) {
      query += ` AND a.media_type = $${paramCount++}`;
      params.push(media_type);
    }

    if (search) {
      query += ` AND (a.display_name ILIKE $${paramCount} OR a.filename ILIKE $${paramCount} OR a.notes ILIKE $${paramCount})`;
      params.push(`%${search}%`);
      paramCount++;
    }

    query += ` ORDER BY a.created_at DESC`;
    query += ` LIMIT $${paramCount++} OFFSET $${paramCount++}`;
    params.push(limit, offset);

    const result = await pool.query(query, params);
    const total = result.rows.length > 0 ? parseInt(result.rows[0].full_count, 10) : 0;

    res.json({
      assets: result.rows.map(({ full_count, ...rest }) => rest),
      total,
    });
  } catch (err) {
    next(err);
  }
});

// POST / - Register a new asset from a completed capture session
router.post('/', async (req, res, next) => {
  try {
    const {
      projectId,
      binId,
      clipName,
      hiresKey,
      proxyKey,
      duration,
      capturedAt,
    } = req.body;

    if (!projectId || !clipName) {
      return res.status(400).json({ error: 'projectId and clipName are required' });
    }

    const durationMs = duration ? Math.round(duration * 1000) : null;

    const existing = await pool.query(
      `SELECT * FROM assets
         WHERE project_id = $1 AND display_name = $2 AND status = 'live'
         ORDER BY created_at DESC LIMIT 1`,
      [projectId, clipName]
    );

    let id;
    let asset;
    if (existing.rows.length > 0) {
      id = existing.rows[0].id;
      const upd = await pool.query(
        `UPDATE assets
           SET status          = 'processing',
               original_s3_key = COALESCE($2, original_s3_key),
               proxy_s3_key    = COALESCE($3, proxy_s3_key),
               duration_ms     = COALESCE($4, duration_ms),
               bin_id          = COALESCE(bin_id, $5),
               updated_at      = NOW()
         WHERE id = $1
         RETURNING *`,
        [id, hiresKey || null, proxyKey || null, durationMs, binId || null]
      );
      asset = upd.rows[0];
    } else {
      id = uuidv4();
      const ins = await pool.query(
        `INSERT INTO assets (
          id, project_id, bin_id,
          filename, display_name,
          status, media_type,
          original_s3_key, proxy_s3_key,
          duration_ms,
          created_at, updated_at
        )
        VALUES (
          $1, $2, $3,
          $4, $4,
          'processing', 'video',
          $5, $6,
          $7,
          COALESCE($8::timestamptz, NOW()), NOW()
        )
        RETURNING *`,
        [
          id, projectId, binId || null,
          clipName,
          hiresKey || null, proxyKey || null,
          durationMs,
          capturedAt || null,
        ]
      );
      asset = ins.rows[0];
    }

    const thumbnailKey = `thumbnails/${id}.jpg`;

    if (proxyKey) {
      // Capture already produced a proxy — queue thumbnail off the proxy.
      await thumbnailQueue.add('generate', {
        assetId: id,
        proxyKey,
        outputKey: thumbnailKey,
      });
    } else if (asset.original_s3_key) {
      // No proxy yet but we have a hi-res master in S3 — queue proxy
      // generation. The proxy worker flips the asset to 'ready' on success
      // and dispatches the thumbnail itself once the proxy lands.
      const generatedProxyKey = `proxies/${id}.mp4`;
      await proxyQueue.add('generate', {
        assetId: id,
        inputKey:  asset.original_s3_key,
        outputKey: generatedProxyKey,
      });
      console.log(`[assets] queued proxy for ${id} (${asset.display_name})`);
    } else {
      // Nothing to transcode — mark ready so it isn't stuck at 'processing'.
      // The shutdown POST path with no hires/proxy lands here (rare, but legal).
      await pool.query(
        `UPDATE assets SET status = 'ready', updated_at = NOW() WHERE id = $1`,
        [id]
      );
      asset.status = 'ready';
    }

    res.status(existing.rows.length > 0 ? 200 : 201).json(asset);
  } catch (err) {
    next(err);
  }
});

// POST /cleanup-live
router.post('/cleanup-live', async (req, res, next) => {
  try {
    const maxAgeHours = Math.max(1, parseInt(req.query.max_age_hours || '4', 10));
    const result = await pool.query(
      `UPDATE assets
         SET status = 'error', updated_at = NOW()
       WHERE status = 'live'
         AND created_at < NOW() - ($1 * INTERVAL '1 hour')
       RETURNING id, display_name, project_id, created_at`,
      [maxAgeHours]
    );
    res.json({ cleaned: result.rowCount, assets: result.rows });
  } catch (err) {
    next(err);
  }
});

// POST /cleanup-live-orphans
// Reaps /live/<uuid>/ directories that have no matching asset row in the DB.
// These accumulate when a recorder crashes mid-capture or when an asset row
// is deleted after the HLS dir was created. Closes part of #7.
router.post('/cleanup-live-orphans', async (_req, res, next) => {
  try {
    const liveRoot = process.env.LIVE_DIR || '/live';
    let entries;
    try {
      entries = await fs.readdir(liveRoot, { withFileTypes: true });
    } catch (err) {
      if (err.code === 'ENOENT') return res.json({ reaped: 0, kept: 0, dirs: [] });
      throw err;
    }
    const uuidRe = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

    const dirIds = entries
      .filter(e => e.isDirectory() && uuidRe.test(e.name))
      .map(e => e.name);

    if (dirIds.length === 0) return res.json({ reaped: 0, kept: 0, dirs: [] });

    // Find which of those UUIDs correspond to live or in-flight assets.
    // We keep dirs that match ANY asset row (regardless of status) so that
    // an archived asset's HLS scrubber isn't yanked out from under it.
    const known = await pool.query(
      'SELECT id FROM assets WHERE id = ANY($1::uuid[])',
      [dirIds]
    );
    const keep = new Set(known.rows.map(r => r.id));

    const reaped = [];
    const kept = [];
    for (const id of dirIds) {
      if (keep.has(id)) { kept.push(id); continue; }
      const fullPath = path.join(liveRoot, id);
      try {
        await fs.rm(fullPath, { recursive: true, force: true });
        reaped.push(id);
        console.log(`[assets] reaped orphan live dir ${fullPath}`);
      } catch (err) {
        console.warn(`[assets] failed to reap ${fullPath}: ${err.message}`);
      }
    }

    res.json({ reaped: reaped.length, kept: kept.length, dirs: reaped });
  } catch (err) {
    next(err);
  }
});

// GET /:id
router.get('/:id', async (req, res, next) => {
  try {
    const { id } = req.params;
    const result = await pool.query('SELECT * FROM assets WHERE id = $1', [id]);
    if (result.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    res.json(result.rows[0]);
  } catch (err) {
    next(err);
  }
});

// PATCH /:id
router.patch('/:id', async (req, res, next) => {
  try {
    const { id } = req.params;
    const { display_name, tags, notes, bin_id } = req.body;

    const updates = [];
    const params = [];
    let paramCount = 1;

    if (display_name !== undefined) { updates.push(`display_name = $${paramCount++}`); params.push(display_name); }
    if (tags        !== undefined) { updates.push(`tags = $${paramCount++}`);         params.push(tags); }
    if (notes       !== undefined) { updates.push(`notes = $${paramCount++}`);        params.push(notes); }
    if (bin_id      !== undefined) { updates.push(`bin_id = $${paramCount++}`);       params.push(bin_id || null); }

    if (updates.length === 0) return res.status(400).json({ error: 'No fields to update' });

    updates.push(`updated_at = NOW()`);
    params.push(id);

    const result = await pool.query(
      `UPDATE assets SET ${updates.join(', ')} WHERE id = $${paramCount} RETURNING *`,
      params
    );
    if (result.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    res.json(result.rows[0]);
  } catch (err) {
    next(err);
  }
});

// POST /:id/copy
router.post('/:id/copy', async (req, res, next) => {
  try {
    const { id } = req.params;
    const { binId, projectId } = req.body;
    const r = await pool.query('SELECT * FROM assets WHERE id = $1', [id]);
    if (r.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    const src = r.rows[0];
    const newId = uuidv4();
    const ins = await pool.query(
      `INSERT INTO assets (
        id, project_id, bin_id, filename, display_name,
        status, media_type, original_s3_key, proxy_s3_key, thumbnail_s3_key,
        codec, resolution, fps, duration_ms, start_tc, file_size, tags, notes,
        created_at, updated_at
      ) VALUES (
        $1, $2, $3, $4, $5,
        $6, $7, $8, $9, $10,
        $11, $12, $13, $14, $15, $16, $17, $18,
        NOW(), NOW()
      ) RETURNING *`,
      [
        newId,
        projectId || src.project_id,
        binId === undefined ? src.bin_id : (binId || null),
        src.filename, src.display_name,
        src.status, src.media_type,
        src.original_s3_key, src.proxy_s3_key, src.thumbnail_s3_key,
        src.codec, src.resolution, src.fps, src.duration_ms, src.start_tc,
        src.file_size, src.tags, src.notes,
      ]
    );
    res.status(201).json(ins.rows[0]);
  } catch (err) {
    next(err);
  }
});

// POST /:id/mark-empty — flag a pre-created live asset as 'error' because
// the recorder finished a session without any frames (bad source URL, dead
// SDI signal, etc.). Called by the capture sidecar's shutdown handler.
router.post('/:id/mark-empty', async (req, res, next) => {
  try {
    const { id } = req.params;
    const result = await pool.query(
      `UPDATE assets
         SET status = 'error',
             notes  = COALESCE(notes || E'\\n', '') || 'Recording produced no frames — source never connected.',
             updated_at = NOW()
       WHERE id = $1 AND status = 'live'
       RETURNING id`,
      [id]
    );
    if (result.rows.length === 0) return res.status(404).json({ error: 'No matching live asset' });
    res.json({ id });
  } catch (err) { next(err); }
});

// POST /:id/generate-proxy — re-queue proxy for an asset that has a hi-res
// master but no proxy_s3_key. Used to backfill recorder-captured clips that
// pre-date the auto-proxy-on-finalize fix.
router.post('/:id/generate-proxy', async (req, res, next) => {
  try {
    const { id } = req.params;
    const r = await pool.query('SELECT * FROM assets WHERE id = $1', [id]);
    if (r.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    const asset = r.rows[0];
    if (!asset.original_s3_key) return res.status(400).json({ error: 'Asset has no hi-res source to proxy from' });
    const proxyKey = asset.proxy_s3_key || `proxies/${id}.mp4`;
    await proxyQueue.add('generate', { assetId: id, inputKey: asset.original_s3_key, outputKey: proxyKey });
    const updated = await pool.query(
      `UPDATE assets SET status = 'processing', updated_at = NOW() WHERE id = $1 RETURNING *`,
      [id]
    );
    res.json(updated.rows[0]);
  } catch (err) { next(err); }
});

// POST /backfill-proxies — admin: queue proxy generation for every 'ready'
// asset that has a hi-res but no proxy. One-shot maintenance for clips
// captured before the auto-queue-on-finalize fix.
router.post('/backfill-proxies', async (_req, res, next) => {
  try {
    const targets = await pool.query(
      `SELECT id, original_s3_key FROM assets
       WHERE status = 'ready'
         AND original_s3_key IS NOT NULL
         AND (proxy_s3_key IS NULL OR proxy_s3_key = '')
       ORDER BY created_at DESC`
    );
    for (const asset of targets.rows) {
      const proxyKey = `proxies/${asset.id}.mp4`;
      await proxyQueue.add('generate', {
        assetId: asset.id, inputKey: asset.original_s3_key, outputKey: proxyKey,
      });
    }
    if (targets.rows.length > 0) {
      await pool.query(
        `UPDATE assets SET status = 'processing', updated_at = NOW()
         WHERE id = ANY($1)`,
        [targets.rows.map(r => r.id)]
      );
    }
    res.json({ queued: targets.rows.length });
  } catch (err) { next(err); }
});

// POST /:id/retry — re-queue the proxy job.
//
// Originally this only fired for status='error', which meant an archived or
// 'ready'-but-proxy-less asset (e.g. an old recorder capture that never got
// a browser-playable proxy) had no way back. Now we also accept assets that
// have a hi-res source but no proxy_s3_key, regardless of status — the UI
// uses this as the user-facing "Generate proxy" action.
router.post('/:id/retry', async (req, res, next) => {
  try {
    const { id } = req.params;
    const r = await pool.query('SELECT * FROM assets WHERE id = $1', [id]);
    if (r.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    const asset = r.rows[0];
    if (!asset.original_s3_key) {
      return res.status(400).json({ error: 'Asset has no source file to reprocess' });
    }
    const canRetry =
      asset.status === 'error' ||
      !asset.proxy_s3_key; // works for 'ready' or 'archived' that lost / never had a proxy
    if (!canRetry) {
      return res.status(400).json({
        error: `Nothing to retry — asset is ${asset.status} and already has a proxy.`,
      });
    }
    const proxyKey = asset.proxy_s3_key || `proxies/${id}.mp4`;
    await proxyQueue.add('generate', { assetId: id, inputKey: asset.original_s3_key, outputKey: proxyKey });
    const updated = await pool.query(
      `UPDATE assets SET status = 'processing', updated_at = NOW() WHERE id = $1 RETURNING *`,
      [id]
    );
    res.json(updated.rows[0]);
  } catch (err) {
    next(err);
  }
});

// DELETE /:id
router.delete('/:id', async (req, res, next) => {
  try {
    const { id } = req.params;
    const { hard } = req.query;
    if (hard === 'true') {
      const assetResult = await pool.query('SELECT * FROM assets WHERE id = $1', [id]);
      if (assetResult.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
      const asset = assetResult.rows[0];
      if (asset.proxy_s3_key)     await deleteObject(asset.proxy_s3_key);
      if (asset.thumbnail_s3_key) await deleteObject(asset.thumbnail_s3_key);
      if (asset.original_s3_key)  await deleteObject(asset.original_s3_key);
      await pool.query('DELETE FROM assets WHERE id = $1', [id]);
      res.json({ message: 'Asset deleted permanently' });
    } else {
      const result = await pool.query(
        `UPDATE assets SET status = 'archived', updated_at = NOW() WHERE id = $1 RETURNING *`,
        [id]
      );
      if (result.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
      res.json(result.rows[0]);
    }
  } catch (err) {
    next(err);
  }
});

// GET /:id/stream
router.get('/:id/stream', async (req, res, next) => {
  try {
    const { id } = req.params;
    const r = await pool.query('SELECT * FROM assets WHERE id = $1', [id]);
    if (r.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    const a = r.rows[0];
    if (a.status === 'live') return res.json({ url: `/live/${a.id}/index.m3u8`, type: 'hls', live: true });
    if (a.proxy_s3_key) return res.json({ url: `/api/v1/assets/${id}/video`, type: 'mp4' });
    const orig = a.original_s3_key;
    if (orig && orig.toLowerCase().endsWith('.mp4')) return res.json({ url: `/api/v1/assets/${id}/video`, type: 'mp4' });
    // No browser-playable source — let the UI surface a "Generate proxy"
    // CTA. has_source tells the UI whether retry is even possible.
    return res.json({
      url: null,
      type: null,
      reason: 'no_proxy',
      has_source: !!a.original_s3_key,
    });
  } catch (err) {
    next(err);
  }
});

// GET /:id/live-path
// Returns the SMB UNC path of a live (growing) asset so the Premiere panel
// can mount the file in place rather than downloading a proxy first.
// Editors mount the SMB share once; the panel passes individual file paths.
router.get('/:id/live-path', async (req, res, next) => {
  try {
    const { id } = req.params;
    const a = await pool.query(
      'SELECT id, project_id, display_name, status FROM assets WHERE id = $1',
      [id]
    );
    if (a.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    const asset = a.rows[0];

    if (asset.status !== 'live') {
      return res.status(409).json({ error: 'Asset is not currently growing', status: asset.status });
    }

    const s = await pool.query(
      `SELECT key, value FROM settings
       WHERE key IN ('growing_enabled', 'growing_smb_url')`
    );
    const cfg = {};
    for (const { key, value } of s.rows) cfg[key] = value;
    if (cfg.growing_enabled !== 'true') {
      return res.status(409).json({ error: 'Growing-files mode is disabled' });
    }
    if (!cfg.growing_smb_url) {
      return res.status(409).json({ error: 'No SMB URL configured — set growing_smb_url in Settings' });
    }

    // Find the recorder driving this asset so we know the right file extension.
    const rec = await pool.query(
      `SELECT recording_container FROM recorders
       WHERE current_session_id = $1
       ORDER BY updated_at DESC LIMIT 1`,
      [asset.display_name]
    );
    const ext = rec.rows[0]?.recording_container || 'mov';

    const smbRoot = cfg.growing_smb_url.replace(/\/+$/, '');
    const winPath = smbRoot.replace(/^smb:\/\//, '\\\\').replace(/\//g, '\\') +
                    `\\${asset.project_id}\\${asset.display_name}.${ext}`;
    const posix   = smbRoot.replace(/^smb:\/\//, '//') +
                    `/${asset.project_id}/${asset.display_name}.${ext}`;
    res.json({
      smb_url:  `${smbRoot}/${asset.project_id}/${asset.display_name}.${ext}`,
      win_path: winPath,
      posix_path: posix,
      project_id: asset.project_id,
      display_name: asset.display_name,
      ext,
    });
  } catch (err) {
    next(err);
  }
});

// GET /:id/video
router.get('/:id/video', async (req, res, next) => {
  try {
    const { id } = req.params;
    const r = await pool.query('SELECT proxy_s3_key, original_s3_key FROM assets WHERE id = $1', [id]);
    if (r.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    const a = r.rows[0];
    const key = a.proxy_s3_key || (a.original_s3_key?.toLowerCase().endsWith('.mp4') ? a.original_s3_key : null);
    if (!key) return res.status(404).json({ error: 'No browser-playable source' });
    const params = { Bucket: getS3Bucket(), Key: key };
    const rangeHeader = req.headers.range;
    if (rangeHeader) params.Range = rangeHeader;
    const s3Res = await s3Client.send(new GetObjectCommand(params));
    const status = rangeHeader ? 206 : 200;
    const headers = { 'Content-Type': 'video/mp4', 'Accept-Ranges': 'bytes', 'Cache-Control': 'no-store' };
    if (s3Res.ContentLength) headers['Content-Length'] = String(s3Res.ContentLength);
    if (s3Res.ContentRange)  headers['Content-Range']  = s3Res.ContentRange;
    res.writeHead(status, headers);
    s3Res.Body.pipe(res);
  } catch (err) { next(err); }
});

// GET /:id/hires
router.get('/:id/hires', async (req, res, next) => {
  try {
    const { id } = req.params;
    const r = await pool.query(
      'SELECT original_s3_key, filename, display_name, file_size FROM assets WHERE id = $1',
      [id]
    );
    if (r.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    const a = r.rows[0];
    if (!a.original_s3_key) return res.status(404).json({ error: 'No hi-res source available' });
    const url   = await getSignedUrlForObject(a.original_s3_key);
    const parts = a.original_s3_key.split('.');
    const ext   = (parts.length > 1 ? parts[parts.length - 1] : 'mxf').toLowerCase();
    const base  = (a.display_name || a.filename || id).replace(/[^\w.-]/g, '_').substring(0, 100);
    res.json({ url, filename: `${base}.${ext}`, ext, file_size: a.file_size || null, type: 'hires' });
  } catch (err) { next(err); }
});

// GET /:id/thumbnail
router.get('/:id/thumbnail', async (req, res, next) => {
  try {
    const { id } = req.params;
    const result = await pool.query('SELECT thumbnail_s3_key FROM assets WHERE id = $1', [id]);
    if (result.rows.length === 0) return res.status(404).json({ error: 'Asset not found' });
    const { thumbnail_s3_key } = result.rows[0];
    if (!thumbnail_s3_key) return res.status(404).json({ error: 'Thumbnail not yet available' });
    const url = await getSignedUrlForObject(thumbnail_s3_key);
    if (req.query.redirect === '1') return res.redirect(302, url);
    res.json({ url });
  } catch (err) {
    next(err);
  }
});

export default router;
