server.js

import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import { initializeDatabase } from './db/database.js';
import { redis } from './services/redis.js';

// Import routes
import authRoutes from './routes/auth.js';
import servicesRoutes from './routes/services.js';
import slotsRoutes from './routes/slots.js';
import reservationsRoutes from './routes/reservations.js';

dotenv.config();

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

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

// Request logging
app.use((req, res, next) => {
    console.log(`${new Date().toISOString()} - ${req.method} ${req.path}`);
    next();
});

// Health check endpoint
app.get('/health', async (req, res) => {
    try {
        // Test Redis connection
        await redis.ping();
        res.json({
            status: 'healthy',
            timestamp: new Date().toISOString(),
            services: {
                database: 'connected',
                redis: 'connected'
            }
        });
    } catch (error) {
        res.status(503).json({
            status: 'unhealthy',
            error: error.message
        });
    }
});

// API Routes
app.use('/api/auth', authRoutes);
app.use('/api/services', servicesRoutes);
app.use('/api/slots', slotsRoutes);
app.use('/api/reservations', reservationsRoutes);

// Root endpoint
app.get('/', (req, res) => {
    res.json({
        name: 'Bookd API',
        version: '1.0.0',
        description: 'Reservation system with RBAC and concurrency control',
        endpoints: {
            health: '/health',
            auth: '/api/auth',
            services: '/api/services',
            slots: '/api/slots',
            reservations: '/api/reservations'
        }
    });
});

// 404 handler
app.use((req, res) => {
    res.status(404).json({ error: 'Not found' });
});

// Global error handler
app.use((err, req, res, next) => {
    console.error('Global error handler:', err);
    res.status(err.status || 500).json({
        error: err.message || 'Internal server error',
        ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
    });
});

// Initialize database and start server
async function startServer() {
    try {
        console.log('🚀 Starting Bookd server...\n');

        // Initialize database schema
        await initializeDatabase();

        // Start Express server
        app.listen(PORT, () => {
            console.log(`\n✓ Server running on http://localhost:${PORT}`);
            console.log(`✓ Environment: ${process.env.NODE_ENV || 'development'}`);
            console.log(`✓ PostgreSQL: ${process.env.DB_HOST}:${process.env.DB_PORT}`);
            console.log(`✓ Redis: ${process.env.REDIS_HOST}:${process.env.REDIS_PORT}`);
            console.log('\n📚 API Documentation:');
            console.log(`   Health: http://localhost:${PORT}/health`);
            console.log(`   Auth: http://localhost:${PORT}/api/auth`);
            console.log(`   Services: http://localhost:${PORT}/api/services`);
            console.log(`   Slots: http://localhost:${PORT}/api/slots`);
            console.log(`   Reservations: http://localhost:${PORT}/api/reservations\n`);
        });
    } catch (error) {
        console.error('Failed to start server:', error);
        process.exit(1);
    }
}

// Handle graceful shutdown
process.on('SIGTERM', async () => {
    console.log('SIGTERM received, shutting down gracefully...');
    await redis.quit();
    process.exit(0);
});

process.on('SIGINT', async () => {
    console.log('\nSIGINT received, shutting down gracefully...');
    await redis.quit();
    process.exit(0);
});

startServer();