import ScanModel from '../../models/Scan';
import UserModel from '../../models/User';
import QRCodeModel from '../../models/QrCode';
import AuditLogModel from '../../models/AuditLog';
import { Types } from 'mongoose';
import fs from 'fs';
import path from 'path';
import { PDFGenerationService } from '../../services/pdf-generation.service';
interface MetricsData {
    totalScans: number;
    activeUsers: number;
    qrCodes: number;
    averageDailyScans: number;
    topQRCode: {
        id: string;
        title: string;
        scanCount: number;
        trend: {
            direction: 'up' | 'down' | 'stable';
            percentage: number;
            previousPeriodCount: number;
        };
    };
    totalScansBreakdown: Array<{
        period: string;
        count: number;
        percentage: number;
        timestamp: string;
    }>;
}

interface TimePeriodConfig {
    days: number;
    label: string;
    aggregation: 'day' | 'week' | 'month';
}

type TimePeriodType = '1d' | '7d' | '30d' | '1y';

export class AdminRepository {



    /**
     * Main orchestrator: Generates a PDF report stream with time period filtering
     */
    public static async getPdfReportStream(
        timePeriod: '1d' | '7d' | '30d' | '1y' = '30d',
        dateRange?: { startDate?: Date; endDate?: Date; year?: number }
    ): Promise<Buffer> {
        try {
            // If year is provided, set timePeriod to '1y'
            let effectiveTimePeriod: TimePeriodType = timePeriod;
            if (dateRange?.year) {
                effectiveTimePeriod = '1y';
            }

            // Validate and handle time period
            const validation = this.handleErrorsAndValidation(effectiveTimePeriod, dateRange);
            if (!validation.valid) {
                throw new Error(validation.error);
            }

            const config = this.getTimePeriodConfig(effectiveTimePeriod, dateRange?.year);
            const { startDate, endDate } = this.calculateDateRange(effectiveTimePeriod, dateRange);

            // Calculate all metrics
            const metrics = await this.calculateMetrics(startDate, endDate, config);

            // Generate PDF from HTML template
            return await this.generateAdminReportPdf('business-report', {
                ...metrics,
                periodLabel: config.label,
                dateRange: `${startDate.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })} - ${endDate.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })}`,
                generatedAt: new Date().toLocaleString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: true }),
            });
        } catch (error: any) {
            console.error('PDF generation error:', error);
            throw new Error(`PDF generation failed: ${error.message}`);
        }
    }

    /**
     * Private: Calculate date range based on time period or year
     */
    private static calculateDateRange(
        timePeriod: TimePeriodType,
        dateRange?: { startDate?: Date; endDate?: Date; year?: number }
    ): { startDate: Date; endDate: Date } {
        // If year is provided, filter by entire year
        if (dateRange?.year) {
            const year = dateRange.year;
            const startDate = new Date(year, 0, 1); // January 1st
            startDate.setHours(0, 0, 0, 0);

            const endDate = new Date(year, 11, 31); // December 31st
            endDate.setHours(23, 59, 59, 999);

            return { startDate, endDate };
        }

        // If explicit dates are provided, use them
        if (dateRange?.startDate && dateRange?.endDate) {
            const startDate = new Date(dateRange.startDate);
            startDate.setHours(0, 0, 0, 0);

            const endDate = new Date(dateRange.endDate);
            endDate.setHours(23, 59, 59, 999);

            return { startDate, endDate };
        }

        // Handle yearly period
        if (timePeriod === '1y') {
            const year = dateRange?.year || new Date().getFullYear();
            const startDate = new Date(year, 0, 1); // January 1st
            startDate.setHours(0, 0, 0, 0);

            const endDate = new Date(year, 11, 31); // December 31st
            endDate.setHours(23, 59, 59, 999);

            return { startDate, endDate };
        }

        // Otherwise, use time period logic
        const endDate = dateRange?.endDate || new Date();
        endDate.setHours(23, 59, 59, 999);

        let startDate: Date;
        if (dateRange?.startDate) {
            startDate = new Date(dateRange.startDate);
            startDate.setHours(0, 0, 0, 0);
        } else {
            startDate = new Date(endDate);
            const days = timePeriod === '1d' ? 1 : timePeriod === '7d' ? 7 : 30;
            startDate.setDate(startDate.getDate() - days);
            startDate.setHours(0, 0, 0, 0);
        }

        return { startDate, endDate };
    }

    /**
     * Private: Get time period configuration
     */
    private static getTimePeriodConfig(timePeriod: TimePeriodType, year?: number): TimePeriodConfig {
        if (timePeriod === '1y') {
            return {
                days: 365,
                label: year ? `Year ${year}` : '1 Year',
                aggregation: 'month', // Aggregate by month for yearly reports
            };
        }

        const configs: Record<'1d' | '7d' | '30d', TimePeriodConfig> = {
            '1d': { days: 1, label: '1 Day', aggregation: 'day' },
            '7d': { days: 7, label: '7 Days', aggregation: 'day' },
            '30d': { days: 30, label: '30 Days', aggregation: 'day' },
        };
        return configs[timePeriod];
    }

    /**
     * Private: Calculate all metrics efficiently with optimized queries
     */
    private static async calculateMetrics(
        startDate: Date,
        endDate: Date,
        config: TimePeriodConfig
    ): Promise<MetricsData> {
        // Parallel queries for performance
        const [scans, activeUsers, qrCodes, totalScansBreakdown, topQRCodeData] = await Promise.all([
            // Total scans count
            ScanModel.countDocuments({
                createdAt: { $gte: startDate, $lte: endDate },
            }),

            // Active users (users who have scans in the period)
            ScanModel.distinct('scanned_by', {
                createdAt: { $gte: startDate, $lte: endDate },
                scanned_by: { $ne: null },
            }),

            // QR Codes count (active QR codes in the period)
            QRCodeModel.countDocuments({
                status: 'ACTIVE',
                isDelete: false,
                $or: [
                    { createdAt: { $gte: startDate, $lte: endDate } },
                    { created_at: { $gte: startDate, $lte: endDate } },
                ],
            }),

            // Total Scans breakdown by period
            this.getTotalScansBreakdown(startDate, endDate, config),

            // Top QR Code with trend
            this.getTopQRCodeWithTrend(startDate, endDate, config),
        ]);

        const daysDiff = Math.ceil((endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24)) || 1;
        const averageDailyScans = Math.round(scans / daysDiff);

        return {
            totalScans: scans,
            activeUsers: activeUsers.length,
            qrCodes,
            averageDailyScans,
            topQRCode: topQRCodeData,
            totalScansBreakdown,
        };
    }

    /**
     * Private: Get Total Scans breakdown by period (daily/weekly/monthly)
     */
    private static async getTotalScansBreakdown(
        startDate: Date,
        endDate: Date,
        config: TimePeriodConfig
    ): Promise<MetricsData['totalScansBreakdown']> {
        const format = config.aggregation === 'day' ? '%Y-%m-%d' : config.aggregation === 'week' ? '%Y-W%V' : '%Y-%m';

        const breakdown: Array<{ _id: string; count: number }> = await ScanModel.aggregate([
            {
                $match: {
                    createdAt: { $gte: startDate, $lte: endDate },
                },
            },
            {
                $group: {
                    _id: {
                        $dateToString: {
                            format,
                            date: '$createdAt',
                            timezone: 'UTC',
                        },
                    },
                    count: { $sum: 1 },
                },
            },
            {
                $sort: { _id: 1 },
            },
        ]);

        const total = breakdown.reduce((sum: number, item: any) => sum + item.count, 0);

        return breakdown.map((item: any) => ({
            period: item._id,
            count: item.count,
            percentage: total > 0 ? Math.round((item.count / total) * 100 * 100) / 100 : 0,
            timestamp: new Date().toISOString(),
        }));
    }

    /**
     * Private: Get Top QR Code with trend analytics
     */
    private static async getTopQRCodeWithTrend(
        startDate: Date,
        endDate: Date,
        config: TimePeriodConfig
    ): Promise<MetricsData['topQRCode']> {
        // Calculate previous period for comparison
        const periodDuration = endDate.getTime() - startDate.getTime();
        const previousEndDate = new Date(startDate);
        previousEndDate.setTime(previousEndDate.getTime() - 1);
        const previousStartDate = new Date(previousEndDate);
        previousStartDate.setTime(previousStartDate.getTime() - periodDuration);

        // Get top QR code in current period
        const topQRCodeCurrent = await ScanModel.aggregate([
            {
                $match: {
                    createdAt: { $gte: startDate, $lte: endDate },
                },
            },
            {
                $group: {
                    _id: '$qrcode_id',
                    scanCount: { $sum: 1 },
                },
            },
            {
                $sort: { scanCount: -1 },
            },
            {
                $limit: 1,
            },
        ]);

        if (!topQRCodeCurrent || topQRCodeCurrent.length === 0) {
            return {
                id: 'N/A',
                title: 'No QR Code Data',
                scanCount: 0,
                trend: {
                    direction: 'stable',
                    percentage: 0,
                    previousPeriodCount: 0,
                },
            };
        }

        const topQRCodeId = topQRCodeCurrent[0]._id;
        const currentCount = topQRCodeCurrent[0].scanCount;

        // Get same QR code's count in previous period
        const previousPeriodData = await ScanModel.aggregate([
            {
                $match: {
                    qrcode_id: topQRCodeId,
                    createdAt: { $gte: previousStartDate, $lte: previousEndDate },
                },
            },
            {
                $group: {
                    _id: '$qrcode_id',
                    scanCount: { $sum: 1 },
                },
            },
        ]);

        const previousCount = previousPeriodData.length > 0 ? previousPeriodData[0].scanCount : 0;

        // Calculate trend
        let direction: 'up' | 'down' | 'stable' = 'stable';
        let percentage = 0;

        if (previousCount > 0) {
            percentage = Math.round(((currentCount - previousCount) / previousCount) * 100 * 100) / 100;
            direction = percentage > 0 ? 'up' : percentage < 0 ? 'down' : 'stable';
        } else if (currentCount > 0) {
            direction = 'up';
            percentage = 100;
        }

        // Get QR code details
        const qrCode = await QRCodeModel.findById(topQRCodeId).select('title').lean() as { title?: string } | null;

        return {
            id: topQRCodeId.toString(),
            title: qrCode?.title || 'Unknown QR Code',
            scanCount: currentCount,
            trend: {
                direction,
                percentage: Math.abs(percentage),
                previousPeriodCount: previousCount,
            },
        };
    }

    /**
     * Private: Format number with comma separators
     */
    private static formatNumber(num: number): string {
        return num.toLocaleString('en-US');
    }

    /**
     * Private: Generate admin report PDF using jsPDF
     */
    private static async generateAdminReportPdf(templateName: string, data: any): Promise<Buffer> {
        try {
            // Use the PDF generation service
            return await PDFGenerationService.generateAdminBusinessReport(data);
        } catch (error: any) {
            console.error('Admin report PDF generation error:', error);
            throw new Error(`Failed to generate admin report PDF: ${error.message}`);
        }
    }

    /**
     * Private: Generate PDF from HTML template using shared Piscina worker pool
     */
    private static async generatePdfFromTemplate(templateName: string, data: any): Promise<Buffer> {
        return await this.generateAdminReportPdf(templateName, data);
    }

    /**
     * Main orchestrator: Generates a PDF report stream for user behavior analytics
     */
    public static async getUserBehaviorPdfReportStream(
        timePeriod: TimePeriodType = '30d',
        dateRange?: { startDate?: Date; endDate?: Date; year?: number }
    ): Promise<Buffer> {
        try {
            // If year is provided, set timePeriod to '1y'
            let effectiveTimePeriod: TimePeriodType = timePeriod;
            if (dateRange?.year) {
                effectiveTimePeriod = '1y';
            }

            // Validate and handle time period
            const validation = this.handleErrorsAndValidation(effectiveTimePeriod, dateRange);
            if (!validation.valid) {
                throw new Error(validation.error);
            }

            const config = this.getTimePeriodConfig(effectiveTimePeriod, dateRange?.year);
            const { startDate, endDate } = this.calculateDateRange(effectiveTimePeriod, dateRange);

            // Calculate all user behavior metrics
            const behaviorMetrics = await this.calculateUserBehaviorMetrics(startDate, endDate, config);

            // Generate PDF from HTML template
            return await this.generateUserBehaviorPdf('user-behavior-report', {
                ...behaviorMetrics,
                periodLabel: config.label,
                dateRange: `${startDate.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })} - ${endDate.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })}`,
                generatedAt: new Date().toLocaleString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: true }),
            });
        } catch (error: any) {
            console.error('User behavior PDF generation error:', error);
            throw new Error(`User behavior PDF generation failed: ${error.message}`);
        }
    }

    /**
     * Private: Generate user behavior report PDF using jsPDF
     */
    private static async generateUserBehaviorPdf(templateName: string, data: any): Promise<Buffer> {
        try {
            // Use the PDF generation service
            return await PDFGenerationService.generateUserBehaviorReport(data);
        } catch (error: any) {
            console.error('User behavior PDF generation error:', error);
            throw new Error(`Failed to generate user behavior PDF: ${error.message}`);
        }
    }


    /**
     * Private: Handle errors and validation
     */
    private static handleErrorsAndValidation(
        timePeriod: string,
        dateRange?: { startDate?: Date; endDate?: Date; year?: number }
    ): { valid: boolean; error?: string } {
        // Validate time period
        if (!['1d', '7d', '30d', '1y'].includes(timePeriod)) {
            return {
                valid: false,
                error: `Invalid time period. Must be '1d', '7d', '30d', or '1y'. Received: ${timePeriod}`,
            };
        }

        // Validate dates if provided
        if (dateRange?.startDate && isNaN(dateRange.startDate.getTime())) {
            return {
                valid: false,
                error: 'Invalid startDate provided',
            };
        }

        if (dateRange?.endDate && isNaN(dateRange.endDate.getTime())) {
            return {
                valid: false,
                error: 'Invalid endDate provided',
            };
        }

        // Validate date range logic
        if (dateRange?.startDate && dateRange?.endDate) {
            if (dateRange.startDate > dateRange.endDate) {
                return {
                    valid: false,
                    error: 'startDate cannot be after endDate',
                };
            }
        }

        return { valid: true };
    }

    /**
     * Main orchestrator: Generates a PDF report stream for user behavior analytics
     */
    // public static async getUserBehaviorPdfReportStream(
    //     timePeriod: TimePeriodType = '30d',
    //     dateRange?: { startDate?: Date; endDate?: Date; year?: number }
    // ): Promise<Buffer> {
    //     try {
    //         // If year is provided, set timePeriod to '1y'
    //         let effectiveTimePeriod: TimePeriodType = timePeriod;
    //         if (dateRange?.year) {
    //             effectiveTimePeriod = '1y';
    //         }

    //         // Validate and handle time period
    //         const validation = this.handleErrorsAndValidation(effectiveTimePeriod, dateRange);
    //         if (!validation.valid) {
    //             throw new Error(validation.error);
    //         }

    //         const config = this.getTimePeriodConfig(effectiveTimePeriod, dateRange?.year);
    //         const { startDate, endDate } = this.calculateDateRange(effectiveTimePeriod, dateRange);

    //         // Calculate all user behavior metrics
    //         const behaviorMetrics = await this.calculateUserBehaviorMetrics(startDate, endDate, config);

    //         // Generate PDF from HTML template
    //         const pdfBuffer = await this.generatePdfFromTemplate('user-behavior-report', {
    //             ...behaviorMetrics,
    //             periodLabel: config.label,
    //             dateRange: `${startDate.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })} - ${endDate.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })}`,
    //             generatedAt: new Date().toLocaleString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: true }),
    //         });

    //         return pdfBuffer;
    //     } catch (error: any) {
    //         console.error('User behavior PDF generation error:', error);
    //         throw new Error(`User behavior PDF generation failed: ${error.message}`);
    //     }
    // }

    /**
     * Private: Calculate user behavior metrics
     */
    private static async calculateUserBehaviorMetrics(
        startDate: Date,
        endDate: Date,
        config: TimePeriodConfig
    ): Promise<any> {
        // Parallel queries for performance
        const [
            loginActivity,
            userRegistrations,
            qrCodeCreations,
            scanActivity,
            profileUpdates,
            topActiveUsers,
            securityEvents,
            userEngagement,
            dailyActivity
        ] = await Promise.all([
            // Login activity
            AuditLogModel.countDocuments({
                action: 'USER_LOGIN',
                timestamp: { $gte: startDate, $lte: endDate },
                status: 'SUCCESS',
            }),

            // User registrations
            UserModel.countDocuments({
                $or: [
                    { createdAt: { $gte: startDate, $lte: endDate } },
                    { created_at: { $gte: startDate, $lte: endDate } },
                ],
                is_delete: false,
            }),

            // QR code creations
            AuditLogModel.countDocuments({
                action: 'QRCODE_CREATE',
                timestamp: { $gte: startDate, $lte: endDate },
                status: 'SUCCESS',
            }),

            // Scan activity
            ScanModel.countDocuments({
                createdAt: { $gte: startDate, $lte: endDate },
            }),

            // Profile updates
            AuditLogModel.countDocuments({
                action: 'USER_PROFILE_UPDATE',
                timestamp: { $gte: startDate, $lte: endDate },
                status: 'SUCCESS',
            }),

            // Top active users (users with most scans)
            ScanModel.aggregate([
                {
                    $match: {
                        createdAt: { $gte: startDate, $lte: endDate },
                        scanned_by: { $ne: null },
                    },
                },
                {
                    $group: {
                        _id: '$scanned_by',
                        scanCount: { $sum: 1 },
                    },
                },
                {
                    $sort: { scanCount: -1 },
                },
                {
                    $limit: 10,
                },
                {
                    $lookup: {
                        from: 'users',
                        localField: '_id',
                        foreignField: '_id',
                        as: 'user',
                    },
                },
                {
                    $unwind: {
                        path: '$user',
                        preserveNullAndEmptyArrays: true,
                    },
                },
                {
                    $project: {
                        userId: '$_id',
                        email: '$user.email',
                        name: { $ifNull: ['$user.name', 'N/A'] },
                        scanCount: 1,
                    },
                },
            ]),

            // Security events (failed logins)
            AuditLogModel.countDocuments({
                action: { $in: ['SECURITY_LOGIN_ATTEMPT_FAILED', 'SECURITY_SUSPICIOUS_ACTIVITY'] },
                timestamp: { $gte: startDate, $lte: endDate },
            }),

            // User engagement (users who performed any action)
            AuditLogModel.distinct('user_id', {
                timestamp: { $gte: startDate, $lte: endDate },
                user_id: { $ne: null },
            }),

            // Daily activity breakdown
            AuditLogModel.aggregate([
                {
                    $match: {
                        timestamp: { $gte: startDate, $lte: endDate },
                        action: { $in: ['USER_LOGIN', 'QRCODE_CREATE', 'QRCODE_SCAN'] },
                    },
                },
                {
                    $group: {
                        _id: {
                            $dateToString: {
                                format: '%Y-%m-%d',
                                date: '$timestamp',
                                timezone: 'UTC',
                            },
                        },
                        logins: {
                            $sum: { $cond: [{ $eq: ['$action', 'USER_LOGIN'] }, 1, 0] },
                        },
                        qrCreations: {
                            $sum: { $cond: [{ $eq: ['$action', 'QRCODE_CREATE'] }, 1, 0] },
                        },
                        scans: {
                            $sum: { $cond: [{ $eq: ['$action', 'QRCODE_SCAN'] }, 1, 0] },
                        },
                    },
                },
                {
                    $sort: { _id: 1 },
                },
            ]),
        ]);

        // Get profile completion rate
        const totalUsers = await UserModel.countDocuments({ is_delete: false });
        const completedProfiles = await UserModel.countDocuments({
            isProfileComplete: true,
            is_delete: false,
        });
        const profileCompletionRate = totalUsers > 0 ? (completedProfiles / totalUsers) * 100 : 0;

        // Calculate average actions per user
        const uniqueActiveUsers = userEngagement.length;
        const totalActions = loginActivity + qrCodeCreations + scanActivity;
        const avgActionsPerUser = uniqueActiveUsers > 0 ? totalActions / uniqueActiveUsers : 0;

        return {
            loginActivity,
            userRegistrations,
            qrCodeCreations,
            scanActivity,
            profileUpdates,
            topActiveUsers,
            securityEvents,
            uniqueActiveUsers,
            profileCompletionRate: Math.round(profileCompletionRate * 100) / 100,
            avgActionsPerUser: Math.round(avgActionsPerUser * 100) / 100,
            dailyActivity,
        };
    }

    /**
     * Get QR code metrics and data for PDF report
     */
    public static async getQrCodeReportData(
        mode: 'on-demand' | 'daily' | 'custom',
        qrcodeId?: string,
        startDate?: Date,
        endDate?: Date
    ): Promise<{
        totalQrCodes: number;
        totalScans: number;
        activeQrCodes: number;
        qrCodes: Array<{
            _id: string;
            title: string;
            type: string;
            status: string;
            scan_count: number;
            created_at: Date;
            created_by: any;
        }>;
        scans: Array<{
            _id: string;
            qrcode_id: any;
            qrcode_data?: {
                _id: any;
                title?: string;
                type?: string;
            };
            scanned_by: any;
            scan_location: any;
            is_anonymous: boolean;
            createdAt: Date;
        }>;
        dateRange: { startDate: Date; endDate: Date };
    }> {
        let queryStartDate: Date;
        let queryEndDate: Date = new Date();
        queryEndDate.setHours(23, 59, 59, 999);

        // Determine date range based on mode
        switch (mode) {
            case 'daily':
                // Last 30 days for daily summary
                queryStartDate = new Date();
                queryStartDate.setDate(queryStartDate.getDate() - 30);
                queryStartDate.setHours(0, 0, 0, 0);
                break;
            case 'custom':
                if (!startDate || !endDate) {
                    throw new Error('startDate and endDate are required for custom mode');
                }
                queryStartDate = new Date(startDate);
                queryStartDate.setHours(0, 0, 0, 0);
                queryEndDate = new Date(endDate);
                queryEndDate.setHours(23, 59, 59, 999);
                break;
            case 'on-demand':
            default:
                // All active QR codes
                queryStartDate = new Date(0); // Beginning of time
                queryEndDate = new Date();
                queryEndDate.setHours(23, 59, 59, 999);
                break;
        }

        // Build QR code filter
        const qrCodeFilter: any = {
            isDelete: false,
            $or: [
                { createdAt: { $gte: queryStartDate, $lte: queryEndDate } },
                { created_at: { $gte: queryStartDate, $lte: queryEndDate } },
            ],
        };

        // If specific QR code ID is provided
        if (qrcodeId && mode === 'custom') {
            if (!Types.ObjectId.isValid(qrcodeId)) {
                throw new Error('Invalid QR code ID');
            }
            qrCodeFilter._id = new Types.ObjectId(qrcodeId);
        }

        // Get QR codes with scan counts
        const qrCodes = await QRCodeModel.aggregate([
            { $match: qrCodeFilter },
            {
                $lookup: {
                    from: 'users',
                    localField: 'created_by',
                    foreignField: '_id',
                    as: 'created_by',
                    pipeline: [{ $project: { email: 1, first_name: 1, last_name: 1 } }],
                },
            },
            {
                $addFields: {
                    created_by: { $arrayElemAt: ['$created_by', 0] },
                    scan_count: { $ifNull: ['$scan_count', 0] },
                },
            },
            {
                $project: {
                    title: 1,
                    type: 1,
                    status: 1,
                    scan_count: 1,
                    created_at: { $ifNull: ['$created_at', '$createdAt'] },
                    created_by: 1,
                },
            },
            { $sort: { scan_count: -1 } },
            { $limit: 100 }, // Limit to top 100 for PDF
        ]);

        // Get total counts
        const totalQrCodes = await QRCodeModel.countDocuments({
            isDelete: false,
            $or: [
                { createdAt: { $gte: queryStartDate, $lte: queryEndDate } },
                { created_at: { $gte: queryStartDate, $lte: queryEndDate } },
            ],
        });

        const activeQrCodes = await QRCodeModel.countDocuments({
            isDelete: false,
            status: 'ACTIVE',
            $or: [
                { createdAt: { $gte: queryStartDate, $lte: queryEndDate } },
                { created_at: { $gte: queryStartDate, $lte: queryEndDate } },
            ],
        });

        // Get scan data for the QR codes
        const qrCodeIds = qrCodes.map((qc: any) => new Types.ObjectId(qc._id));
        const scanFilter: any = {
            qrcode_id: { $in: qrCodeIds },
            createdAt: { $gte: queryStartDate, $lte: queryEndDate },
        };

        const scans = await ScanModel.aggregate([
            { $match: scanFilter },
            {
                $lookup: {
                    from: 'users',
                    localField: 'scanned_by',
                    foreignField: '_id',
                    as: 'scanned_by',
                    pipeline: [{ $project: { email: 1, first_name: 1, last_name: 1 } }],
                },
            },
            {
                $lookup: {
                    from: 'qrcodes',
                    localField: 'qrcode_id',
                    foreignField: '_id',
                    as: 'qrcode_data',
                    pipeline: [{ $project: { title: 1, type: 1, _id: 1 } }],
                },
            },
            {
                $addFields: {
                    scanned_by: { $arrayElemAt: ['$scanned_by', 0] },
                    qrcode_data: { $arrayElemAt: ['$qrcode_data', 0] },
                },
            },
            { $sort: { createdAt: -1 } },
            { $limit: 500 }, // Limit scans for PDF
        ]);

        const totalScans = await ScanModel.countDocuments(scanFilter);

        return {
            totalQrCodes,
            totalScans,
            activeQrCodes,
            qrCodes,
            scans,
            dateRange: { startDate: queryStartDate, endDate: queryEndDate },
        };
    }

}
