src/controllers/setting.controller.ts

import { Request, Response } from 'express';
import Setting from '../models/settings';
import { Op, FindOptions } from 'sequelize';
import { logger } from '../utils/logger';

const buildSettingsWhereClause = (filter: Record<string, any>): 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.updated_by) {
            whereClause.updated_by = { [Op.eq]: filter.updated_by };
        }

        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 getSettings = 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', 'updated_by', 'created_at'];

        const whereClause = buildSettingsWhereClause(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 [settings, totalSettings] = await Promise.all([
            Setting.findAll(options),
            Setting.count({ where: whereClause }),
        ]);

        const responseData = {
            page: currentPage,
            limit: pageSize,
            total: totalSettings,
            data: settings
        };

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

    catch (error) {

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

const getSettingById = async (req: Request, res: Response) => {
    try {
        const { id } = req.params;

        const setting = await Setting.findByPk(id);

        if (!setting) {
            return res.status(404).json({ error: 'Setting not found' });
        }

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

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

        const { id } = req.params;
        const {setting_key, setting_value} = req.body;

        const setting = await Setting.findByPk(id);

        if (!setting) {
            return res.status(404).json({ error: 'Setting not found' });
        }

        if(setting_key){
            setting.setting_key = setting_key;
        }
        if(setting_value){
            setting.setting_value = setting_value;
        }

        //  TODO: to change it once we have authentication in place
        setting.updated_by = 1;

        await setting.save();

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

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

export { getSettings, getSettingById, updateSettingById };