/**
 * Event Management Routes
 *
 * Category CRUD, Event CRUD with search/filter,
 * Session CRUD, Resource CRUD,
 * AI-powered event content generation.
 */

import express, { Request, Response } from 'express';
import { body, query, validationResult } from 'express-validator';
import { getModels } from '../models';
import { authenticateJwtOrApiToken } from '../middleware/dualAuth';
import { requirePermission } from '../middleware/permissions';
import { generateWithAI } from '../utils/aiProvider';

const router = express.Router();
router.use(authenticateJwtOrApiToken);

// ============================================
// CATEGORY ROUTES
// ============================================

// List categories for a company
router.get('/categories/:companyId', async (req: Request, res: Response) => {
  try {
    const { companyId } = req.params;
    const { EventCategory } = getModels();

    if (!req.user!.companyIds.includes(companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    const categories = await EventCategory.find({ companyId }).sort({ order: 1, createdAt: 1 });
    res.json(categories);
  } catch (error) {
    res.status(500).json({ error: 'Failed to get categories' });
  }
});

// Get single category
router.get('/categories/detail/:id', async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventCategory } = getModels();

    const category = await EventCategory.findById(id);
    if (!category) {
      res.status(404).json({ error: 'Category not found' });
      return;
    }

    if (!req.user!.companyIds.includes(category.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    res.json(category);
  } catch (error) {
    res.status(500).json({ error: 'Failed to get category' });
  }
});

// Create category
router.post('/categories', requirePermission('events', 'create'), [
  body('name').trim().notEmpty().withMessage('Name is required'),
  body('companyId').notEmpty().withMessage('Company ID is required'),
], async (req: Request, res: Response) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      res.status(400).json({ errors: errors.array() });
      return;
    }

    const { EventCategory } = getModels();
    const category = new EventCategory(req.body);
    await category.save();
    res.status(201).json(category);
  } catch (error) {
    res.status(500).json({ error: 'Failed to create category' });
  }
});

// Update category
router.put('/categories/:id', requirePermission('events', 'edit'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventCategory } = getModels();

    const category = await EventCategory.findById(id);
    if (!category) {
      res.status(404).json({ error: 'Category not found' });
      return;
    }

    if (!req.user!.companyIds.includes(category.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    Object.assign(category, req.body, { updatedAt: new Date() });
    await category.save();
    res.json(category);
  } catch (error) {
    res.status(500).json({ error: 'Failed to update category' });
  }
});

// Delete category (clear categoryId on related events)
router.delete('/categories/:id', requirePermission('events', 'delete'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventCategory, Event } = getModels();

    const category = await EventCategory.findById(id);
    if (!category) {
      res.status(404).json({ error: 'Category not found' });
      return;
    }

    if (!req.user!.companyIds.includes(category.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    await Event.updateMany({ categoryId: id }, { $unset: { categoryId: '' } });
    await EventCategory.findByIdAndDelete(id);
    res.json({ message: 'Category deleted' });
  } catch (error) {
    res.status(500).json({ error: 'Failed to delete category' });
  }
});

// ============================================
// EVENT ROUTES
// ============================================

// List events for a company with search/filter
router.get('/events/:companyId', async (req: Request, res: Response) => {
  try {
    const { companyId } = req.params;
    const { Event } = getModels();

    if (!req.user!.companyIds.includes(companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    const filter: any = { companyId };
    const { search, categoryId, status, eventType, eventMode, priority, visibility, audienceType, isFeatured } = req.query;

    if (search) {
      filter.$text = { $search: search as string };
    }
    if (categoryId) filter.categoryId = categoryId;
    if (status) filter.status = status;
    if (eventType) filter.eventType = eventType;
    if (eventMode) filter.eventMode = eventMode;
    if (priority) filter.priority = priority;
    if (visibility) filter.visibility = visibility;
    if (audienceType) filter.audienceType = audienceType;
    if (isFeatured !== undefined) filter.isFeatured = isFeatured === 'true';

    const page = parseInt(req.query.page as string) || 1;
    const limit = parseInt(req.query.limit as string) || 50;
    const skip = (page - 1) * limit;

    const [events, total] = await Promise.all([
      Event.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit),
      Event.countDocuments(filter),
    ]);

    res.json({ data: events, pagination: { page, limit, total, pages: Math.ceil(total / limit) } });
  } catch (error) {
    res.status(500).json({ error: 'Failed to get events' });
  }
});

// Get single event
router.get('/events/detail/:id', async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { Event } = getModels();

    const event = await Event.findById(id);
    if (!event) {
      res.status(404).json({ error: 'Event not found' });
      return;
    }

    if (!req.user!.companyIds.includes(event.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    res.json(event);
  } catch (error) {
    res.status(500).json({ error: 'Failed to get event' });
  }
});

// Create event
router.post('/events', requirePermission('events', 'create'), [
  body('title').trim().notEmpty().withMessage('Title is required'),
  body('companyId').notEmpty().withMessage('Company ID is required'),
  body('startTime').optional().isString().withMessage('Start time must be a string'),
  body('endTime').optional().isString().withMessage('End time must be a string'),
  body('duration').optional().isString().withMessage('Duration must be a string'),
  body('eventDate').optional().isISO8601().withMessage('Event date must be a valid date'),
], async (req: Request, res: Response) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      res.status(400).json({ errors: errors.array() });
      return;
    }

    // Validate startTime < endTime when both are provided
    if (req.body.startTime && req.body.endTime && req.body.startTime >= req.body.endTime) {
      res.status(400).json({ error: 'End Time must be after Start Time' });
      return;
    }

    // Validate eventDate is not in the past
    if (req.body.eventDate) {
      const today = new Date().toISOString().split('T')[0];
      if (req.body.eventDate < today) {
        res.status(400).json({ error: 'Event Date cannot be in the past' });
        return;
      }
    }

    // Validate duration is not negative
    if (req.body.duration) {
      const durationNum = parseInt(req.body.duration);
      if (!isNaN(durationNum) && durationNum < 0) {
        res.status(400).json({ error: 'Duration cannot be negative' });
        return;
      }
    }

    const { Event } = getModels();
    // Sanitize: only allow known Event schema fields
    const allowedFields = [
      'companyId', 'title', 'slug', 'shortDescription', 'detailedDescription', 'summary',
      'categoryId', 'tags', 'eventType', 'status', 'visibility', 'priority', 'eventMode',
      'eventDate', 'startTime', 'endTime', 'timezone', 'location', 'venue', 'onlineLink',
      'capacity', 'budget', 'currency', 'audienceType', 'approvalStatus',
      'learningObjectives', 'outcomes', 'prerequisites',
      'instructor', 'hostName', 'hostEmail',
      'thumbnail', 'banner', 'mediaUrls',
      'internalNotes', 'metaTitle', 'metaDescription', 'seoKeywords',
      'version', 'reviewNotes',
      'aiGenerated', 'isFeatured',
    ];
    const sanitized: Record<string, any> = {};
    for (const key of allowedFields) {
      if (req.body[key] !== undefined) {
        sanitized[key] = req.body[key];
      }
    }
    // Clamp string lengths to model limits
    if (sanitized.title && sanitized.title.length > 200) {
      sanitized.title = sanitized.title.slice(0, 200);
    }
    if (sanitized.shortDescription && sanitized.shortDescription.length > 500) {
      sanitized.shortDescription = sanitized.shortDescription.slice(0, 500);
    }
    if (sanitized.metaTitle && sanitized.metaTitle.length > 60) {
      sanitized.metaTitle = sanitized.metaTitle.slice(0, 60);
    }
    if (sanitized.metaDescription && sanitized.metaDescription.length > 160) {
      sanitized.metaDescription = sanitized.metaDescription.slice(0, 160);
    }
    // Validate enum values
    const validEventTypes = ['meeting', 'workshop', 'conference', 'webinar', 'training', 'product_launch', 'campaign_event', 'sop_training', 'team_activity', 'onboarding', 'hr_activity', 'other'];
    const validStatuses = ['draft', 'review', 'approved', 'published', 'archived', 'cancelled'];
    const validPriorities = ['low', 'medium', 'high', 'critical'];
    const validVisibilities = ['private', 'internal', 'public'];
    const validEventModes = ['online', 'offline', 'hybrid'];
    const validAudienceTypes = ['public', 'internal', 'team_specific', 'department_specific', 'admin_only'];
    if (sanitized.eventType && !validEventTypes.includes(sanitized.eventType)) {
      sanitized.eventType = 'other';
    }
    if (sanitized.status && !validStatuses.includes(sanitized.status)) {
      sanitized.status = 'draft';
    }
    if (sanitized.priority && !validPriorities.includes(sanitized.priority)) {
      sanitized.priority = 'medium';
    }
    if (sanitized.visibility && !validVisibilities.includes(sanitized.visibility)) {
      sanitized.visibility = 'internal';
    }
    if (sanitized.eventMode && !validEventModes.includes(sanitized.eventMode)) {
      sanitized.eventMode = 'online';
    }
    if (sanitized.audienceType && !validAudienceTypes.includes(sanitized.audienceType)) {
      sanitized.audienceType = 'internal';
    }

    const event = new Event(sanitized);
    console.log('[Events] Creating event with fields:', Object.keys(sanitized).join(', '));
    await event.save();
    res.status(201).json(event);
  } catch (error: any) {
    console.error('[Events] Failed to create event:', error.message, error.stack);
    res.status(500).json({ error: 'Failed to create event', details: error.message });
  }
});

// Update event
router.put('/events/:id', requirePermission('events', 'edit'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { Event } = getModels();

    const event = await Event.findById(id);
    if (!event) {
      res.status(404).json({ error: 'Event not found' });
      return;
    }

    if (!req.user!.companyIds.includes(event.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    // Validate startTime < endTime when updating time fields
    const newStartTime = req.body.startTime ?? event.startTime;
    const newEndTime = req.body.endTime ?? event.endTime;
    if (newStartTime && newEndTime && newStartTime >= newEndTime) {
      res.status(400).json({ error: 'End Time must be after Start Time' });
      return;
    }

    // Validate eventDate is not in the past ONLY when the client is actually
    // changing it to a new value. Re-sending the event's existing (already past)
    // date on an edit must NOT block the update — otherwise past/ongoing events
    // become impossible to edit (status, priority, details, etc.), which was the
    // root cause of edits silently failing (#72/#73/#74).
    if (req.body.eventDate !== undefined && req.body.eventDate !== event.eventDate) {
      const today = new Date().toISOString().split('T')[0];
      if (req.body.eventDate && req.body.eventDate < today) {
        res.status(400).json({ error: 'Event Date cannot be in the past' });
        return;
      }
    }

    // Validate duration is not negative when updating
    const newDuration = req.body.duration ?? event.duration;
    if (newDuration) {
      const durationNum = parseInt(newDuration);
      if (!isNaN(durationNum) && durationNum < 0) {
        res.status(400).json({ error: 'Duration cannot be negative' });
        return;
      }
    }

    Object.assign(event, req.body, { updatedAt: new Date() });
    await event.save();
    res.json(event);
  } catch (error) {
    res.status(500).json({ error: 'Failed to update event' });
  }
});

// Delete event (cascade: delete sessions and resources)
router.delete('/events/:id', requirePermission('events', 'delete'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { Event, EventSession, EventResource } = getModels();

    const event = await Event.findById(id);
    if (!event) {
      res.status(404).json({ error: 'Event not found' });
      return;
    }

    if (!req.user!.companyIds.includes(event.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    await EventSession.deleteMany({ eventId: id });
    await EventResource.deleteMany({ eventId: id });
    await Event.findByIdAndDelete(id);
    res.json({ message: 'Event deleted' });
  } catch (error) {
    res.status(500).json({ error: 'Failed to delete event' });
  }
});

// ============================================
// SESSION ROUTES
// ============================================

// List sessions for an event
router.get('/sessions/:eventId', async (req: Request, res: Response) => {
  try {
    const { eventId } = req.params;
    const { EventSession, Event } = getModels();

    const event = await Event.findById(eventId);
    if (!event) {
      res.status(404).json({ error: 'Event not found' });
      return;
    }

    if (!req.user!.companyIds.includes(event.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    const sessions = await EventSession.find({ eventId }).sort({ order: 1, createdAt: 1 });
    res.json(sessions);
  } catch (error) {
    res.status(500).json({ error: 'Failed to get sessions' });
  }
});

// Get single session
router.get('/sessions/detail/:id', async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventSession } = getModels();

    const session = await EventSession.findById(id);
    if (!session) {
      res.status(404).json({ error: 'Session not found' });
      return;
    }

    if (!req.user!.companyIds.includes(session.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    res.json(session);
  } catch (error) {
    res.status(500).json({ error: 'Failed to get session' });
  }
});

// Create session
router.post('/sessions', requirePermission('events', 'create'), [
  body('title').trim().notEmpty().withMessage('Title is required'),
  body('eventId').notEmpty().withMessage('Event ID is required'),
  body('companyId').notEmpty().withMessage('Company ID is required'),
], async (req: Request, res: Response) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      res.status(400).json({ errors: errors.array() });
      return;
    }

    const { EventSession } = getModels();
    const session = new EventSession(req.body);
    await session.save();
    res.status(201).json(session);
  } catch (error) {
    res.status(500).json({ error: 'Failed to create session' });
  }
});

// Update session
router.put('/sessions/:id', requirePermission('events', 'edit'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventSession } = getModels();

    const session = await EventSession.findById(id);
    if (!session) {
      res.status(404).json({ error: 'Session not found' });
      return;
    }

    if (!req.user!.companyIds.includes(session.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    Object.assign(session, req.body, { updatedAt: new Date() });
    await session.save();
    res.json(session);
  } catch (error) {
    res.status(500).json({ error: 'Failed to update session' });
  }
});

// Delete session (cascade: delete resources)
router.delete('/sessions/:id', requirePermission('events', 'delete'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventSession, EventResource } = getModels();

    const session = await EventSession.findById(id);
    if (!session) {
      res.status(404).json({ error: 'Session not found' });
      return;
    }

    if (!req.user!.companyIds.includes(session.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    await EventResource.deleteMany({ sessionId: id });
    await EventSession.findByIdAndDelete(id);
    res.json({ message: 'Session deleted' });
  } catch (error) {
    res.status(500).json({ error: 'Failed to delete session' });
  }
});

// Reorder sessions
router.put('/sessions/reorder/:eventId', requirePermission('events', 'edit'), async (req: Request, res: Response) => {
  try {
    const { eventId } = req.params;
    const { orders } = req.body as { orders: { id: string; order: number }[] };
    const { EventSession, Event } = getModels();

    const event = await Event.findById(eventId);
    if (!event) {
      res.status(404).json({ error: 'Event not found' });
      return;
    }

    if (!req.user!.companyIds.includes(event.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    for (const { id, order } of orders) {
      await EventSession.findByIdAndUpdate(id, { order });
    }

    const sessions = await EventSession.find({ eventId }).sort({ order: 1 });
    res.json(sessions);
  } catch (error) {
    res.status(500).json({ error: 'Failed to reorder sessions' });
  }
});

// Update checklist items for a session
router.put('/sessions/:id/checklist', requirePermission('events', 'edit'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { checklistItems } = req.body as { checklistItems: any[] };
    const { EventSession } = getModels();

    const session = await EventSession.findById(id);
    if (!session) {
      res.status(404).json({ error: 'Session not found' });
      return;
    }

    if (!req.user!.companyIds.includes(session.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    session.checklistItems = checklistItems;
    session.updatedAt = new Date();
    await session.save();
    res.json(session);
  } catch (error) {
    res.status(500).json({ error: 'Failed to update checklist' });
  }
});

// ============================================
// RESOURCE ROUTES
// ============================================

// List resources for an event
router.get('/resources/:eventId', async (req: Request, res: Response) => {
  try {
    const { eventId } = req.params;
    const { EventResource, Event } = getModels();

    const event = await Event.findById(eventId);
    if (!event) {
      res.status(404).json({ error: 'Event not found' });
      return;
    }

    if (!req.user!.companyIds.includes(event.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    const resources = await EventResource.find({ eventId }).sort({ order: 1, createdAt: 1 });
    res.json(resources);
  } catch (error) {
    res.status(500).json({ error: 'Failed to get resources' });
  }
});

// Get single resource
router.get('/resources/detail/:id', async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventResource } = getModels();

    const resource = await EventResource.findById(id);
    if (!resource) {
      res.status(404).json({ error: 'Resource not found' });
      return;
    }

    if (!req.user!.companyIds.includes(resource.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    res.json(resource);
  } catch (error) {
    res.status(500).json({ error: 'Failed to get resource' });
  }
});

// Create resource
router.post('/resources', requirePermission('events', 'create'), [
  body('title').trim().notEmpty().withMessage('Title is required'),
  body('eventId').notEmpty().withMessage('Event ID is required'),
  body('companyId').notEmpty().withMessage('Company ID is required'),
], async (req: Request, res: Response) => {
  try {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      res.status(400).json({ errors: errors.array() });
      return;
    }

    const { EventResource } = getModels();
    const resource = new EventResource(req.body);
    await resource.save();
    res.status(201).json(resource);
  } catch (error) {
    res.status(500).json({ error: 'Failed to create resource' });
  }
});

// Update resource
router.put('/resources/:id', requirePermission('events', 'edit'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventResource } = getModels();

    const resource = await EventResource.findById(id);
    if (!resource) {
      res.status(404).json({ error: 'Resource not found' });
      return;
    }

    if (!req.user!.companyIds.includes(resource.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    Object.assign(resource, req.body, { updatedAt: new Date() });
    await resource.save();
    res.json(resource);
  } catch (error) {
    res.status(500).json({ error: 'Failed to update resource' });
  }
});

// Delete resource
router.delete('/resources/:id', requirePermission('events', 'delete'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { EventResource } = getModels();

    const resource = await EventResource.findById(id);
    if (!resource) {
      res.status(404).json({ error: 'Resource not found' });
      return;
    }

    if (!req.user!.companyIds.includes(resource.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    await EventResource.findByIdAndDelete(id);
    res.json({ message: 'Resource deleted' });
  } catch (error) {
    res.status(500).json({ error: 'Failed to delete resource' });
  }
});

// Reorder resources
router.put('/resources/reorder/:sessionId', requirePermission('events', 'edit'), async (req: Request, res: Response) => {
  try {
    const { sessionId } = req.params;
    const { orders } = req.body as { orders: { id: string; order: number }[] };
    const { EventResource, EventSession } = getModels();

    const session = await EventSession.findById(sessionId);
    if (!session) {
      res.status(404).json({ error: 'Session not found' });
      return;
    }

    if (!req.user!.companyIds.includes(session.companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    for (const { id, order } of orders) {
      await EventResource.findByIdAndUpdate(id, { order });
    }

    const resources = await EventResource.find({ sessionId }).sort({ order: 1 });
    res.json(resources);
  } catch (error) {
    res.status(500).json({ error: 'Failed to reorder resources' });
  }
});

// ============================================
// AI GENERATION ROUTES
// ============================================

async function generateEventAI(prompt: string, systemPrompt: string, userId?: string): Promise<string> {
  const result = await generateWithAI(prompt, systemPrompt, 4000, undefined, undefined, undefined, undefined, userId);
  let cleaned = result.content.trim();
  cleaned = cleaned.replace(/```json\n?|```\n?/g, '').trim();
  return cleaned;
}

const AI_SYSTEM_PROMPT = 'You are an expert event planner and business coordinator. Generate professional event content for enterprise use. Always respond with valid JSON when structured data is requested. Use British English spelling. Be concise and professional.';

// Generate event description
router.post('/ai/generate-description', requirePermission('events', 'ai-generate'), async (req: Request, res: Response) => {
  try {
    const { title, brief, eventType, eventMode, difficulty, companyId } = req.body;
    if (!title) {
      res.status(400).json({ error: 'Title is required' });
      return;
    }

    const prompt = `Generate a professional event description for a business event with the following details:
Title: ${title}
${brief ? `Brief: ${brief}` : ''}
${eventType ? `Event Type: ${eventType}` : ''}
${eventMode ? `Event Mode: ${eventMode}` : ''}

Generate a JSON object with these fields:
- shortDescription (max 200 characters)
- detailedDescription (2-3 paragraphs)
- summary (1-2 sentences)
- objectives (array of 3-5 learning/business objectives)
- expectedOutcomes (array of 3-5 expected outcomes)`;

    const result = await generateEventAI(prompt, AI_SYSTEM_PROMPT);
    res.json({ content: result });
  } catch (error: any) {
    res.status(500).json({ error: error.message || 'AI generation failed' });
  }
});

// Generate event agenda/sessions
router.post('/ai/generate-agenda', requirePermission('events', 'ai-generate'), async (req: Request, res: Response) => {
  try {
    const { title, description, objectives, format, companyId } = req.body;
    if (!title) {
      res.status(400).json({ error: 'Title is required' });
      return;
    }

    const prompt = `Generate a structured event agenda/sessions for:
Title: ${title}
${description ? `Description: ${description}` : ''}
${objectives ? `Objectives: ${objectives}` : ''}
${format ? `Format: ${format}` : ''}

Generate a JSON array of session objects, each with:
- title (string)
- description (string, 1-2 sentences)
- duration (string, e.g., "30 min")
- speakerInfo (string, suggested speaker role)
- objectives (array of 2-3 strings)
- checklistItems (array of {text, order} objects for planning tasks)`;

    const result = await generateEventAI(prompt, AI_SYSTEM_PROMPT);
    res.json({ content: result });
  } catch (error: any) {
    res.status(500).json({ error: error.message || 'AI generation failed' });
  }
});

// Generate event checklist
router.post('/ai/generate-checklist', requirePermission('events', 'ai-generate'), async (req: Request, res: Response) => {
  try {
    const { title, eventType, eventMode, companyId } = req.body;
    if (!title) {
      res.status(400).json({ error: 'Title is required' });
      return;
    }

    const prompt = `Generate a pre-event planning checklist for:
Title: ${title}
${eventType ? `Event Type: ${eventType}` : ''}
${eventMode ? `Event Mode: ${eventMode}` : ''}

Generate a JSON array of checklist item objects, each with:
- text (string, the task description)
- order (number, starting from 1)
Organize items chronologically from planning to execution.`;

    const result = await generateEventAI(prompt, AI_SYSTEM_PROMPT);
    res.json({ content: result });
  } catch (error: any) {
    res.status(500).json({ error: error.message || 'AI generation failed' });
  }
});

// Generate minutes of meeting
router.post('/ai/generate-mom', requirePermission('events', 'ai-generate'), async (req: Request, res: Response) => {
  try {
    const { title, eventDate, notes, attendees, companyId } = req.body;
    if (!title) {
      res.status(400).json({ error: 'Title is required' });
      return;
    }

    const prompt = `Generate professional Minutes of Meeting (MoM) for:
Event: ${title}
${eventDate ? `Date: ${eventDate}` : ''}
${attendees ? `Attendees: ${attendees}` : ''}
${notes ? `Raw Notes: ${notes}` : ''}

Generate a JSON object with:
- summary (string, 2-3 sentence overview)
- keyDecisions (array of strings)
- actionItems (array of {task, assignee, deadline} objects)
- followUps (array of strings)
- nextSteps (array of strings)`;

    const result = await generateEventAI(prompt, AI_SYSTEM_PROMPT);
    res.json({ content: result });
  } catch (error: any) {
    res.status(500).json({ error: error.message || 'AI generation failed' });
  }
});

// Enhance event content
router.post('/ai/enhance-content', requirePermission('events', 'ai-generate'), async (req: Request, res: Response) => {
  try {
    const { content, enhancementType, title, companyId } = req.body;
    if (!content) {
      res.status(400).json({ error: 'Content is required' });
      return;
    }

    const typeInstructions: Record<string, string> = {
      grammar: 'Improve grammar, spelling, and punctuation while keeping the original meaning.',
      tone: 'Rewrite with a professional business tone appropriate for enterprise communication.',
      expand: 'Expand the content with more detail, examples, and supporting information.',
      simplify: 'Simplify the content while preserving key information, make it concise and clear.',
      format: 'Reformat the content with proper structure, headings, bullet points, and formatting.',
      keypoints: 'Extract the key points and create a structured summary.',
      mom: 'Transform the content into a formal Minutes of Meeting format.',
    };

    const instruction = typeInstructions[enhancementType] || typeInstructions.grammar;
    const prompt = `${instruction}\n\n${title ? `Title: ${title}\n\n` : ''}Content:\n${content}`;

    const result = await generateEventAI(prompt, AI_SYSTEM_PROMPT);
    res.json({ content: result });
  } catch (error: any) {
    res.status(500).json({ error: error.message || 'AI generation failed' });
  }
});

export default router;