'use strict';
const httpStatus = require('http-status');
const moment = require('moment');
const generateControllers = require('../../core/controllers');
const { buildContext } = require('../../core/controllers');
const notificationService = require('./notification.service');
const notificationDetailService = require('./notification_detail.service');
const userService = require('../auth/user.service');
const userDeviceService = require('./user_device.service');
const eventInscriptionService = require('../events/events_inscriptions.service');
const { usersIdsComposer } = require('../../helpers/composes.helper');
const pushHelper = require('../../helpers/push.helper');
const notificationHelper = require('../../helpers/notification.helpers')

const { extractParamsFromRequest, handleErrorResponse, handleResultResponse } = require('../../helpers/controller.helper');
const { get } = require('lodash');

// Module Name
const MODULE_NAME = '[notification.controller]';
const controllerOptions = { MODULE_NAME };


async function _sendNotificationAllActiveUsers(notification) {
    let limit = 4;
    let page = 1;

    let totalRows = 0;
    let totalPages = -1;

    do {
        let offset = (page - 1) * limit;
        let result = await userService._getActiveUserIds(offset, limit);

        if (totalPages == -1) {
            totalPages = Math.ceil(result.count / limit);
        }

        page = page + 1;

        let ids = result.rows.map(function (item) { return item.id });
        notificationService.sendNotification(notification, ids);


    } while (page <= totalPages);

    return 'OK';
}

async function _getUserIdsForEventId(eventId, segment) {
    let userIds = [];

    switch (segment) {
        //Todos los inscritos tanto invitados como libres
        case 'ALL_VALIDATED':
            userIds = await eventInscriptionService._getInscriptionByEventAndValidated(eventId, true);
            break;
        //Todos los de lista de espera tanto invitados como libres (Actualmente en invitados no hay lista de espera)
        case 'ALL_NOT_VALIDATED':
            userIds = await eventInscriptionService._getInscriptionByEventAndValidated(eventId, false);
            break;

        //Solo invitados como actualmente no se usa codigo de reserva para los coles, vale con filtrar por aquellos que tengan codigo de reserva
        case 'PARTNERS_ALL':
            userIds = await eventInscriptionService._getInscriptionByEventFromPartner(eventId);
            break;

        //Todos los inscritos al evento, tanto validados como en lista de espera 
        default: //ALL
            userIds = await eventInscriptionService._getInscriptionByEvent(eventId);
            break;
    }

    return usersIdsComposer(userIds);
}


const extraControllers = {

    sendNotification: (config) => {

        /**
                 * notificationSample = {
                 *  "tittle": "título de la notificación",
                 *  "message": "cuerpo de la notificación",
                 *  "recipients": {
                 * OPCION 1- Unos usuarios determinados
                 *      "userIds": ["*" | "f428a317-6d1f-4eda-aa3e-22baff3f48d7", ...] 
                 *      "segment": "ALL" | "LAST_YEAR" | "LAST_MONTH"
                 * 
                 * OPCION 2 - A todos los usuarios inscritos a un evento, se puede segmentar
                 *      "eventId": "xxx-xxx-xxx-xxx",
                 *      "segment": "ALL" | "ALL_VALIDATED" | "ALL_NOT_VALIDATED" |
                 *                 "PARTNERS_ALL" | "PARTNERS_VALIDATED" | "PARTNERS_NOT_VALIDATED" |
                 *                 "COLLEGE_ALL" | "COLLEGE_VALIDATED" | "COLLEGE_NOT_VALIDATED"
                 *  },
                 * "data": {
                 *      "type": "message",
                 *      "title": "Título del mensaje",
                 *      "message": "Cuerpo del mensaje",
                 *      "button": {
                 *          "caption": "Etiqueta del boton",
            *               "url": "https://www.site.es",
            *               "screen": "<RouterName>",
            *               "paramId": "23",
                 *      }
                 * }
                 *}
                 */

        return async (req, res, next) => {
            config = config || {
                scopes: [],
            };

            const context = buildContext(req, config);
            let params = extractParamsFromRequest(req, res);

            let receipt = undefined;
            let userIds = undefined;
            let eventId = undefined;
            let segment = undefined;
            const { body } = req;

            if (!body.title) {
                return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing message title'), res)
            }

            if (!body.body) {
                return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing body content'), res)
            }

            // Evento?
            if (body.recipients.eventId) {
                eventId = body.recipients.eventId;
                segment = body.recipients.segment;
            } else if (body.recipients.userIds) {
                userIds = body.recipients.userIds;
                segment = body.recipients.segment;
            } else {
                return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing user Ids or event Ids'), res)
            }


            try {

                let notification = notificationHelper.createNotification({
                    ...body,
                    userId: context.user.id
                });

                if ((userIds) && (userIds.length == 1) && (userIds[0] == "*")) {
                    receipt = _sendNotificationAllActiveUsers(notification);
                } else {

                    let _userIds = null;

                    if (userIds) {
                        _userIds = userIds;
                    } else {
                        if (eventId) {
                            _userIds = await _getUserIdsForEventId(eventId, segment);
                        } else {
                            return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing event and segment'), res)
                        }
                    }

                    if (_userIds) {
                        receipt = notificationService.sendNotification(notification, _userIds);
                    }
                }


                /*let getUserIds = async () => {
                    if (userIds) {
                        return new Promise(function(resolve) { resolve(userIds) } );                        
                    } else if (eventId) {
                        switch (segment) {
                            //Todos los inscritos tanto invitados como libres
                            case 'ALL_VALIDATED':
                                userIds = await eventInscriptionService._getInscriptionByEventAndValidated(eventId, true);
                                break;
                            //Todos los de lista de espera tanto invitados como libres (Actualmente en invitados no hay lista de espera)
                            case 'ALL_NOT_VALIDATED':
                                userIds = await eventInscriptionService._getInscriptionByEventAndValidated(eventId, false);
                                break;

                            //Solo invitados como actualmente no se usa codigo de reserva para los coles, vale con filtrar por aquellos que tengan codigo de reserva
                            case 'PARTNERS_ALL':
                                userIds = await eventInscriptionService._getInscriptionByEventFromPartner(eventId);
                                break;

                            //Todos los inscritos al evento, tanto validados como en lista de espera 
                            default: //ALL
                                userIds = await eventInscriptionService._getInscriptionByEvent(eventId);
                                break;
                        }
                        
                        return new Promise(function (resolve) { resolve(usersIdsComposer(userIds)); });

                    } else {
                        return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', new Error('Missing event and segment'), res)
                    }
                } */

                //receipt = notificationService.sendNotification(notification, await getUserIds());

                return handleResultResponse(receipt, null, null, res, httpStatus.OK);
            } catch (error) {
                console.error(error);
                return handleErrorResponse(controllerOptions.MODULE_NAME, 'sendNotification', error, res)
            }
        }
    },

    updateNotificationsWithReceipts: (config) => {
        return async (req, res, next) => {
            /*config = config || {
                scopes: [],
            };

            const context = buildContext(req, config);
            let params = extractParamsFromRequest(req, res);

            let getNotificationsWithoutReceipt = async () => {
                let params = {
                    where: {}
                };
                return await notificationDetailService.fetchAll(params, context);
            }

            let receipt = await Promise.all(getUserDevicesList).then(
                function (userDeviceList) {
                    return Promise.all(userDeviceList.map(buildMessagePromise))
                })
                .then(sendNotificationsPromise)
            */
        }
    },

    registerDevice: (config) => {
        return async (req, res, next) => {
            config = config || {
                scopes: [],
            };


            try {
                const context = buildContext(req, config);
                const userId = context.user && context.user.id ? context.user.id : null;


                let data = {
                    token: req.body.token,
                    valid: 1,
                    userId
                };


                let params = extractParamsFromRequest(req, res, {
                    includeAll: false,
                    paginate: { limit: 1, page: 1 },
                    params: {
                        token: data.token,
                    }
                });

                // Buscamos el token y el usuario
                console.log('>> Busco el token', params.params);
                let result = await userDeviceService.fetchOne(params, context);

                if (result) {
                    // Borramos el registro donde aparece el token
                    console.log('>> Borro el registro del token', params.params, data, context);
                    result = await userDeviceService.delete(params, context);
                }

                // Dar de alta el token
                console.log('>> Dar de alta el token', data);
                result = await userDeviceService.create(data, context);
            } catch (error) {
                console.error(error);
            }
            // En todo caso devolver OK al cliente
            return handleResultResponse('OK', null, null, res, httpStatus.OK);
        }
    },
};

module.exports = generateControllers(notificationService, extraControllers, controllerOptions);