server.js

import { createServer } from 'node:http';
import next from 'next';
import { Server } from 'socket.io';
import path from 'path';
import fs from 'fs/promises';
import { v4 as uuidv4 } from 'uuid';
import { fileURLToPath } from 'url';
import { dirname } from 'path';

// ESM __dirname equivalent for reliable absolute paths
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Import your DB helpers
import { insertMemory, getAllMemories } from './server/db.js';

const dev = process.env.NODE_ENV !== 'production';
const hostname = process.env.HOST || '0.0.0.0';
const port = 3000;
const DEBUG = process.env.NODE_ENV !== 'production';

const app = next({ dev, hostname, port });
const handler = app.getRequestHandler();

console.log('⌛ Starting Memory Wall Server...');

app.prepare().then(() => {
  const httpServer = createServer((req, res) => {
    handler(req, res);
  });

  const io = new Server(httpServer, {
    cors: {
      origin: '*',
      methods: ['GET', 'POST'],
    },
    transports: ['websocket', 'polling'],
  });

  console.log('✅ Socket.IO server initialized');

  io.on('connection', (socket) => {
    if (DEBUG) console.log(`[Socket.IO] 🎨… Client connected: ${socket.id}`);

    // Send current memories from DB to the newly connected client
    try {
      const memories = getAllMemories();
      socket.emit('initial-memories', memories);
      if (DEBUG) console.log(`[Socket.IO] 🎨 Sent ${memories.length} initial memories to ${socket.id}`);
    } catch (err) {
      console.error('[Socket.IO] 🖼️ Error loading initial memories:', err);
    }

    // Allow clients to explicitly request the latest wall data
    socket.on('request-initial-memories', () => {
      try {
        const memories = getAllMemories();
        socket.emit('initial-memories', memories);
        if (DEBUG) console.log(`[Socket.IO] 🎨 Re-sent ${memories.length} initial memories to ${socket.id}`);
      } catch (err) {
        console.error('[Socket.IO] ❌ Error handling request-initial-memories:', err);
      }
    });

    // When client submits a new memory
    socket.on('new-memory', async (payload) => {
      if (DEBUG) console.log(`[Socket.IO] 📨 Received new-memory from ${socket.id}`);
     
      try {
        const { name, message, email, photoBase64, compositeBase64 } = payload;

        // Validate required fields
        if (!name?.trim()) {
          console.error('[Socket.IO] 🖼️ Missing name');
          socket.emit('memory-saved', { success: false, error: 'Name is required' });
          return;
        }
       
        if (!message?.trim()) {
          console.error('[Socket.IO] 🖼️ Missing message');
          socket.emit('memory-saved', { success: false, error: 'Message is required' });
          return;
        }
       
        if (!photoBase64 && !compositeBase64) {
          console.error('[Socket.IO] 🖼️ Missing images');
          socket.emit('memory-saved', { success: false, error: 'Image is required' });
          return;
        }

        const id = uuidv4();
        const now = Date.now();

        if (DEBUG) console.log(`[Socket.IO] 🎨 Generated ID: ${id}`);

        let photoUrl = null;
        let compositeUrl = null;

        // ✅ FIX #1: Save the RAW PHOTO (for avatar display)
        if (photoBase64) {
          try {
            const matches = photoBase64.match(/^data:(.+);base64,(.+)$/);
            if (matches?.length === 3) {
              const mimeType = matches[1];
              const ext = mimeType.split('/')[1] || 'webp';
              const buffer = Buffer.from(matches[2], 'base64');
             
              // Save to photos directory using __dirname for reliable path
              const photoDir = path.join(__dirname, 'public', 'memories', 'photos');
              await fs.mkdir(photoDir, { recursive: true });
              const photoFilePath = path.join(photoDir, `${id}.${ext}`);
              await fs.writeFile(photoFilePath, buffer);
              photoUrl = `/memories/photos/${id}.${ext}`;
             
              if (DEBUG) console.log(`[Socket.IO] 💾 Saved photo: ${photoUrl}`);
            } else {
              console.error('[Socket.IO] 🖼️ Invalid photo base64 format');
            }
          } catch (fileErr) {
            console.error('[Socket.IO] 🖼️ Photo save error:', fileErr);
          }
        }

        // ✅ FIX #2: Save the COMPOSITE CARD (full card screenshot)
        if (compositeBase64) {
          try {
            const matches = compositeBase64.match(/^data:(.+);base64,(.+)$/);
            if (matches?.length === 3) {
              const mimeType = matches[1];
              const ext = mimeType.split('/')[1] || 'png';
              const buffer = Buffer.from(matches[2], 'base64');
             
              // Save to composite directory using __dirname for reliable path
              const compositeDir = path.join(__dirname, 'public', 'memories', 'composite');
              await fs.mkdir(compositeDir, { recursive: true });
              const compositeFilePath = path.join(compositeDir, `${id}.${ext}`);
              await fs.writeFile(compositeFilePath, buffer);
              compositeUrl = `/memories/composite/${id}.${ext}`;
             
              if (DEBUG) console.log(`[Socket.IO] 💾 Saved composite: ${compositeUrl}`);
            } else {
              console.error('[Socket.IO] 🖼️ Invalid composite base64 format');
            }
          } catch (fileErr) {
            console.error('[Socket.IO] 🖼️ Composite save error:', fileErr);
          }
        }

        // ✅ FIX #3: Store PHOTO as imageUrl, COMPOSITE as fPhotoUrl
        const memory = {
          id,
          name: name.trim(),
          message: message.trim().slice(0, 80),
          email: email?.trim() || null,
          imageUrl: photoUrl || '/icon.png',      //🖼️ RAW PHOTO for avatar
          fPhotoUrl: compositeUrl || photoUrl,            // 🖼️ COMPOSITE CARD
          createdAt: now,
        };

        if (DEBUG) console.log(`[Socket.IO] 🎨 Inserting memory into DB...`);
        insertMemory(memory);
        if (DEBUG) console.log(`[Socket.IO] 🖼️… Successfully saved to DB: ${id}`);
       
        // Broadcast only persisted memory metadata/URLs to keep payloads lightweight.
        io.emit('memory-created', memory);
        if (DEBUG) console.log(`[Socket.IO] 🖼️¡ Broadcasted memory-created to ${io.engine.clientsCount} clients`);

        // Confirm to sender
        socket.emit('memory-saved', { success: true, id });
        if (DEBUG) console.log(`[Socket.IO] 🎨… Confirmed to sender: ${socket.id}`);
       
      } catch (err) {
        console.error('[Socket.IO] 🖼️ Error in new-memory handler:', err);
        socket.emit('memory-saved', {
          success: false,
          error: err.message || 'Server error',
        });
      }
    });

    socket.on('disconnect', (reason) => {
      if (DEBUG) console.log(`[Socket.IO] ❌ Client disconnected: ${socket.id} (${reason})`);
    });

    socket.on('error', (error) => {
      console.error(`[Socket.IO] ⌛ Socket error for ${socket.id}:`, error);
    });
  });

  httpServer
    .listen(port, () => {
      console.log(`✅ Server ready on http://localhost:${port}`);
      console.log(`🎨 Submit page: http://localhost:${port}/submit`);
      console.log(`🖼️  Wall page: http://localhost:${port}/wall`);
      console.log(`\n⌛ Waiting for connections...\n`);
    })
    .on('error', (err) => {
      console.error('⌛ Server failed:', err);
      process.exit(1);
    });
});