const Area = require("../../models/area");
const Canton = require("../../models/canton");
const Cargo = require("../../models/cargo");
const Provincia = require("../../models/provincia");
const { Op } = require('sequelize');
const Rol = require("../../models/rol");
const Usuario = require("../../models/usuario");
const Usuario_Rol = require("../../models/usuario_rol");
const bcrypt = require('bcryptjs')
const jwt = require('../../services/jwt');
const Historial_Empresa = require("../../models/historial_empresa");
const Licencia = require("../../models/licencia");
const { where } = require("sequelize");

async function autenticarUsuario(req, res) {

    try {
        let params = req.body;
        console.log(params)
        const usuario = await Usuario.findOne({
            where: {
                ESTADO: 1,
                USUARIO: params.USUARIO
            },
            include: [
                {
                    model: Usuario_Rol,
                    as: 'USUARIO_ROL',
                    include: [
                        {
                            model: Rol
                        }
                    ]
                },
                {
                    model: Historial_Empresa,
                    as: 'HISTORIAL_EMPRESA',
                    required: false, // This ensures it doesn't filter out users without a history
                    where: {
                        ESTADO: true
                    },
                    include: [
                        {
                            model: Cargo,
                            include: [{ model: Area }]
                        }
                    ]
                }
            ]
        });
        if (!usuario) {
            res.status(402).send({ message: 'El Usuario no existe' });
        } else {
            if (params.getHash) {
                res.status(200).send({ token: jwt.createToken(usuario) });
            } else {
                let result = bcrypt.compareSync(params.CONTRASENIA, usuario.CONTRASENIA);
                if (result) {
                    res.status(200).send({
                        data: usuario
                    });
                } else {
                    res.status(402).send({ message: 'Error al ingresar, contraseña incorrecta.' });
                }

            }
        }
    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

//mantenimientos
async function obtenerUsuario(req, res) {
    try {

        const usuarioEncontrado = await Usuario.findOne({
            where: { ID_USUARIO: req.params.id },
            include: [
                {
                    model: Historial_Empresa,
                    as: 'HISTORIAL_EMPRESA',
                    required: false,
                    include: [
                        {
                            model: Cargo,
                            include: [
                                {
                                    model: Area
                                }
                            ]
                        }
                    ],
                    where: { ESTADO: true }
                },
                {
                    model: Usuario_Rol,
                    as: 'USUARIO_ROL',
                    include: [
                        {
                            model: Rol
                        }
                    ],
                    where: { ESTADO: 1 }
                }
            ]
        });

        if (usuarioEncontrado.USUARIO_ROL) {
            res.status(200).send({
                data: usuarioEncontrado,
            });
        } else {
            res.status(402).send({
                message: 'No existe usuario'
            });
        }

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

// genrecimaienos 
async function obtenerUsuarioLicencias(req, res) {
    try {

        const usuarioEncontrado = await Usuario.findOne({
            where: { ID_USUARIO: req.params.id },
            include: [
                {
                    model: Historial_Empresa,
                    as: 'HISTORIAL_EMPRESA',
                    required: false,
                    include: [
                        {
                            model: Cargo,
                            include: [
                                {
                                    model: Area
                                }
                            ]
                        }
                    ],
                    where: { ESTADO: true }
                },
                {
                    model: Usuario_Rol,
                    as: 'USUARIO_ROL',
                    include: [
                        {
                            model: Rol
                        }
                    ],
                    where: { ESTADO: 1 }
                }, {
                    model: Licencia,
                    as: 'LICENCIA',
                    required: false,
                    where: { ESTADO: 1 }
                }
            ]
        });

        console.log(usuarioEncontrado)

        if (usuarioEncontrado) {
            res.status(200).send({
                data: usuarioEncontrado,
            });
        } else {
            res.status(402).send({
                message: 'No existe usuario'
            });
        }

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

async function listarUsuariosActivosParaGerenciamiento(req, res) {
    try {

        const usuarioEncontrado = await Usuario.findAll({
            include: [
                {
                    model: Licencia,
                    as: 'LICENCIA',
                    required: true,
                    where: { ESTADO: 1 }
                }

            ]
        });


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

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

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
        });
    }
}


async function obtenerArea(req, res) {
    try {
        const area = await Area.findOne({ where: { ID_AREA: req.params.id } });


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


    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

async function obtenerAreasMultiples(req, res) {
    try {
        const ids = req.body.ids;
        
        const areasEncontradas = await Area.findAll({
            where: { 
                ID_AREA: {
                    [Op.in]: ids
                }
            }
        });

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

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

async function obtenerLicencia(req, res) {
    try {
        const licencia = await Licencia.findOne({ where: { ID_LICENCIA: req.params.id } });


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


    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

async function obtenerCorreosSupervisor(req, res) {
    try {


        const usuarioEncontrado = await Usuario.findAll({
            attributes: ['CORREO_EMPRESARIAL'],
            include: [
                {
                    model: Historial_Empresa,
                    as: 'HISTORIAL_EMPRESA',
                    required: true,
                    include: [
                        {
                            model: Cargo,
                            required: true,
                            include: [
                                {
                                    model: Area, where: { ID_AREA: req.params.id }, required: true
                                }
                            ]
                        }
                    ],
                    where: { ESTADO: true }
                },
                {
                    model: Usuario_Rol,
                    required: true,
                    as: 'USUARIO_ROL',
                    include: [
                        {
                            model: Rol,
                            required: true,
                            where: {
                                CODIGO: 3
                            }
                        }
                    ],
                    where: { ESTADO: 1 }
                }
            ]
        });


        console.log(usuarioEncontrado)

        if (usuarioEncontrado) {
            res.status(200).send({
                data: usuarioEncontrado,
            });
        } else {
            res.status(402).send({
                message: 'No existe usuario'
            });
        }

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}


async function obtenerCorreosHSE(req, res) {
    try {


        const usuarioEncontrado = await Usuario.findAll({
            attributes: ['CORREO_EMPRESARIAL'],
            include: [

                {
                    model: Usuario_Rol,
                    as: 'USUARIO_ROL',
                    include: [
                        {
                            model: Rol,
                            required: true,
                            where: {
                                CODIGO: 2
                            }
                        }
                    ],
                    where: { ESTADO: 1 }
                }
            ]
        });


        console.log(usuarioEncontrado)

        if (usuarioEncontrado) {
            res.status(200).send({
                data: usuarioEncontrado,
            });
        } else {
            res.status(402).send({
                message: 'No existe usuario'
            });
        }

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}


async function obtenerCorreosGerencia(req, res) {
    try {


        const usuarioEncontrado = await Usuario.findAll({
            attributes: ['CORREO_EMPRESARIAL'],
            include: [

                {
                    model: Usuario_Rol,
                    as: 'USUARIO_ROL',
                    include: [
                        {
                            model: Rol,
                            required: true,
                            where: {
                                CODIGO: 1
                            }
                        }
                    ],
                    where: { ESTADO: 1 }
                }
            ]
        });


        console.log(usuarioEncontrado)

        if (usuarioEncontrado) {
            res.status(200).send({
                data: usuarioEncontrado,
            });
        } else {
            res.status(402).send({
                message: 'No existe usuario'
            });
        }

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}
//nuevo metodo para obtener nombres para listado de gerennciamiento
async function obtenerNombresConductores(req, res) {
    try {
        const ids = req.body.ids; 
        
        const usuariosEncontrados = await Usuario.findAll({
            where: { 
                ID_USUARIO: {
                    [Op.in]: ids
                }
            },
            attributes: ['ID_USUARIO', 'NOMBRES', 'APELLIDOS'] // Solo nombre y apellido
        });

        if (usuariosEncontrados) {
            res.status(200).send({
                data: usuariosEncontrados,
            });
        } else {
            res.status(402).send({
                message: 'No existen usuarios'
            });
        }

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

// mi usuario

async function obtenerMiUsuario(req, res) {
    try {

        const usuarioEncontrado = await Usuario.findOne({
            where: { ID_USUARIO: req.params.id },
            include: [

                {
                    model: Canton,
                    // Incluir el modelo Area dentro de Cargo a través del historial de empresa
                },
                {
                    model: Historial_Empresa,
                    as: 'HISTORIAL_EMPRESA',
                    required: false,
                    include: [
                        {
                            model: Cargo,
                            include: [{ model: Area }] // Incluir el modelo Area dentro de Cargo
                        }
                    ],
                    where: { ESTADO: true } // Filtrar por estado activo en el historial de empresa
                },
                {
                    model: Usuario_Rol,
                    as: 'USUARIO_ROL', // Asegúrate de que este alias coincida con el definido en las asociaciones
                    include: [
                        {
                            model: Rol,
                            include: [{ model: Sistema }]
                        }
                    ],
                    where: { ESTADO: 1 } // Filtrar por estado 1 en Usuario_Rol
                }
            ]
        });

        if (usuarioEncontrado.USUARIO_ROL) {
            res.status(200).send({
                data: usuarioEncontrado,
            });
        } else {
            res.status(402).send({
                message: 'No existe usuario'
            });
        }

    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}

async function actualizarContrasenia(req, res) {
    try {

        let usuario = await Usuario.findOne({ where: { ID_USUARIO: req.params.id } });

        let result = bcrypt.compareSync(req.body.CONTRASENIA_ANTERIOR, usuario.CONTRASENIA);
        if (result) {

            let contraniaNueva = await bcrypt.hash(req.body.CONTRASENIA, 10);

            let usuarioActualizado = await Usuario.update({ CONTRASENIA: contraniaNueva }, { where: { ID_USUARIO: req.params.id } });
            if (usuarioActualizado) {
                res.status(200).send({ message: 'Contraseña actualizada' });
            } else {
                res.status(402).send({ message: 'No se ha podido actualizar la contraseña' });
            }

        } else {
            res.status(402).send({ message: 'La contrasenia anterior no coincide' });
        }



    } catch (e) {
        console.log(e)
        res.status(500).send({
            message: e.name
        });
    }
}
async function listarUsuariosActivosTarjetas(req, res) {
    try {
        const usuariosActivos = await Usuario.findAll({ 
            where: { ESTADO: 1 }
        });

        if (usuariosActivos.length > 0) {
            res.status(200).send({
                data: usuariosActivos,
            });
        } else {
            res.status(402).send({
                message: 'No existen usuarios activos registrados en la base de datos'
            });
        }
    } catch (err) {
        console.log(err);
        res.status(500).send({
            message: 'error:' + err
        });
    }
}

module.exports = {

    autenticarUsuario,
    obtenerUsuario,

    //GERENCIAMIETNOS
    obtenerUsuarioLicencias,
    listarUsuariosActivosParaGerenciamiento,
    listarAreas,
    obtenerCorreosSupervisor,
    obtenerArea,
    obtenerLicencia,
    obtenerCorreosHSE,
    obtenerCorreosGerencia,
    //TARJETAS STOP Y GERENCIAMIENTO
    obtenerNombresConductores,
    obtenerAreasMultiples,

    //TARJETAS STOP
    listarUsuariosActivosTarjetas,

    //Miperfil
    obtenerMiUsuario,
    actualizarContrasenia

};