Art-gallery/server/index.js

const express = require('express');
const cors = require('cors');
const path = require('path');
const fs = require('fs');
require('dotenv').config();

const pool = require('./db');
const { ensurePaintingImages, preloadArtistImagesLocal, replacePaintingImageFromUrl, IMAGE_DIR } = require('./image-service');
const { searchGoogleImagesFirst, fetchImageBuffer, pickExt } = require('../scripts/image-fetcher');

const app = express();
const PORT = process.env.PORT || 3001;

app.use(cors());
app.use(express.json());
app.use('/images', express.static(IMAGE_DIR));

const INFLUENCE_LINKS_EXISTS = `
  EXISTS (
    SELECT 1 FROM painting_influence_sources pis
    WHERE pis.painting_id = p.id OR pis.source_painting_id = p.id
  ) OR EXISTS (
    SELECT 1 FROM painting_influences pi
    WHERE pi.painting_id = p.id OR pi.influenced_by_painting_id = p.id
  )`;

const INFLUENCED_BY_SQL = `
  SELECT
    pis.source_type,
    pis.period_note,
    pis.period_start_year,
    pis.period_end_year,
    pis.notes,
    pis.source,
    pis.aspects,
    pis.quote,
    pis.source_author,
    pis.source_url,
    pis.confidence,
    pis.discovered_via,
    p.id,
    p.title,
    p.year,
    p.image_path,
    pa.name AS artist_name,
    pa.id AS artist_id,
    sa.id AS source_artist_id,
    sa.name AS source_artist_name,
    sa.portrait_path AS artist_portrait,
    m.id AS movement_id,
    m.name AS movement_name,
    m.color AS movement_color
  FROM painting_influence_sources pis
  LEFT JOIN paintings p ON pis.source_painting_id = p.id
  LEFT JOIN artists pa ON p.artist_id = pa.id
  LEFT JOIN artists sa ON pis.source_artist_id = sa.id
  LEFT JOIN art_movements m ON pis.source_movement_id = m.id
  WHERE pis.painting_id = $1
  ORDER BY
    CASE pis.source_type WHEN 'painting' THEN 1 WHEN 'artist' THEN 2 ELSE 3 END,
    COALESCE(p.year, pis.period_start_year) NULLS LAST`;
app.get('/api/timeline', async (req, res) => {
  try {
    const { start, end } = req.query;
    const startYear = parseInt(start) || -3000;
    const endYear = parseInt(end) || 2100;

    const [eras, movements] = await Promise.all([
      pool.query(
        `SELECT * FROM historical_eras
         WHERE end_year >= $1 AND start_year <= $2
         ORDER BY sort_order, start_year`,
        [startYear, endYear]
      ),
      pool.query(
        `SELECT DISTINCT m.*, e.name as era_name
         FROM art_movements m
         LEFT JOIN historical_eras e ON m.era_id = e.id
         INNER JOIN artists a ON a.movement_id = m.id
         WHERE m.end_year >= $1 AND m.start_year <= $2
           AND (a.death_year IS NULL OR a.death_year >= $1)
           AND (a.birth_year IS NULL OR a.birth_year <= $2)
         ORDER BY m.start_year`,
        [startYear, endYear]
      ),
    ]);

    res.json({ eras: eras.rows, movements: movements.rows });
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Failed to fetch timeline' });
  }
});

// Artists for a movement in a time range
app.get('/api/movements/:id/artists', async (req, res) => {
  try {
    const { id } = req.params;
    const result = await pool.query(
      `SELECT id, name, birth_year, death_year, portrait_path, bio_short
       FROM artists WHERE movement_id = $1
       ORDER BY birth_year`,
      [id]
    );
    res.json(result.rows);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Failed to fetch artists' });
  }
});

// All artists in a year range (for timeline portrait placement)
app.get('/api/artists', async (req, res) => {
  try {
    const { start, end, movement_id } = req.query;
    let query = `
      SELECT a.*, m.name as movement_name, m.color as movement_color
      FROM artists a
      LEFT JOIN art_movements m ON a.movement_id = m.id
      WHERE 1=1`;
    const params = [];

    if (start) {
      params.push(parseInt(start));
      query += ` AND (a.death_year IS NULL OR a.death_year >= $${params.length})`;
    }
    if (end) {
      params.push(parseInt(end));
      query += ` AND (a.birth_year IS NULL OR a.birth_year <= $${params.length})`;
    }
    if (movement_id) {
      params.push(parseInt(movement_id));
      query += ` AND a.movement_id = $${params.length}`;
    }

    query += ' ORDER BY a.birth_year';
    const result = await pool.query(query, params);
    res.json(result.rows);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Failed to fetch artists' });
  }
});

// Artist detail with periods and paintings
app.get('/api/artists/:id/navigation', async (req, res) => {
  try {
    const artistId = parseInt(req.params.id, 10);

    const groupByMovement = (rows) => {
      const map = new Map();
      for (const row of rows) {
        const key = row.movement_id ?? 0;
        if (!map.has(key)) {
          map.set(key, {
            movement_id: row.movement_id,
            movement_name: row.movement_name || 'Other',
            movement_color: row.movement_color || '#8B7355',
            artists: [],
          });
        }
        const group = map.get(key);
        if (!group.artists.some((a) => a.id === row.id)) {
          group.artists.push({
            id: row.id,
            name: row.name,
            birth_year: row.birth_year,
            death_year: row.death_year,
            portrait_path: row.portrait_path,
          });
        }
      }
      return Array.from(map.values()).sort((a, b) =>
        a.movement_name.localeCompare(b.movement_name)
      );
    };

    const predecessorSql = `
      SELECT DISTINCT a.id, a.name, a.birth_year, a.death_year, a.portrait_path,
             m.id AS movement_id, m.name AS movement_name, m.color AS movement_color
      FROM paintings p_work
      JOIN painting_influence_sources pis ON pis.painting_id = p_work.id
      LEFT JOIN paintings p_pred ON pis.source_painting_id = p_pred.id
      LEFT JOIN artists a ON a.id = COALESCE(p_pred.artist_id, pis.source_artist_id)
      LEFT JOIN art_movements m ON a.movement_id = m.id
      WHERE p_work.artist_id = $1 AND a.id IS NOT NULL AND a.id <> $1
      UNION
      SELECT DISTINCT a.id, a.name, a.birth_year, a.death_year, a.portrait_path,
             m.id AS movement_id, m.name AS movement_name, m.color AS movement_color
      FROM painting_influences pi
      JOIN paintings p_work ON pi.painting_id = p_work.id
      JOIN paintings p_pred ON pi.influenced_by_painting_id = p_pred.id
      JOIN artists a ON p_pred.artist_id = a.id
      LEFT JOIN art_movements m ON a.movement_id = m.id
      WHERE p_work.artist_id = $1 AND a.id <> $1`;

    const successorSql = `
      SELECT DISTINCT a.id, a.name, a.birth_year, a.death_year, a.portrait_path,
             m.id AS movement_id, m.name AS movement_name, m.color AS movement_color
      FROM painting_influence_sources pis
      JOIN paintings p_src ON pis.source_painting_id = p_src.id
      JOIN paintings p_work ON pis.painting_id = p_work.id
      JOIN artists a ON p_work.artist_id = a.id
      LEFT JOIN art_movements m ON a.movement_id = m.id
      WHERE p_src.artist_id = $1 AND a.id <> $1
      UNION
      SELECT DISTINCT a.id, a.name, a.birth_year, a.death_year, a.portrait_path,
             m.id AS movement_id, m.name AS movement_name, m.color AS movement_color
      FROM painting_influences pi
      JOIN paintings p_src ON pi.influenced_by_painting_id = p_src.id
      JOIN paintings p_work ON pi.painting_id = p_work.id
      JOIN artists a ON p_work.artist_id = a.id
      LEFT JOIN art_movements m ON a.movement_id = m.id
      WHERE p_src.artist_id = $1 AND a.id <> $1`;

    const [predecessors, successors] = await Promise.all([
      pool.query(
        `SELECT * FROM (${predecessorSql}) u ORDER BY movement_name NULLS LAST, birth_year NULLS LAST, name`,
        [artistId]
      ),
      pool.query(
        `SELECT * FROM (${successorSql}) u ORDER BY movement_name NULLS LAST, birth_year NULLS LAST, name`,
        [artistId]
      ),
    ]);

    res.json({
      predecessors: groupByMovement(predecessors.rows),
      successors: groupByMovement(successors.rows),
    });
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Failed to fetch artist navigation' });
  }
});

// Artist detail with periods and paintings
app.get('/api/artists/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const [artist, periods, paintings] = await Promise.all([
      pool.query(
        `SELECT a.*, m.name as movement_name
         FROM artists a
         LEFT JOIN art_movements m ON a.movement_id = m.id
         WHERE a.id = $1`,
        [id]
      ),
      pool.query(
        `SELECT * FROM artist_periods WHERE artist_id = $1 ORDER BY sort_order, start_year`,
        [id]
      ),
      pool.query(
        `SELECT p.*,
                (${INFLUENCE_LINKS_EXISTS}) AS has_influence_links
         FROM paintings p
         WHERE p.artist_id = $1
         ORDER BY p.sort_order, p.year`,
        [id]
      ),
    ]);

    if (artist.rows.length === 0) {
      return res.status(404).json({ error: 'Artist not found' });
    }

    res.json({
      artist: artist.rows[0],
      periods: periods.rows,
      paintings: paintings.rows,
    });
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Failed to fetch artist' });
  }
});

// Painting image checkup (developer audit table) — must be before /api/paintings/:id
app.get('/api/paintings/checkup', async (_req, res) => {
  try {
    const { rows } = await pool.query(
      `SELECT p.id, p.title, p.year, p.image_path, p.thumbnail_path,
              p.checkup_checked AS checked, p.checkup_fixed AS fixed,
              a.name AS artist_name
       FROM paintings p
       JOIN artists a ON a.id = p.artist_id
       ORDER BY a.name, p.year NULLS LAST, p.title`
    );

    const paintings = rows.map((row) => {
      const galleryFile = row.image_path || row.thumbnail_path || null;
      const detailFile = row.image_path || row.thumbnail_path || null;
      const detailOnDemand = !detailFile;

      const galleryFileExists = galleryFile
        ? fs.existsSync(path.join(IMAGE_DIR, galleryFile))
        : false;
      const detailFileExists = detailFile
        ? fs.existsSync(path.join(IMAGE_DIR, detailFile))
        : false;

      return {
        id: row.id,
        title: row.title,
        artist_name: row.artist_name,
        year: row.year,
        gallery_file: galleryFile,
        gallery_preview: row.thumbnail_path || galleryFile,
        detail_file: detailOnDemand ? `/api/paintings/${row.id}/image?size=full` : detailFile,
        detail_preview: row.thumbnail_path || (detailOnDemand ? null : detailFile),
        detail_on_demand: detailOnDemand,
        gallery_file_exists: galleryFileExists,
        detail_file_exists: detailOnDemand ? null : detailFileExists,
        checked: !!row.checked,
        fixed: !!row.fixed,
      };
    });

    res.json({ paintings, total: paintings.length });
  } catch (err) {
    console.error('Checkup error:', err.message);
    res.status(500).json({ error: 'Failed to load checkup data' });
  }
});

// Update checkup workflow flags (checked / fixed)
app.patch('/api/paintings/:id/checkup-flags', async (req, res) => {
  try {
    const paintingId = parseInt(req.params.id, 10);
    const { checked, fixed } = req.body ?? {};

    if (checked === undefined && fixed === undefined) {
      return res.status(400).json({ error: 'Provide checked and/or fixed boolean' });
    }
    if (checked !== undefined && typeof checked !== 'boolean') {
      return res.status(400).json({ error: 'checked must be a boolean' });
    }
    if (fixed !== undefined && typeof fixed !== 'boolean') {
      return res.status(400).json({ error: 'fixed must be a boolean' });
    }

    const current = await pool.query(
      `SELECT checkup_checked, checkup_fixed FROM paintings WHERE id = $1`,
      [paintingId]
    );
    if (current.rows.length === 0) {
      return res.status(404).json({ error: 'Painting not found' });
    }

    const willBeFixed =
      fixed !== undefined ? fixed : !!current.rows[0].checkup_fixed;
    let nextChecked = checked;
    if (willBeFixed) {
      nextChecked = true;
    }

    const sets = [];
    const params = [];
    if (fixed !== undefined) {
      params.push(fixed);
      sets.push(`checkup_fixed = $${params.length}`);
    }
    if (nextChecked !== undefined) {
      params.push(nextChecked);
      sets.push(`checkup_checked = $${params.length}`);
    }
    params.push(paintingId);

    const result = await pool.query(
      `UPDATE paintings SET ${sets.join(', ')}
       WHERE id = $${params.length}
       RETURNING checkup_checked AS checked, checkup_fixed AS fixed`,
      params
    );

    res.json({
      checked: !!result.rows[0].checked,
      fixed: !!result.rows[0].fixed,
    });
  } catch (err) {
    console.error('Checkup flags error:', err.message);
    res.status(500).json({ error: 'Failed to update checkup flags' });
  }
});

// Painting detail with influences
app.get('/api/paintings/:id', async (req, res) => {
  try {
    const { id } = req.params;

    const painting = await pool.query(
      `SELECT p.*, a.name as artist_name, a.id as artist_id, a.portrait_path as artist_portrait,
              (${INFLUENCE_LINKS_EXISTS}) AS has_influence_links
       FROM paintings p
       JOIN artists a ON p.artist_id = a.id
       WHERE p.id = $1`,
      [id]
    );

    if (painting.rows.length === 0) {
      return res.status(404).json({ error: 'Painting not found' });
    }

    const [influencedBy, influenced] = await Promise.all([
      pool.query(INFLUENCED_BY_SQL, [id]),
      pool.query(
        `SELECT * FROM (
          SELECT pi.notes, pi.source, pi.aspects, pi.quote, pi.source_author, pi.source_url,
                 'painting' AS source_type,
                 p.id, p.title, p.year, p.image_path, a.name as artist_name, a.id as artist_id
          FROM painting_influences pi
          JOIN paintings p ON pi.painting_id = p.id
          JOIN artists a ON p.artist_id = a.id
          WHERE pi.influenced_by_painting_id = $1
          UNION ALL
          SELECT pis.notes, pis.source, pis.aspects, pis.quote, pis.source_author, pis.source_url,
                 'painting' AS source_type,
                 p.id, p.title, p.year, p.image_path, a.name as artist_name, a.id as artist_id
          FROM painting_influence_sources pis
          JOIN paintings p ON pis.painting_id = p.id
          JOIN artists a ON p.artist_id = a.id
          WHERE pis.source_painting_id = $1 AND pis.source_type = 'painting'
        ) influenced_works
        ORDER BY year NULLS LAST`,
        [id]
      ),
    ]);

    res.json({
      painting: painting.rows[0],
      influencedBy: influencedBy.rows,
      influenced: influenced.rows,
    });
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Failed to fetch painting' });
  }
});

// Fast preload: link local image files only (no external downloads)
app.post('/api/artists/:id/preload-images', async (req, res) => {
  try {
    const artistId = parseInt(req.params.id, 10);
    const result = await preloadArtistImagesLocal(artistId);
    res.json(result);
  } catch (err) {
    console.error('Preload error:', err.message);
    res.status(500).json({ error: 'Preload failed' });
  }
});

// Developer debug: Google Images first result for image audit
app.get('/api/paintings/:id/debug-image-search', async (req, res) => {
  try {
    const paintingId = parseInt(req.params.id, 10);
    const result = await pool.query(
      `SELECT p.title, a.name AS artist_name
       FROM paintings p
       JOIN artists a ON a.id = p.artist_id
       WHERE p.id = $1`,
      [paintingId]
    );
    if (result.rows.length === 0) {
      return res.status(404).json({ error: 'Painting not found' });
    }

    const { title, artist_name: artistName } = result.rows[0];
    const search = await searchGoogleImagesFirst(artistName, title);
    res.json(search);
  } catch (err) {
    console.error('Debug image search error:', err.message);
    res.status(500).json({ error: 'Image search failed' });
  }
});

// Developer debug: replace painting image with a search result URL
app.post('/api/paintings/:id/fix-image', async (req, res) => {
  try {
    const paintingId = parseInt(req.params.id, 10);
    const imageUrl = req.body?.imageUrl;
    if (!imageUrl || typeof imageUrl !== 'string' || !/^https?:\/\//i.test(imageUrl)) {
      return res.status(400).json({ error: 'Valid imageUrl required' });
    }

    const updated = await replacePaintingImageFromUrl(paintingId, imageUrl);
    await pool.query(
      `UPDATE paintings SET checkup_fixed = true, checkup_checked = true WHERE id = $1`,
      [paintingId]
    );
    res.json({ ...updated, fixed: true, checked: true });
  } catch (err) {
    console.error('Fix image error:', err.message);
    res.status(500).json({ error: err.message || 'Fix image failed' });
  }
});

// Proxy remote image for debug preview (avoids hotlink / CORS blocks)
app.get('/api/debug/image-proxy', async (req, res) => {
  try {
    const imageUrl = req.query.url;
    if (!imageUrl || typeof imageUrl !== 'string' || !/^https?:\/\//i.test(imageUrl)) {
      return res.status(400).json({ error: 'Valid url query required' });
    }

    const buffer = await fetchImageBuffer(imageUrl);
    const ext = pickExt(imageUrl).toLowerCase();
    const type =
      ext === '.png' ? 'image/png' : ext === '.webp' ? 'image/webp' : 'image/jpeg';
    res.setHeader('Content-Type', type);
    res.setHeader('Cache-Control', 'no-store');
    res.send(buffer);
  } catch (err) {
    console.error('Image proxy error:', err.message);
    res.status(502).json({ error: 'Could not load preview image' });
  }
});

// On-demand painting image (resolves, caches, serves thumb or full)
app.get('/api/paintings/:id/image', async (req, res) => {
  try {
    const { id } = req.params;
    const size = req.query.size === 'full' ? 'full' : 'thumb';
    const relPath = await ensurePaintingImages(parseInt(id, 10), size);

    if (!relPath) {
      return res.status(404).json({ error: 'Image not found' });
    }

    const absPath = path.join(IMAGE_DIR, relPath);
    if (!fs.existsSync(absPath)) {
      return res.status(404).json({ error: 'Image file missing' });
    }

    res.setHeader('Cache-Control', 'public, max-age=86400');
    res.sendFile(absPath);
  } catch (err) {
    console.error('Image fetch error:', err.message);
    res.status(500).json({ error: 'Image fetch failed' });
  }
});

// Year range bounds
app.get('/api/bounds', async (req, res) => {
  try {
    const result = await pool.query(`
      SELECT
        (SELECT MIN(start_year) FROM art_movements) as min_year,
        GREATEST(
          (SELECT MAX(end_year) FROM historical_eras),
          (SELECT MAX(end_year) FROM art_movements),
          (SELECT MAX(death_year) FROM artists WHERE death_year IS NOT NULL)
        ) as max_year
    `);
    res.json(result.rows[0]);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Failed to fetch bounds' });
  }
});

const CLIENT_DIST = path.join(__dirname, '..', 'client', 'dist');
if (fs.existsSync(CLIENT_DIST)) {
  app.use(express.static(CLIENT_DIST));
  app.get(/^(?!\/api|\/images).*/, (_req, res) => {
    res.sendFile(path.join(CLIENT_DIST, 'index.html'));
  });
}

app.listen(PORT, () => {
  console.log(`Gallery running on http://localhost:${PORT}`);
});