server.js

const express = require('express');
const cors = require('cors');
const { config, validateConfig } = require('./config');
const { logMessage } = require('./src/utils/logger');
const { requestLogger, errorHandler } = require('./src/middleware/logging');
const subscriptionManager = require('./src/managers/subscription-manager');
const graphAuth = require('./src/auth/graph-auth');
const { getGraphClient } = require('./src/services/graph-client');
const eventCache = require('./src/services/event-cache-db');

// Import routes
const homeRoutes = require('./src/routes/home');
const webhookRoutes = require('./src/routes/webhook');
const subscriptionRoutes = require('./src/routes/subscriptions');
const statusRoutes = require('./src/routes/status');
const calendarRoutes = require('./src/routes/calendar');
const healthRoutes = require('./src/routes/health');

const app = express();

// Middleware
app.use(cors());
app.use(express.json({ limit: '50mb' }));
app.use(express.urlencoded({ extended: true }));
app.use(requestLogger);

// Routes
app.use('/', homeRoutes);
app.use('/webhook', webhookRoutes);
app.use('/subscriptions', subscriptionRoutes);
app.use('/status', statusRoutes);
app.use('/calendar', calendarRoutes);
app.use('/health', healthRoutes);

// Error handling
app.use(errorHandler);

async function cleanupOldSubscriptions() {
  try {
    logMessage('🧹 Cleaning up old webhook subscriptions...');
    const graphClient = await getGraphClient();

    // Get all current subscriptions
    const result = await graphClient.api('/subscriptions').get();
    const subscriptions = result.value || [];

    if (subscriptions.length === 0) {
      logMessage('No existing subscriptions found');
      // Still clear cache since we want a fresh start
      subscriptionManager.clearCachedSubscription();
      return;
    }

    logMessage(`Found ${subscriptions.length} existing subscriptions to clean up`);

    // Delete all existing subscriptions
    for (const sub of subscriptions) {
      try {
        logMessage(`Deleting subscription: ${sub.id.slice(-8)}`);
        await graphClient.api(`/subscriptions/${sub.id}`).delete();
      } catch (deleteError) {
        logMessage(`Failed to delete subscription ${sub.id.slice(-8)}: ${deleteError.message}`, 'WARNING');
      }
    }

    // Clear cached subscription since we deleted all
    subscriptionManager.clearCachedSubscription();

    logMessage('✅ Old subscriptions cleaned up successfully');
  } catch (error) {
    logMessage(`Subscription cleanup failed: ${error.message}`, 'WARNING');
    // Clear cache anyway to force fresh start
    subscriptionManager.clearCachedSubscription();
  }
}

async function syncExistingEvents() {
  try {
    logMessage('🔄 Syncing existing events from Outlook calendar...');
    const graphClient = await getGraphClient();

    // Fetch events from 1 week ago to 1 year forward
    const now = new Date();
    const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
    const oneYearForward = new Date(now.getTime() + 365 * 24 * 60 * 60 * 1000);

    const response = await graphClient
      .api('/me/events')
      .filter(`start/dateTime ge '${oneWeekAgo.toISOString()}' and start/dateTime le '${oneYearForward.toISOString()}'`)
      .select('id,subject,start,end,location,body,bodyPreview,isAllDay,lastModifiedDateTime,createdDateTime,isCancelled')
      .top(500)
      .get();

    const events = response.value || [];
    logMessage(`Found ${events.length} events to cache`);

    let cachedCount = 0;
    for (const event of events) {
      try {
        eventCache.upsertEvent(event);
        cachedCount++;
      } catch (error) {
        logMessage(`Failed to cache event ${event.id}: ${error.message}`, 'WARNING');
      }
    }

    logMessage(`✅ Successfully cached ${cachedCount} events`);
  } catch (error) {
    logMessage(`⚠️ Initial sync failed: ${error.message}`, 'WARNING');
    logMessage('Service will continue with empty cache - webhooks will populate as events change', 'WARNING');
  }
}

async function initializeServices() {
  try {
    // Validate configuration
    validateConfig();

    // Initialize event cache database
    logMessage('Initializing event cache database...');
    eventCache.initialize();

    // Clean up old events (older than 1 year)
    eventCache.cleanupOldEvents();

    // Initialize auth
    logMessage('Refreshing Microsoft Graph token...');
    await graphAuth.getToken();

    // Sync existing events to populate cache
    await syncExistingEvents();

    // Clean up old subscriptions first (this will clear cache)
    await cleanupOldSubscriptions();

    // Initialize subscription manager AFTER cleanup
    subscriptionManager.initSubscription();

    // Create new subscription (will create since we cleared cache)
    const subscriptionResult = await subscriptionManager.manageSubscription();

    if (!subscriptionResult) {
      logMessage('❌ Failed to create webhook subscription', 'ERROR');
      logMessage('Service will continue without webhooks - manual subscription creation may be needed', 'WARNING');
    }

    // Scan and move existing events that match criteria
    const { scanAndMoveExistingEvents } = require('./src/services/event-processor');
    await scanAndMoveExistingEvents();

    logMessage('✅ Services initialized successfully');
    logMessage(`📅 ICS feed available at: /calendar/{secret-token}.ics`);

    // Start periodic health checks
    logMessage('🔄 Periodic health check scheduler started');
    setInterval(async () => {
      try {
        await subscriptionManager.manageSubscription();
      } catch (error) {
        logMessage(`Health check error: ${error.message}`, 'ERROR');
      }
    }, 30 * 60 * 1000); // Every 30 minutes

  } catch (error) {
    logMessage(`Initialization failed: ${error.message}`, 'ERROR');
    throw error;
  }
}

// Graceful shutdown
process.on('SIGINT', () => {
  logMessage('Shutting down...');
  process.exit(0);
});

process.on('SIGTERM', () => {
  logMessage('Shutting down...');
  process.exit(0);
});

// Start server
app.listen(config.port, async () => {
  logMessage(`Server running on port ${config.port}`);

  try {
    await initializeServices();
    logMessage('✅ Initialization completed successfully');
  } catch (error) {
    logMessage(`❌ Initialization failed: ${error.message}`, 'ERROR');
    process.exit(1);
  }
});

module.exports = app;