'use strict';

const toUpper = (val) => (typeof val === 'string' && val) ? val.toUpperCase().trim() : val;

const RegistroAlimentacion = require('../models/registroAlimentacion');
const Usuario = require('../models/usuario');
const Local = require('../models/local');
const { Op } = require('sequelize');
const moment = require('moment-timezone');
const HistorialEmpresa = require('../models/historial_empresa'); 
const Cargo = require('../models/cargo');
const Area = require('../models/area');

// Registrar alimentación del usuario actual
async function registrarAlimentacion(req, res) {
    try {
        const { ID_USUARIO, TIPO_COMIDA, ID_LOCAL, OBSERVACION } = req.body;

        if (!ID_LOCAL) {
            return res.status(400).send({
                message: 'Debe seleccionar un local'
            });
        }

        const fechaActual = moment().tz('America/Guayaquil').format('YYYY-MM-DD');
        const horaActual = moment().tz('America/Guayaquil').format('HH:mm:ss');

        // Verificar si ya registró ese tipo de comida hoy
        const registroExistente = await RegistroAlimentacion.findOne({
            where: {
                ID_USUARIO,
                FECHA: fechaActual,
                TIPO_COMIDA,
                ESTADO: true
            }
        });

        if (registroExistente) {
            return res.status(400).send({
                message: `Ya has registrado ${TIPO_COMIDA.toLowerCase()} el día de hoy`
            });
        }

        const nuevoRegistro = await RegistroAlimentacion.create({
            ID_USUARIO,
            ID_LOCAL,
            FECHA: fechaActual,
            HORA: horaActual,
            TIPO_COMIDA,
            OBSERVACION: toUpper(OBSERVACION) || null,
            ESTADO: true
        });

        res.status(201).send({
            message: 'Alimentación registrada exitosamente',
            data: nuevoRegistro
        });

    } catch (e) {
        console.log('Error registrarAlimentacion:', e);
        res.status(500).send({
            message: e.name || 'Error al registrar la alimentación'
        });
    }
}

// Obtener registros de alimentación del usuario actual del día de hoy
async function obtenerMisRegistrosHoy(req, res) {
    try {
        const { idUsuario } = req.params;
        const fechaHoy = moment().tz('America/Guayaquil').format('YYYY-MM-DD');

        const registros = await RegistroAlimentacion.findAll({
            where: {
                ID_USUARIO: idUsuario,
                FECHA: fechaHoy,
                ESTADO: true
            },
            order: [['HORA', 'DESC']]
        });

        res.status(200).send({
            data: registros
        });

    } catch (e) {
        console.log('Error obtenerMisRegistrosHoy:', e);
        res.status(500).send({
            message: e.name || 'Error al obtener registros'
        });
    }
}

// Obtener reporte de alimentación del día (para colaborador de cocina)
async function obtenerReporteAlimentacionDia(req, res) {
    try {
        const { fecha, idLocal } = req.body;
        const fechaBusqueda = fecha || moment().tz('America/Guayaquil').format('YYYY-MM-DD');

        const whereCondition = {
            FECHA: fechaBusqueda,
            ESTADO: true
        };

        // Filtro por local
        if (idLocal && idLocal !== 0 && idLocal !== null) {
            whereCondition.ID_LOCAL = idLocal;
        }

        const registros = await RegistroAlimentacion.findAll({
            where: whereCondition,
            include: [
                {
                    model: Usuario,
                    attributes: ['ID_USUARIO', 'IDENTIFICACION', 'NOMBRES', 'APELLIDOS']
                },
                {
                    model: Local,
                    attributes: ['ID_LOCAL', 'NOMBRE'],
                    required: false
                }
            ],
            order: [['TIPO_COMIDA', 'ASC'], ['HORA', 'ASC']]
        });

        // Contar por tipo de comida
        const desayunos = registros.filter(r => r.TIPO_COMIDA === 'DESAYUNO').length;
        const almuerzos = registros.filter(r => r.TIPO_COMIDA === 'ALMUERZO').length;
        const meriendas = registros.filter(r => r.TIPO_COMIDA === 'MERIENDA').length;

        // Contar por local
        const porLocal = {};
        registros.forEach(r => {
            const nombreLocal = r.LOCAL?.NOMBRE || 'Sin local';
            porLocal[nombreLocal] = (porLocal[nombreLocal] || 0) + 1;
        });

        res.status(200).send({
            data: registros,
            resumen: {
                fecha: fechaBusqueda,
                total: registros.length,
                desayunos,
                almuerzos,
                meriendas,
                porLocal
            }
        });

    } catch (e) {
        console.log('Error obtenerReporteAlimentacionDia:', e);
        res.status(500).send({
            message: e.name || 'Error al obtener reporte'
        });
    }
}

async function obtenerReporteAlimentacion(req, res) {
    try {
        const { fechaInicio, fechaFin, tipoComida, idLocal, idArea } = req.body;

        const whereCondition = { ESTADO: true };

        if (fechaInicio && fechaFin) {
            whereCondition.FECHA = { [Op.between]: [fechaInicio, fechaFin] };
        } else if (fechaInicio) {
            whereCondition.FECHA = { [Op.gte]: fechaInicio };
        } else if (fechaFin) {
            whereCondition.FECHA = { [Op.lte]: fechaFin };
        }

        if (tipoComida && tipoComida !== 'TODOS') {
            whereCondition.TIPO_COMIDA = tipoComida;
        }

        if (idLocal && idLocal !== 0) {
            whereCondition.ID_LOCAL = idLocal;
        }

        const includeUsuario = {
            model: Usuario,
            attributes: ['ID_USUARIO', 'IDENTIFICACION', 'NOMBRES', 'APELLIDOS']
        };

        if (idArea) {
            includeUsuario.include = [
                {
                    model: HistorialEmpresa,
                    as: 'HISTORIAL_EMPRESA',
                    required: true,
                    where: { ESTADO: true },
                    include: [
                        {
                            model: Cargo,
                            required: true,
                            where: { ID_AREA: idArea },
                            include: [{ model: Area }]
                        }
                    ]
                }
            ];
        }

        const registros = await RegistroAlimentacion.findAll({
            where: whereCondition,
            include: [
                includeUsuario,
                { model: Local, attributes: ['ID_LOCAL', 'NOMBRE'], required: false }
            ],
            order: [['FECHA', 'DESC'], ['HORA', 'DESC']]
        });

        res.status(200).send({
            data: registros,
            resumen: {
                total: registros.length,
                desayunos: registros.filter(r => r.TIPO_COMIDA === 'DESAYUNO').length,
                almuerzos: registros.filter(r => r.TIPO_COMIDA === 'ALMUERZO').length,
                meriendas: registros.filter(r => r.TIPO_COMIDA === 'MERIENDA').length
            }
        });

    } catch (e) {
        console.log('Error obtenerReporteAlimentacion:', e);
        res.status(500).send({ message: e.name || 'Error al obtener reporte' });
    }
}


// Obtener estadísticas para tarjetas del dashboard
async function obtenerEstadisticasAlimentacion(req, res) {
    try {
        const { fecha } = req.body;
        const fechaBusqueda = fecha || moment().tz('America/Guayaquil').format('YYYY-MM-DD');

        const registros = await RegistroAlimentacion.findAll({
            where: {
                FECHA: fechaBusqueda,
                ESTADO: true
            }
        });

        const desayunos = registros.filter(r => r.TIPO_COMIDA === 'DESAYUNO').length;
        const almuerzos = registros.filter(r => r.TIPO_COMIDA === 'ALMUERZO').length;
        const meriendas = registros.filter(r => r.TIPO_COMIDA === 'MERIENDA').length;

        res.status(200).send({
            data: {
                fecha: fechaBusqueda,
                total: registros.length,
                desayunos,
                almuerzos,
                meriendas
            }
        });

    } catch (e) {
        console.log('Error obtenerEstadisticasAlimentacion:', e);
        res.status(500).send({
            message: e.name || 'Error al obtener estadísticas'
        });
    }
}
async function listarAreas(req, res) {
    try {
        const areas = await Area.findAll({ where: { ESTADO: 1 } });


        res.status(200).send({
            data: areas,
        });


    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}
module.exports = {
    registrarAlimentacion,
    obtenerMisRegistrosHoy,
    obtenerReporteAlimentacionDia,
    obtenerReporteAlimentacion,
    obtenerEstadisticasAlimentacion,
    listarAreas
};
