admin.routes.ts

/**
 * Admin API Routes
 * Provides endpoints for administrative operations
 */

import { Router, Request, Response } from 'express';
import { AdminService } from '../services/admin.service';
import { logger } from '../utils/logger';

const router = Router();
const adminService = new AdminService();

/**
 * GET /api/v1/admin/datasets
 * List all datasets with summary statistics
 */
router.get('/datasets', async (_req: Request, res: Response): Promise<void> => {
  try {
    const datasets = await adminService.listDatasets();
    res.json({ datasets });
  } catch (error) {
    logger.error('Failed to list datasets', { error });
    res.status(500).json({
      error: 'Failed to list datasets',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
});

/**
 * GET /api/v1/admin/datasets/:datasetId
 * Get detailed information about a specific dataset
 */
router.get('/datasets/:datasetId', async (req: Request, res: Response): Promise<void> => {
  try {
    const { datasetId } = req.params;

    const dataset = await adminService.getDatasetDetails(datasetId);

    if (!dataset) {
      res.status(404).json({
        error: 'Dataset not found',
        message: `No dataset found with ID: ${datasetId}`,
      });
      return;
    }

    res.json(dataset);
  } catch (error) {
    logger.error('Failed to get dataset details', { error });
    res.status(500).json({
      error: 'Failed to get dataset details',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
});

/**
 * GET /api/v1/admin/documents
 * List documents with optional filtering
 * Query params: datasetId, status, limit, offset
 */
router.get('/documents', async (req: Request, res: Response): Promise<void> => {
  try {
    const { datasetId, status, limit, offset } = req.query;

    const limitNum = limit ? parseInt(limit as string) : 50;
    const offsetNum = offset ? parseInt(offset as string) : 0;

    if (isNaN(limitNum) || limitNum < 1 || limitNum > 200) {
      res.status(400).json({
        error: 'Invalid limit parameter',
        message: 'Limit must be between 1 and 200',
      });
      return;
    }

    if (isNaN(offsetNum) || offsetNum < 0) {
      res.status(400).json({
        error: 'Invalid offset parameter',
        message: 'Offset must be non-negative',
      });
      return;
    }

    const result = await adminService.listDocuments(
      datasetId as string | undefined,
      status as string | undefined,
      limitNum,
      offsetNum
    );

    res.json(result);
  } catch (error) {
    logger.error('Failed to list documents', { error });
    res.status(500).json({
      error: 'Failed to list documents',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
});

/**
 * GET /api/v1/admin/documents/:documentId
 * Get detailed information about a specific document
 */
router.get('/documents/:documentId', async (req: Request, res: Response): Promise<void> => {
  try {
    const { documentId } = req.params;

    const document = await adminService.getDocumentDetails(documentId);

    if (!document) {
      res.status(404).json({
        error: 'Document not found',
        message: `No document found with ID: ${documentId}`,
      });
      return;
    }

    res.json(document);
  } catch (error) {
    logger.error('Failed to get document details', { error });
    res.status(500).json({
      error: 'Failed to get document details',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
});

/**
 * POST /api/v1/admin/documents/:documentId/reprocess
 * Trigger manual reprocessing of a document
 * Body: { fromStage?: string }
 */
router.post('/documents/:documentId/reprocess', async (req: Request, res: Response): Promise<void> => {
  try {
    const { documentId } = req.params;
    const { fromStage } = req.body;

    // Validate fromStage if provided
    const validStages = [
      'language_detection',
      'ocr',
      'chunking',
      'embedding',
      'table_extraction',
      'indexing',
    ];

    if (fromStage && !validStages.includes(fromStage)) {
      res.status(400).json({
        error: 'Invalid stage',
        message: `Stage must be one of: ${validStages.join(', ')}`,
      });
      return;
    }

    await adminService.reprocessDocument(documentId, fromStage);

    res.json({
      message: 'Document reprocessing triggered',
      documentId,
      fromStage: fromStage || 'language_detection',
    });
  } catch (error) {
    logger.error('Failed to reprocess document', { error });
    
    if (error instanceof Error && error.message.includes('not found')) {
      res.status(404).json({
        error: 'Document not found',
        message: error.message,
      });
      return;
    }

    if (error instanceof Error && error.message.includes('currently being processed')) {
      res.status(409).json({
        error: 'Document is being processed',
        message: error.message,
      });
      return;
    }

    res.status(500).json({
      error: 'Failed to reprocess document',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
});

/**
 * DELETE /api/v1/admin/documents/:documentId
 * Delete a document and all its associated data
 */
router.delete('/documents/:documentId', async (req: Request, res: Response): Promise<void> => {
  try {
    const { documentId } = req.params;

    await adminService.deleteDocument(documentId);

    res.json({
      message: 'Document deleted successfully',
      documentId,
    });
  } catch (error) {
    logger.error('Failed to delete document', { error });
    res.status(500).json({
      error: 'Failed to delete document',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
});

/**
 * GET /api/v1/admin/jobs
 * Get recent job history
 * Query params: limit, offset
 */
router.get('/jobs', async (req: Request, res: Response): Promise<void> => {
  try {
    const { limit, offset } = req.query;

    const limitNum = limit ? parseInt(limit as string) : 100;
    const offsetNum = offset ? parseInt(offset as string) : 0;

    if (isNaN(limitNum) || limitNum < 1 || limitNum > 500) {
      res.status(400).json({
        error: 'Invalid limit parameter',
        message: 'Limit must be between 1 and 500',
      });
      return;
    }

    if (isNaN(offsetNum) || offsetNum < 0) {
      res.status(400).json({
        error: 'Invalid offset parameter',
        message: 'Offset must be non-negative',
      });
      return;
    }

    const result = await adminService.getJobHistory(limitNum, offsetNum);

    res.json(result);
  } catch (error) {
    logger.error('Failed to get job history', { error });
    res.status(500).json({
      error: 'Failed to get job history',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
});

/**
 * GET /api/v1/admin/stats
 * Get system-wide statistics
 */
router.get('/stats', async (_req: Request, res: Response): Promise<void> => {
  try {
    const stats = await adminService.getSystemStats();
    res.json(stats);
  } catch (error) {
    logger.error('Failed to get system stats', { error });
    res.status(500).json({
      error: 'Failed to get system stats',
      message: error instanceof Error ? error.message : 'Unknown error',
    });
  }
});

export default router;