const express = require('express');
const { validateURL, validateToken } = require('../input-validator');
const { paginate, parsePaginationParams } = require('../pagination');

module.exports = function(ctx) {
  const router = express.Router();

  // GET /config — Get notification configuration (sensitive data redacted)
  router.get('/config', ctx.asyncHandler(async (req, res) => {
    const notificationConfig = ctx.notification.getConfig();
    // Return config without sensitive data
    const safeConfig = {
      enabled: notificationConfig.enabled,
      providers: {
        discord: {
          enabled: notificationConfig.providers.discord?.enabled || false,
          configured: !!notificationConfig.providers.discord?.webhookUrl,
        },
        telegram: {
          enabled: notificationConfig.providers.telegram?.enabled || false,
          configured: !!(notificationConfig.providers.telegram?.botToken && notificationConfig.providers.telegram?.chatId),
        },
        ntfy: {
          enabled: notificationConfig.providers.ntfy?.enabled || false,
          configured: !!notificationConfig.providers.ntfy?.topic,
          serverUrl: notificationConfig.providers.ntfy?.serverUrl || 'https://ntfy.sh',
        },
      },
      events: notificationConfig.events,
      healthCheck: notificationConfig.healthCheck,
    };
    res.json({ success: true, config: safeConfig });
  }, 'notifications-config-get'));

  // POST /config — Update notification configuration
  router.post('/config', ctx.asyncHandler(async (req, res) => {
    const { enabled, providers, events, healthCheck } = req.body;
    const notificationConfig = ctx.notification.getConfig();

    // Validate provider webhook URLs and tokens
    if (providers) {
      if (providers.discord?.webhookUrl) {
        try {
          validateURL(providers.discord.webhookUrl);
        } catch (validationErr) {
          return ctx.errorResponse(res, 400, 'Invalid Discord webhook URL');
        }
      }
      if (providers.telegram?.botToken) {
        try {
          validateToken(providers.telegram.botToken);
        } catch (validationErr) {
          return ctx.errorResponse(res, 400, 'Invalid Telegram bot token format');
        }
      }
      if (providers.ntfy?.serverUrl) {
        try {
          validateURL(providers.ntfy.serverUrl);
        } catch (validationErr) {
          return ctx.errorResponse(res, 400, 'Invalid ntfy server URL');
        }
      }
      if (providers.ntfy?.topic) {
        const topicRegex = /^[a-zA-Z0-9_-]{1,64}$/;
        if (!topicRegex.test(providers.ntfy.topic)) {
          return ctx.errorResponse(res, 400, 'Invalid ntfy topic (alphanumeric, hyphens, underscores only, max 64 chars)');
        }
      }
    }

    // Update enabled state
    if (typeof enabled === 'boolean') {
      notificationConfig.enabled = enabled;
    }

    // Update providers (only update provided fields)
    if (providers) {
      if (providers.discord) {
        notificationConfig.providers.discord = {
          ...notificationConfig.providers.discord,
          ...providers.discord,
        };
      }
      if (providers.telegram) {
        notificationConfig.providers.telegram = {
          ...notificationConfig.providers.telegram,
          ...providers.telegram,
        };
      }
      if (providers.ntfy) {
        notificationConfig.providers.ntfy = {
          ...notificationConfig.providers.ntfy,
          ...providers.ntfy,
        };
      }
    }

    // Update events
    if (events) {
      notificationConfig.events = { ...notificationConfig.events, ...events };
    }

    // Update health check settings
    if (healthCheck) {
      const wasEnabled = notificationConfig.healthCheck?.enabled;
      notificationConfig.healthCheck = { ...notificationConfig.healthCheck, ...healthCheck };

      // Restart daemon if settings changed
      if (healthCheck.enabled !== wasEnabled || healthCheck.intervalMinutes) {
        if (notificationConfig.healthCheck.enabled) {
          ctx.notification.startHealthDaemon();
        } else {
          ctx.notification.stopHealthDaemon();
        }
      }
    }

    await ctx.notification.saveConfig();
    res.json({ success: true, message: 'Notification config updated' });
  }, 'notifications-config-update'));

  // POST /test — Test notification delivery
  router.post('/test', ctx.asyncHandler(async (req, res) => {
    const { provider } = req.body;

    if (provider) {
      // Test specific provider
      let result;
      switch (provider) {
        case 'discord':
          result = await ctx.notification.sendDiscord('Test Notification', 'This is a test notification from DashCaddy.', 'info');
          break;
        case 'telegram':
          result = await ctx.notification.sendTelegram('Test Notification', 'This is a test notification from DashCaddy.', 'info');
          break;
        case 'ntfy':
          result = await ctx.notification.sendNtfy('Test Notification', 'This is a test notification from DashCaddy.', 'info');
          break;
        default:
          return ctx.errorResponse(res, 400, 'Unknown provider');
      }
      res.json({ success: result.success, provider, error: result.error });
    } else {
      // Test all enabled providers
      const result = await ctx.notification.send('test', 'Test Notification', 'This is a test notification from DashCaddy.', 'info');
      res.json({ success: true, ...result });
    }
  }, 'notifications-test'));

  // GET /history — Get notification history
  router.get('/history', ctx.asyncHandler(async (req, res) => {
    const notificationHistory = ctx.notification.getHistory();
    const paginationParams = parsePaginationParams(req.query);
    if (paginationParams) {
      const result = paginate(notificationHistory, paginationParams);
      res.json({ success: true, history: result.data, total: notificationHistory.length, pagination: result.pagination });
    } else {
      const limit = parseInt(req.query.limit) || 50;
      res.json({
        success: true,
        history: notificationHistory.slice(0, limit),
        total: notificationHistory.length,
      });
    }
  }, 'notifications-history'));

  // DELETE /history — Clear notification history
  router.delete('/history', ctx.asyncHandler(async (req, res) => {
    ctx.notification.clearHistory();
    res.json({ success: true, message: 'Notification history cleared' });
  }, 'notifications-history-clear'));

  // POST /health-check — Manually trigger health check
  router.post('/health-check', ctx.asyncHandler(async (req, res) => {
    await ctx.notification.checkHealth();
    const notificationConfig = ctx.notification.getConfig();
    res.json({
      success: true,
      lastCheck: notificationConfig.healthCheck.lastCheck,
      containersMonitored: Object.keys(ctx.notification.getHealthState()).length,
    });
  }, 'notifications-health-check'));

  return router;
};