const routes = require('express').Router();

const { isAdministratorUser, isLoggedUser } = require('../../middlewares/accessValidator');
const SchemaValidator = require('../../middlewares/schemaValidator');

const { cacheSuccesses } = require('../../middlewares/cache');
const PaginateMiddleware = require('../../middlewares/paginate');
const FieldMiddleware = require('../../middlewares/fields');
const SortMiddleware = require('../../middlewares/sort');

const eventController = require('./event.controller');
const eventInscriptionController = require('./events_inscriptions.controller');
const eventReservationController = require('./events_reservations.controller');
const eventQuestionController = require('./events_questions.controller');
const eventValidation = require('./event.validations');

const generalInvalidFields = [
    'userId', 'createdAt', 'updatedAt',
    'assistants', 'confirmed', 'allow_multiple', 'overflow_eventId',
    'state', 'confirmed', 
    'multiple_limit', 'marketing_list',
];

routes.get('/events', 
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    (req, res, next) => {
        if (!req.body.locationId)
            return eventController.find({
                scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails'],
            })(req, res, next)
        else
            return eventController.find({
                scopes: ['defaultScope', 'includeVenue', 'includeMultimediaAvatar', 'includeDetails', { method: ['onlyOfLocation', req.body.locationId] }]
            })(req, res, next);
    } 
);

routes.get('/events/cities',
    isLoggedUser,
    cacheSuccesses('24 hours'),
    eventController.find({
        scopes: ['CitiesOfEvents']
    })
);


routes.get('/events/next',
    isLoggedUser, 
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "name" }), 
    (req, res, next) => {
   //     console.log(moment().add(1, 'days').startOf('day').format('YYYY-MM-DD HH:mm:ss'));
        return eventController.find({
            scopes: ['defaultScope', 'next', 'includeVenue', 'includeMultimedias', { method: ['includeInscription', req.user.id] }],
        })(req, res, next)
    } 

);

routes.get('/events/past', 
    isLoggedUser,
    cacheSuccesses('1 minute'),
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    eventController.find({
       scopes: ['defaultScope', 'past', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/events/yesterday',
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),
    eventController.find({
        scopes: ['defaultScope', 'yesterday', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);


routes.get('/events/today',
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),
    eventController.find({
        scopes: ['defaultScope', 'today', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);


/*routes.get('/events/today',
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),

    (req, res, next) => {
        eventController.find({
            scopes: ['defaultScope', 'next', 'includeVenue', 'includeMultimedias', { method: ['includeInscription', req.user.id] }],
            })(req, res, next)
        .then (function (events) {
            console.log('>>>> ', events); //.stateCode = 'current_event';
            return events;
        });

    } 
);*/



routes.get('/events/tomorrow',
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),
    eventController.find({
        scopes: ['defaultScope', 'tomorrow', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/events/current', 
    isLoggedUser,
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    eventController.find({
        scopes: ['defaultScope', 'current', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

// Eventos destacados
routes.get('/events/featured',
    isLoggedUser,
    cacheSuccesses('1 minute'),
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    eventController.find({
        scopes: ['defaultScope', 'includeVenue', 'includeMultimediaAvatar', 'featured']        
    })
);

routes.get('/events/:id', 
    isLoggedUser, 
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),    
    (req, res, next) => {
        return eventController.findOne({
            scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails', 'includeComments', { method: ['includeInscription', req.user.id] }]
        })(req, res, next)
    } 
);

// Comentarios

routes.get('/events/:id/comments',
    isLoggedUser, 
    (req, res, next) => {
        req.params.association = 'Comments';
        next();
    },
    eventController.find,

);

// Multimedias
routes.get('/events/:id/multimedias',
    isLoggedUser, 
    (req, res, next) => {
        req.params.association = 'Multimedias';
        next();
    },
    eventController.find,
);

// Inscripciones
// Esto da las inscripciones de un usuario
routes.get('/events/:id/inscriptions', 
    isLoggedUser,
    eventController.getInscriptions,
);


// Esto da todas las inscripciones de un usuario
routes.get('/me/inscriptions/count',
    isLoggedUser,
    /*(req, res, next) => {
        req.apicacheGroup = req.user.id;
        next();
    },
    cacheSuccesses('1 hour'),*/
    eventController.getInscriptionsOfNextEventsCount,
);

// Esto da todas las inscripciones de un usuario
routes.get('/me/inscriptions',
    isLoggedUser,
    /*(req, res, next) => {
        req.apicacheGroup = req.user.id;
        next();
    },
    cacheSuccesses('1 hour'),*/
    eventController.getInscriptions,
);

routes.get('/me/inscriptions/:id/mail',
    isLoggedUser,
    //cacheSuccesses('1 hour'),
    eventController.sendMailTicket,
);

// Esto da la inscripción de un usuario
routes.get('/me/inscriptions/:id',
    isLoggedUser,
    /*(req, res, next) => {
        req.apicacheGroup = req.user.id;
        next();
    },
    cacheSuccesses('1 hour'),*/
    eventController.getInscription,
);


// Hacer una inscripción
routes.post('/events/:id/inscriptions',
    isLoggedUser, 
    SchemaValidator(eventValidation.InscriptionInputType, true), 
    eventController.createInscription
);

// Hacer una pregunta
routes.post('/events/:eventId/questions',
    isLoggedUser,
    SchemaValidator(eventValidation.EventQuestionInputType, true),
    eventQuestionController.create()
);

// Borrar una inscripción
routes.delete('/inscriptions/:id',
    isLoggedUser, 
    //SchemaValidator(eventValidation.InscriptionInputType, true),     
    eventController.deleteInscription
);

// Imagen del código QR de una inscripción
routes.get('/inscriptions/:id/qrimage', 
    eventController.getQRCodeImage,
);


routes.get('/events/:id/reservations/:encodedInvitationCode',
    isLoggedUser, 
    //eventController.findComments
    eventController.checkReservationCode
);




//WEB

//Eventos con inscripciones abiertas para la web
routes.get('/web/events',
    //    isLoggedUser,
    FieldMiddleware.middleware({
        validFields: ['id', 'name']
    }),
    //    PaginateMiddleware.middleware(),
    //    SortMiddleware.middleware({ default: "init_available_date" }),
    eventController.find({
        scopes: ['defaultScope', 'withOpenInscriptions']
    }),
);

// Hacer una inscripción por la web
routes.post('/web/events/:id/inscriptions',
    SchemaValidator(eventValidation.webInscriptionInputType, true),
    eventController.createInscription
);

// Comprobar si estoy inscrito al congreso por la web
routes.get('/web/events/:id/inscriptions/:email',
    eventController.checkInscription
);


/*
routes.get('/tickets/:id/',
    isLoggedUser,
    eventController.findComments
);
*/

//routes.get('/venues', isLoggedUser, SortMiddleware.middleware({ default: "name" }), venueController.find);
//routes.get('/venues/:id', isLoggedUser, venueController.findOne);

//routes.post('/entity/', SchemaValidator(VenueValidation.VenueInputType, true), venueController.create);
//routes.put('/venues/:id', isAdministratorUser, venueController.update);
//routes.delete('/venues/:id', isAdministratorUser, venueController.delete);



/********************************************************************************************************
 *  ADMINISTRACIÓN   
 ********************************************************************************************************* 
 */
// Inscripciones
// Esto da las inscripciones de un evento
routes.get('/admin/events/:id/inscriptions',
    isAdministratorUser,
    eventController.getInscriptions,
);

// Todos los ponentes
routes.get('/admin/events',
    isAdministratorUser,
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }), 
    (req, res, next) => {
        if (!req.body.city)
            return eventController.find({
                scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails'],
            })(req, res, next)
        else
            return eventController.find({
                scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails', { method: ['onlyOfCity', req.body.city] }]
            })(req, res, next);
    }
);

routes.get('/admin/events/next',
    isAdministratorUser,
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "init_available_date" }),
    eventController.find({
        scopes: ['defaultScope', 'next', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/admin/events/past',
    isAdministratorUser,
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),
    eventController.find({
        scopes: ['defaultScope', 'past', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/admin/events/current',
    isAdministratorUser,
    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-init_date" }),
    eventController.find({
        scopes: ['defaultScope', 'current', 'includeVenue', 'includeMultimedias', 'includeDetails'],
    }),
);

routes.get('/admin/events/:id',
    isAdministratorUser,
    (req, res, next) => {
        return eventController.findOne({
            scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeOverflowEvent', 'includeDetails']
        })(req, res, next)
    }
);

routes.get('/admin/events/:id/partners',
    isAdministratorUser,
    eventController.findPartners,    
);

routes.get('/admin/events/:id/colleges',
    isAdministratorUser,
    eventController.findColleges,
);

routes.get('/admin/events/:id/reservations/excel',
    isAdministratorUser,
    eventReservationController.getReservationsExcel,
);

routes.get('/admin/events/:id/reservations/:type/excel',
    isAdministratorUser,
    eventReservationController.getReservationsExcel,
);

routes.get('/admin/events/:id/inscriptions/excel',
    isAdministratorUser,
    eventController.getInscripcionsExcel,
);

routes.get('/admin/events/:id/reservations/:type/mail',
    isAdministratorUser,
    eventReservationController.sendMailReservationsEvent,
);

routes.get('/admin/events/:id/entity/:entityId/reservations/mail',
    isAdministratorUser,
    eventReservationController.sendMailReservationsEvent,
);


routes.get('/admin/events/:eventId/partners/:entityId/reservations',
    isAdministratorUser,
    eventReservationController.find(),
);

routes.get('/admin/events/:eventId/questions',
    isAdministratorUser,
    //    PaginateMiddleware.middleware(),
    SortMiddleware.middleware({ default: "-createdAt" }),
    eventQuestionController.find({
        scopes: ['includeUser', 'includeSpeaker'],
    }),
);


routes.get('/admin/reservations/:id',
    isAdministratorUser,
    //SchemaValidator(eventValidation.ReservationInputType, true),
    (req, res, next) => {
        return eventReservationController.findOne({
            scopes: ['includeEvent', 'includeInscriptions']
        })(req, res, next)
    },

);

routes.get('/admin/inscriptions/:id/mail',
    isAdministratorUser,
    //cacheSuccesses('1 hour'),
    eventController.sendMailTicket,
);

routes.get('/admin/reservations/:id/mail',
    isAdministratorUser,
    eventReservationController.sendMailReservation,
);


routes.post('/admin/reservations',
    isAdministratorUser,
    //SchemaValidator(eventValidation.ReservationInputType, true),
    eventReservationController.create(),

);

routes.put('/admin/reservations/:id',
    isAdministratorUser,
    //SchemaValidator(eventValidation.ReservationInputType, true),
    eventReservationController.update(),
);

//Valida una inscripción
routes.put('/admin/inscriptions/:id',
    isAdministratorUser,
    //SchemaValidator(eventValidation.ReservationInputType, true),
    eventController.validateInscription,
);

// Borrar reserva
routes.delete('/admin/reservations/:id',
    isAdministratorUser,
    eventReservationController.delete()
);



/********************************************************************************************************
 *  LIVE
 *********************************************************************************************************
 */
routes.get('/live/events/:id',
    FieldMiddleware.middleware({
        invalidFields: generalInvalidFields
    }),
    (req, res, next) => {
        return eventController.findOne({
            scopes: ['defaultScope', 'includeVenue', 'includeMultimedias', 'includeDetails']
        })(req, res, next)
    }
);

routes.get('/live/events/:eventId/speakers/:speakerId/questions',
    SortMiddleware.middleware({ default: "-createdAt" }),
    eventQuestionController.find({
        scopes: ['includeUser', 'includeSpeaker'],
    }),
);

routes.put('/live/questions/:id',
    eventQuestionController.update(),
);


module.exports = routes;