app.js

const express = require('express');
const session = require('express-session');
const expressLayouts = require('express-ejs-layouts');
const path = require('path');
const http = require('http');
const { Server } = require('socket.io');
const { requireAuth, requireGuest, checkPrivateRoomAccessBySlug } = require('./middleware/auth')
require('dotenv').config();

const authRoutes = require('./routes/auth');
const roomRoutes = require('./routes/rooms');
const userRoutes = require('./routes/user');
const messageRoutes = require('./routes/messages');
const messageController = require('./controllers/messageController');
const store = require('./config/database');
const guestStore = require('./utils/guestStore');

const app = express();
const server = http.createServer(app);
const io = new Server(server);
const PORT = process.env.APP_PORT || 3000;

// Trust proxy to get correct IP addresses (important for rate limiting)
app.set('trust proxy', 1);

// Set socket.io instance in message controller
messageController.setSocketIO(io);

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

const sessionMiddleware = session({
    secret: process.env.APP_SECRET || 'secret-key',
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: process.env.NODE_ENV === 'production',
        maxAge: 24 * 60 * 60 * 1000
    }
});

app.use(sessionMiddleware);

// Static files
app.use(express.static(path.join(__dirname, 'public')));
app.use('/uploads', express.static(path.join(__dirname, 'uploads')));

// View engine setup
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));

app.use(expressLayouts);
app.set('layout', 'layouts/main');

// Global middleware to pass user data to all views
app.use((req, res, next) => {
    res.locals.user = req.session.user || null;
    next();
});


app.use('/api/auth', authRoutes);
app.use('/api/rooms', roomRoutes);
app.use('/api/user', userRoutes);
app.use('/api/messages', messageRoutes);

app.get('/', (req, res) => {
    res.render('index', { title: 'Home' });
});

app.get('/login', requireGuest, (req, res) => {
    res.render('login', {
        title: 'Login',
        layout: 'layouts/auth'
    });
});

app.get('/register', requireGuest, (req, res) => {
    res.render('register', {
        title: 'Register',
        layout: 'layouts/auth'
    });
});

app.get('/room/:slug', checkPrivateRoomAccessBySlug, (req, res) => {
    res.render('room', { title: 'Chat Room'});
});

app.get('/create-room', requireAuth, (req, res) => {
    res.render('create-room', { title: 'Create Room' });
});

app.get('/profile', requireAuth, (req, res) => {
    res.render('profile', { title: 'Profile' });
});

app.get('/terms-conditions', (req, res) => {
    res.render('terms');
});

// Share session with Socket.io
io.engine.use(sessionMiddleware);

// Socket.io connection handling
io.on('connection', (socket) => {
    console.log('User connected:', socket.id);

    const session = socket.request.session;

    // Join a room with validation
    socket.on('join_room', async (roomId) => {
        try {
            const dbSession = store.openSession();
            const room = await dbSession.load(roomId);

            if (!room) {
                socket.emit('room_error', { error: 'Room not found' });
                return;
            }

            if (room.type === 'public') {
                if (session.user || session.guest) {
                    socket.join(roomId);
                    const userType = session.user ? 'user' : 'guest';
                    const userIdentifier = session.user ? session.user.email : session.guest.username;
                    console.log(`${userType} ${socket.id} (${userIdentifier}) joined public room ${roomId}`);
                    return;
                } else {
                    socket.emit('room_error', { error: 'Please login to join this room' });
                    return;
                }
            }

            if (!session.user) {
                socket.emit('room_error', { error: 'Login required for private rooms' });
                return;
            }

            const userEmail = session.user.email.toLowerCase();

            // Admin always has access
            if (room.admin_id === session.user.id) {
                socket.join(roomId);
                console.log(`User ${socket.id} (admin) joined private room ${roomId}`);
                return;
            }

            // Check if user's email is in allowed_emails list
            if (!room.allowed_emails || !Array.isArray(room.allowed_emails)) {
                socket.emit('room_error', { error: 'Access denied - Room configuration error' });
                return;
            }

            const allowedEmails = room.allowed_emails.map(email => email.toLowerCase());

            if (!allowedEmails.includes(userEmail)) {
                socket.emit('room_error', { error: 'Access denied - You are not authorized for this room' });
                return;
            }

            // User is authorized
            socket.join(roomId);
            console.log(`User ${socket.id} (${userEmail}) joined private room ${roomId}`);
        } catch (error) {
            console.error('Socket join_room error:', error);
            socket.emit('room_error', { error: 'An error occurred while joining room' });
        }
    });

    // Leave a room
    socket.on('leave_room', (roomId) => {
        socket.leave(roomId);
        console.log(`User ${socket.id} left room ${roomId}`);
    });

    socket.on('disconnect', () => {
        console.log('User disconnected:', socket.id);

        // Clean up guest username if guest disconnects
        if (session.guest) {
            guestStore.remove(session.guest.username);
            console.log(`Guest username ${session.guest.username} freed up after disconnect`);
        }
    });
});

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

module.exports = { app, io, server };