apps/backend/src/routes/approvals.ts

/**
 * Human Approval API Routes
 * Provides UI/API for approving/rejecting pending requests
 */

import { Router, Request, Response } from 'express';
import { humanApprovalService } from '../services/HumanApprovalService.js';

const router = Router();

/**
 * GET /api/approvals/pending
 * Get all pending approval requests
 */
router.get('/pending', (req: Request, res: Response) => {
    try {
        const pending = humanApprovalService.getPendingRequests();

        res.json({
            success: true,
            count: pending.length,
            requests: pending,
        });
    } catch (error: any) {
        res.status(500).json({
            success: false,
            error: error.message,
        });
    }
});

/**
 * GET /api/approvals/:requestId
 * Get specific approval request
 */
router.get('/:requestId', (req: Request, res: Response) => {
    try {
        const { requestId } = req.params;
        const request = humanApprovalService.getRequest(requestId);

        if (!request) {
            return res.status(404).json({
                success: false,
                error: 'Approval request not found',
            });
        }

        res.json({
            success: true,
            request,
        });
    } catch (error: any) {
        res.status(500).json({
            success: false,
            error: error.message,
        });
    }
});

/**
 * POST /api/approvals/:requestId/approve
 * Approve a pending request
 */
router.post('/:requestId/approve', (req: Request, res: Response) => {
    try {
        const { requestId } = req.params;
        const { approvedBy } = req.body;

        if (!approvedBy) {
            return res.status(400).json({
                success: false,
                error: 'approvedBy is required',
            });
        }

        const success = humanApprovalService.approve(requestId, approvedBy);

        if (!success) {
            return res.status(400).json({
                success: false,
                error: 'Failed to approve request. It may be expired or already processed.',
            });
        }

        const request = humanApprovalService.getRequest(requestId);

        res.json({
            success: true,
            message: 'Request approved',
            request,
        });
    } catch (error: any) {
        res.status(500).json({
            success: false,
            error: error.message,
        });
    }
});

/**
 * POST /api/approvals/:requestId/reject
 * Reject a pending request
 */
router.post('/:requestId/reject', (req: Request, res: Response) => {
    try {
        const { requestId } = req.params;
        const { rejectedBy, reason } = req.body;

        if (!rejectedBy || !reason) {
            return res.status(400).json({
                success: false,
                error: 'rejectedBy and reason are required',
            });
        }

        const success = humanApprovalService.reject(requestId, rejectedBy, reason);

        if (!success) {
            return res.status(400).json({
                success: false,
                error: 'Failed to reject request. It may be expired or already processed.',
            });
        }

        const request = humanApprovalService.getRequest(requestId);

        res.json({
            success: true,
            message: 'Request rejected',
            request,
        });
    } catch (error: any) {
        res.status(500).json({
            success: false,
            error: error.message,
        });
    }
});

/**
 * GET /api/approvals/history
 * Get approval history
 */
router.get('/history/all', (req: Request, res: Response) => {
    try {
        const limit = parseInt(req.query.limit as string) || 50;
        const history = humanApprovalService.getHistory(limit);

        res.json({
            success: true,
            count: history.length,
            requests: history,
        });
    } catch (error: any) {
        res.status(500).json({
            success: false,
            error: error.message,
        });
    }
});

export default router;