src/controllers/errorLog.controller.ts

import { Request, Response } from "express";

import ErrorLog from "../models/errorLog";
import { FindOptions, Op } from "sequelize";
import { logger } from '../utils/logger';

const buildErrorLogWhereClause = (filter: Record<string, any>) => {
    const whereClause: any = {};
    if (filter) {
        if (filter.date) {
            const date = new Date(filter.date); 
            if (!isNaN(date.getTime())) {
                const startOfDay = new Date(date);
                startOfDay.setHours(0, 0, 0, 0);

                const endOfDay = new Date(date);
                endOfDay.setHours(23, 59, 59, 999);

                whereClause.created_at = { 
                    [Op.gte]: startOfDay, 
                    [Op.lte]: endOfDay 
                };
            }
        }

        if (filter.invoice_id) {
            whereClause.invoice_id = { [Op.eq]: filter.invoice_id };
        }

        if (filter.error_type) {
            whereClause.error_type = { [Op.eq]: filter.error_type };
        }

        if (filter.created_before) {
            const beforeDate = new Date(filter.created_before);
            if (!isNaN(beforeDate.getTime())) {
                whereClause.created_at = { ...whereClause.created_at, [Op.lte]: beforeDate };
            }
        }

        if (filter.created_after) {
            const afterDate = new Date(filter.created_after);
            if (!isNaN(afterDate.getTime())) {
                whereClause.created_at = { ...whereClause.created_at, [Op.gte]: afterDate };
            }
        }
    }

    return whereClause;
}

const getErrorLogs = async (req: Request, res: Response) => {

    try {

        const { sort_by, sort_order, page, limit } = req.query;
        const filter = req.query.filter as Record<string, any>;

        const allowedSortColumns = ['id', 'invoice_id', 'created_at'];

        const whereClause = buildErrorLogWhereClause(filter);

        const currentPage = parseInt(page as string) || 1;
        const pageSize = parseInt(limit as string) || 10;

        const options: FindOptions = {
            where: whereClause,
            limit: pageSize,
            offset: (currentPage - 1) * pageSize,
            order: []
        };

        if (sort_by && allowedSortColumns.includes(sort_by as string)) {
            options.order = [[sort_by as string, sort_order === 'desc' ? 'DESC' : 'ASC']];

        } else {
            options.order = [['id', 'ASC']];
        }

        const [errorLogs, totalErrorLogs] = await Promise.all([
            ErrorLog.findAll(options),
            ErrorLog.count({ where: whereClause }),
        ]);

        const responseData = {
            page: currentPage,
            limit: pageSize,
            total: totalErrorLogs,
            data: errorLogs
        }

        return res.status(200).json(responseData);

    }
    catch (error) {
        logger.error('Error fetching error log:');
        logger.error(error);
        return res.status(500).json({ error: 'Error fetching error log.' });
    }
}

const getErrorLogById = async (req: Request, res: Response) => {
    try {
        const { id } = req.params;
        const errorLog = await ErrorLog.findByPk(id);

        if (!errorLog) {
            return res.status(404).json({ error: 'Error log not found' });
        }

        return res.status(200).json(errorLog);
    } catch (error) {   
        logger.error('Error fetching error log:');
        logger.error(error);
        return res.status(500).json({ error: 'Error fetching error log.' });
    }
}

export { getErrorLogs, getErrorLogById }